@zlink-systems/framework 0.10.0

package/dist/runtime/host/index.js

@@ -0,0 +1,2552 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkUserSpotCreationCoordinator = exports.ZLinkHostSpotAddressTransport = exports.ZLinkRelocationStateIncompatibleError = exports.ZLinkRouteMeshRuntimeCoordinator = exports.ZLinkRetiringRollbackError = exports.transferIdString = exports.ZLinkActorTransferAuthorityRuntime = exports.ZLinkFrameworkRuntimeHost = void 0;
+exports.hasUnsupportedManualTopology = hasUnsupportedManualTopology;
+exports.hasExactPeerReadiness = hasExactPeerReadiness;
+const framework_errors_internal_1 = require("../framework-errors-internal");
+const node_crypto_1 = require("node:crypto");
+const runtime_message_1 = require("../backend/runtime-message");
+const runtime_values_1 = require("../backend/runtime-values");
+const service_runtime_contracts_1 = require("../foundation/service-runtime-contracts");
+const runtime_state_projections_1 = require("../foundation/runtime-state-projections");
+const abort_1 = require("../abort");
+const backend_1 = require("../backend");
+const LEGACY_MESH_SEND_TIMEOUT_MS = 1000;
+const contracts_1 = require("../../contracts");
+const submission_result_1 = require("../messaging/submission-result");
+const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
+const DiagnosticsValidation_1 = require("../../contracts/Configuration/DiagnosticsValidation");
+const channels_1 = require("../channels");
+const channel_envelope_1 = require("../channels/channel-envelope");
+const actors_1 = require("../actors");
+const actor_transport_delivery_gate_1 = require("../actors/actor-transport-delivery-gate");
+const application_job_queue_handler_start_gate_1 = require("../application-jobs/application-job-queue-handler-start-gate");
+const execution_1 = require("../execution");
+const diagnostics_1 = require("../diagnostics");
+const topology_runtime_projections_1 = require("../diagnostics/topology-runtime-projections");
+const runtime_observation_queue_1 = require("../diagnostics/runtime-observation-queue");
+const spots_1 = require("../spots");
+const actor_message_follow_context_1 = require("../actors/actor-message-follow-context");
+const actors_2 = require("../actors");
+const streams_1 = require("../streams");
+const locations_1 = require("../locations");
+const Locations_1 = require("../../contracts/Locations");
+const actor_runtime_options_factory_1 = require("./actor-runtime-options-factory");
+const actor_transfer_runtime_1 = require("./actor-transfer-runtime");
+const actor_transfer_authority_runtime_1 = require("./actor-transfer-authority-runtime");
+const entry_actor_runtime_1 = require("./entry-actor-runtime");
+const location_runtime_owner_1 = require("./location-runtime-owner");
+const mesh_router_resolver_1 = require("./mesh-router-resolver");
+const bound_session_relay_1 = require("./bound-session-relay");
+const routing_id_1 = require("../routing-id");
+const service_authority_payload_codec_1 = require("../foundation/service-authority-payload-codec");
+const service_relocation_runtime_1 = require("../foundation/service-relocation-runtime");
+const spot_runtime_options_factory_1 = require("./spot-runtime-options-factory");
+const channel_runtime_options_factory_1 = require("./channel-runtime-options-factory");
+const spot_node_runtime_options_factory_1 = require("./spot-node-runtime-options-factory");
+const runtime_shutdown_1 = require("./runtime-shutdown");
+const admission_1 = require("../admission");
+const route_mesh_runtime_1 = require("./route-mesh-runtime");
+const ConfigurationException_1 = require("../../contracts/Configuration/ConfigurationException");
+const stateful_authority_route_runtime_1 = require("./stateful-authority-route-runtime");
+const instance_activation_authority_1 = require("./instance-activation-authority");
+const spot_address_transport_1 = require("./spot-address-transport");
+const user_spot_creation_coordinator_1 = require("./user-spot-creation-coordinator");
+const actor_placement_coordinator_1 = require("./actor-placement-coordinator");
+const payload_codec_1 = require("../messaging/payload-codec");
+const creation_payload_codec_1 = require("../messaging/creation-payload-codec");
+const route_mesh_runtime_options_1 = require("./route-mesh-runtime-options");
+const service_relocation_host_runtime_1 = require("./service-relocation-host-runtime");
+const application_job_queue_1 = require("./application-job-queue");
+const application_job_queue_scope_1 = require("../application-jobs/application-job-queue-scope");
+const host_capacity_status_1 = require("./host-capacity-status");
+class ZLinkFrameworkRuntimeHost {
+    options;
+    backendAdapterFactory;
+    lifecycleSink;
+    executionState;
+    runtimeState = contracts_1.ZLinkFrameworkRuntimeState.Preparing;
+    runtimeSequence = 0n;
+    runtimeObservationSource = Symbol('zlink.framework-runtime');
+    runtimeDeadline;
+    runtimeRelocationResult;
+    runtimeTerminationResult;
+    relocationOperation;
+    relocationStopStarting;
+    relocationOperationKey;
+    relocationOperationStartedAt;
+    shutdownOperation;
+    shutdownOperationStartedAt;
+    relocationTargetApplicationVersion;
+    runtimeObservers = new Set();
+    channelRuntime;
+    spotNodeRuntime;
+    streamRuntime;
+    statefulAuthorityRoutes;
+    locationOwner;
+    meshRouters;
+    boundSessionRelay;
+    actorHandoff;
+    actorTransferRegistry;
+    actorTransferRuntime;
+    actorTransferAuthorityRuntime;
+    serviceRelocation;
+    entryActorRuntime;
+    actorManager;
+    actorPlacement;
+    spotManager;
+    ownerLeaseRecoveryRuntime;
+    ownerLeaseRecoveryHandler;
+    ownerLeaseFailureHandler;
+    registerUserSpotHandlers;
+    destroyedActorRefs = new Map();
+    runtimeEventPublisher;
+    metrics;
+    applicationJobQueue;
+    capacityStatus;
+    metricRegistrations = [];
+    admission = new admission_1.ZLinkRuntimeAdmissionGate();
+    cachedLocationSpotRouteResolver;
+    actorClientLocationResolver;
+    // Shared, runtime-mutable message-flow mode cell — installed once so
+    // setMessageFlowMode flips every surface live. Seeded from config at start().
+    messageFlowModeCell = {
+        mode: 'errors'
+    };
+    dispatchErrorReporters = new WeakMap();
+    runtimeOrPreStartErrorSink = {
+        reportRuntimeTaskException: (taskName, error) => (this.errorSink ?? this.preStartErrorSink).reportRuntimeTaskException(taskName, error)
+    };
+    cachedDiagnosticsContext;
+    preStartErrorSink = new execution_1.ZLinkRuntimeTaskErrorSink();
+    channelTransport = () => this.channelRuntime;
+    channelRuntimeOptions = new channels_1.DefaultZLinkChannelRuntimeOptions(() => this.channelRuntime);
+    routeMeshRuntimeOptions = new route_mesh_runtime_options_1.DefaultZLinkRouteMeshRuntimeOptions(() => this.spotNodeRuntime);
+    routeTransport;
+    spotAddressTransport;
+    spotPublisherTransport = new spots_1.ZLinkRuntimeSpotPublisherTransport(() => this.spotNodeRuntime);
+    streamBindingRuntime;
+    boundSessionFactory;
+    spotRouterChannelIdForMesh;
+    routeMeshRuntime;
+    clientServerRuntime;
+    fanoutRuntime;
+    routeMeshCoordinator;
+    constructor(options, internalOptions) {
+        this.options = options;
+        this.backendAdapterFactory = resolveBackendAdapterFactory(internalOptions);
+        this.lifecycleSink = options.lifecycleSink;
+        this.runtimeEventPublisher = options.runtimeEventPublisher ?? new diagnostics_1.DefaultZLinkRuntimeEventPublisher();
+        this.metrics = new diagnostics_1.ZLinkRuntimeMetrics(options.registration.metrics?.meterProvider);
+        this.applicationJobQueue = new application_job_queue_1.ApplicationJobQueue((0, application_job_queue_1.resolveApplicationJobQueueConfiguration)(options.registration.applicationJobQueue, () => (0, application_job_queue_1.nodeEffectiveProcessorCount)(options.registration.worker?.maxThreads)), undefined, () => {
+            try {
+                return this.options.providerResolver?.get?.(application_job_queue_handler_start_gate_1.ZLINK_INTERNAL_APPLICATION_JOB_QUEUE_HANDLER_START_GATE)?.shouldHoldPermitBeforeHandler() === true;
+            }
+            catch {
+                return false;
+            }
+        });
+        this.capacityStatus = new host_capacity_status_1.HostCapacityStatusProjection(options.registration.coreHwm, this.applicationJobQueue);
+        this.clientServerRuntime = new topology_runtime_projections_1.ZLinkClientServerRuntimeProjection(() => this.channelRuntime, () => this.runtimeState);
+        this.fanoutRuntime = new topology_runtime_projections_1.ZLinkFanoutRuntimeProjection(() => this.channelRuntime, () => this.runtimeState);
+        this.meshRouters = new mesh_router_resolver_1.MeshRouterResolver(options.registration);
+        this.spotRouterChannelIdForMesh = this.meshRouters.spotRouterChannelIdByMesh();
+        const sendTimeoutMsForSpotMesh = (meshName) => options.registration.spotNodes.get(meshName)?.router?.sendTimeoutMs
+            ?? LEGACY_MESH_SEND_TIMEOUT_MS;
+        const sendTimeoutMsForSpotRouteChannel = (routeChannelId) => {
+            const routeChannel = options.registration.routeChannelOptions.get(routeChannelId);
+            if (routeChannel !== undefined) {
+                return routeChannel.sendTimeoutMs ?? LEGACY_MESH_SEND_TIMEOUT_MS;
+            }
+            return sendTimeoutMsForSpotMesh(routeChannelId);
+        };
+        const defaultSpotSendTimeoutMs = Math.max(LEGACY_MESH_SEND_TIMEOUT_MS, ...[...options.registration.spotNodes.values()].map(node => node.router?.sendTimeoutMs ?? LEGACY_MESH_SEND_TIMEOUT_MS), ...[...options.registration.routeChannelOptions.values()].map(route => route.sendTimeoutMs ?? LEGACY_MESH_SEND_TIMEOUT_MS));
+        this.routeTransport = new channels_1.ZLinkRuntimeRouteTransport(() => this.channelRuntime, (routerChannelId) => this.meshRouters.canUseRouterChannel(routerChannelId), () => this.spotNodeRuntime, { serializers: options.registration.messageSerializers }, (meshName, targetNodeRid) => this.meshRouters.classifyManualNodeTarget(meshName, targetNodeRid), (meshName, sourceNodeRid, parts) => this.submitLocalMeshRoute(meshName, sourceNodeRid, parts), this.metrics);
+        this.spotAddressTransport = new spot_address_transport_1.ZLinkHostSpotAddressTransport({
+            resolver: () => this.createLocationSpotRouteResolver(),
+            routed: this.routeTransport,
+            meshNames: () => [...this.options.registration.spotNodes]
+                .filter(([, node]) => (0, spot_address_transport_1.hasObjectClientCapability)(node.objectRole))
+                .map(([meshName]) => meshName),
+            isMeshConfigured: (meshName) => this.options.registration.spotNodes.has(meshName),
+            meshNode: (meshName) => this.spotNodeRuntime?.meshNode(meshName),
+            completions: (meshName) => this.spotNodeRuntime?.meshCompletionTable(meshName),
+            codecs: { serializers: options.registration.messageSerializers },
+            defaultRequestTimeoutMs: options.registration.requestTimeoutMs ?? 30_000,
+            defaultSendTimeoutMs: defaultSpotSendTimeoutMs,
+            sendTimeoutMsForMesh: sendTimeoutMsForSpotMesh,
+            sendTimeoutMsForRouteChannel: sendTimeoutMsForSpotRouteChannel,
+            dispatchErrors: this.createDispatchErrorReporter(this.runtimeOrPreStartErrorSink)
+        });
+        this.locationOwner = new location_runtime_owner_1.ZLinkLocationRuntimeOwner({
+            registration: options.registration,
+            runtimeEventPublisher: this.runtimeEventPublisher,
+            metrics: this.metrics,
+            fallbackNodeRid: `node-${(0, node_crypto_1.randomUUID)()}`,
+            rewriteAuthorityPayloadForOwner
+        });
+        this.streamBindingRuntime = new streams_1.ZLinkStreamBindingRuntime({
+            streamPayloadCodec: resolveStreamPayloadCodec(options.registration),
+            streamCompression: options.registration.streamCompression,
+            messageSerializers: options.registration.messageSerializers,
+            sessionRelocationSealTimeoutMs: options.registration.locations.options.sessionRelocationSealTimeoutMs
+                ?? Locations_1.zlinkDefaultLocationOptions.sessionRelocationSealTimeoutMs,
+            metrics: this.metrics,
+            flowCreationEnabled: () => this.flowCreationEnabled(),
+            errorSink: () => this.errorSink ?? this.preStartErrorSink,
+            nativeActorNodeProvider: () => this.spotNodeRuntime?.primaryMeshNode,
+            nativeActorMeshNameProvider: () => this.meshRouters.primaryMeshName(),
+            actorAuthorityFenceResolver: async (actorId, signal) => {
+                const resolution = await this.createActorLocationResolver()
+                    ?.resolveDirectActorRoute(actorId, signal);
+                return resolution === undefined || resolution.kind !== 'ready'
+                    ? undefined
+                    : {
+                        authorityOwnerGeneration: resolution.route.authorityOwnerGeneration,
+                        ownerLeaseGeneration: resolution.route.ownerLeaseGeneration,
+                        ownerId: resolution.route.ownerId,
+                        ownerNodeGeneration: resolution.route.ownerNodeGeneration,
+                        authorityStoreVersion: resolution.route.authorityStoreVersion,
+                        actorType: resolution.route.actorType
+                    };
+            },
+            confirmRemoteActorSessionBinding: (actor, sessionRid, signal, options) => {
+                const sessionNode = this.spotNodeRuntime?.primaryMeshNode;
+                return sessionNode === undefined
+                    ? Promise.resolve()
+                    : this.boundSessionRelay.actorPackets.confirmRemoteSessionBinding(actor, sessionNode.status().routingId, sessionRid, signal, options);
+            },
+            relay: (actor, header, payload, signal) => this.boundSessionRelay.actorPackets.relayActorPacket(actor, header, payload, signal),
+            notifyDisconnected: (actor, signal) => this.boundSessionRelay.actorPackets.notifyBoundActorDisconnected(actor, signal)
+        });
+        this.actorHandoff = new actors_2.ZLinkActorHandoffCoordinator({
+            routedTransport: this.routeTransport,
+            messageFollowDurationMs: options.registration.locations.options.messageFollowDurationMs,
+            requestTimeoutMs: options.registration.requestTimeoutMs,
+            requestSource: (actorId) => {
+                const owner = this.locationOwner.currentRuntime?.currentOwnerToken;
+                const state = this.actorManager?.getState(actorId);
+                const current = state?.nativeActorRef;
+                const meshName = state?.meshName;
+                const node = meshName === undefined
+                    ? undefined
+                    : this.spotNodeRuntime?.meshNode(meshName)?.status();
+                if (owner === undefined
+                    || state === undefined
+                    || current === undefined
+                    || meshName === undefined
+                    || node === undefined
+                    || state.locationGeneration === undefined
+                    || state.ownerLeaseGeneration === undefined
+                    || state.ownerLeaseGeneration !== owner.leaseGeneration
+                    || !(0, routing_id_1.routingIdsEqual)(node.routingId, current.nodeRid)) {
+                    throw new ConfigurationException_1.ZLinkConfigurationException(`Actor '${actorId}' handoff requires a committed source owner fence.`);
+                }
+                return {
+                    meshName,
+                    objectGeneration: current.generation,
+                    ownerId: owner.ownerId,
+                    ownerLeaseGeneration: state.ownerLeaseGeneration,
+                    nodeRid: String(current.nodeRid),
+                    nodeRidHex: (0, routing_id_1.encodeRoutingIdStorageHex)(current.nodeRid),
+                    nodeGeneration: node.lifecycleGeneration,
+                    authorityOwnerGeneration: state.locationGeneration
+                };
+            },
+            validateReplySource: (source) => {
+                const owner = this.locationOwner.currentRuntime?.currentOwnerToken;
+                const node = this.spotNodeRuntime?.meshNode(source.meshName)?.status();
+                if (owner === undefined || node === undefined
+                    || owner.ownerId !== source.ownerId
+                    || owner.leaseGeneration !== source.ownerLeaseGeneration
+                    || node.lifecycleGeneration !== source.nodeGeneration) {
+                    return false;
+                }
+                return (0, routing_id_1.routingIdsEqual)(node.routingId, (0, routing_id_1.decodeRoutingId)(source.nodeRid, source.nodeRidHex));
+            },
+            onMarker: (marker, actorId, index, context) => {
+                if (marker === 'message_follow_relay' && context !== undefined) {
+                    this.options.providerResolver?.get?.(actor_transport_delivery_gate_1.ZLINK_INTERNAL_ACTOR_TRANSPORT_DELIVERY_GATE)?.recordMessageFollowRelay?.(actorId, context);
+                }
+                if (marker === 'message_follow_route_removed') {
+                    this.serviceRelocation.completeActorJoinSourceCleanup(actorId);
+                }
+                this.publishActorHandoffEvent({ marker, actorId, index });
+            },
+            onRequestFrame: (actorId, index, requestSeq, flags) => {
+                this.publishActorHandoffEvent({
+                    marker: 'handoff_request_frame',
+                    actorId,
+                    index,
+                    requestSeq: requestSeq?.toString(),
+                    flags
+                });
+            },
+            onMessageFollowRelayed: async (actorId, targetActorRef, context, origin, queuedMessages, queuedBytes) => {
+                try {
+                    const objectGeneration = BigInt(context.objectGeneration);
+                    if (targetActorRef.objectGeneration !== objectGeneration) {
+                        throw new Error(`Actor Message Follow changed object generation for '${actorId}'.`);
+                    }
+                    const sent = await this.spotNodeRuntime?.sendMessageFollowNotification((0, actor_message_follow_context_1.messageFollowOwnerNodeRid)(context.sourceOwner), origin.sourceNodeRid, {
+                        source: {
+                            kind: 'actor',
+                            actor: {
+                                actorId,
+                                generation: objectGeneration,
+                                nodeRid: (0, actor_message_follow_context_1.messageFollowOwnerNodeRid)(context.sourceOwner)
+                            },
+                            targetNodeRid: (0, actor_message_follow_context_1.messageFollowOwnerNodeRid)(context.sourceOwner),
+                            targetNodeGeneration: BigInt(context.sourceOwner.nodeGeneration),
+                            authorityOwnerGeneration: BigInt(context.sourceOwner.authorityOwnerGeneration),
+                            ownerLeaseGeneration: BigInt(context.sourceOwner.ownerLeaseGeneration)
+                        },
+                        target: {
+                            kind: 'actor',
+                            actor: {
+                                actorId,
+                                generation: objectGeneration,
+                                nodeRid: (0, actor_message_follow_context_1.messageFollowOwnerNodeRid)(context.targetOwner)
+                            },
+                            targetNodeRid: (0, actor_message_follow_context_1.messageFollowOwnerNodeRid)(context.targetOwner),
+                            targetNodeGeneration: BigInt(context.targetOwner.nodeGeneration),
+                            authorityOwnerGeneration: BigInt(context.targetOwner.authorityOwnerGeneration),
+                            ownerLeaseGeneration: BigInt(context.targetOwner.ownerLeaseGeneration)
+                        },
+                        hopCount: context.hopCount,
+                        queuedMessages,
+                        queuedBytes,
+                        originalOperation: origin.originalOperation,
+                        originalReplyRouteId: origin.originalReplyRouteId
+                    });
+                    if (sent !== true) {
+                        throw new Error(`Actor Message Follow source runtime '${context.sourceOwner.nodeRid}' is unavailable.`);
+                    }
+                    return true;
+                }
+                catch (error) {
+                    this.runtimeOrPreStartErrorSink.reportRuntimeTaskException('actor Message Follow notification', error);
+                    return false;
+                }
+            },
+            isStaleActorRef: (actorId, actorRef) => {
+                const state = this.actorManager?.getState(actorId);
+                const current = state?.nativeActorRef;
+                if (actorRef === undefined)
+                    return state?.remoteActorPacketTarget !== undefined;
+                return current !== undefined && (current.generation !== actorRef.objectGeneration ||
+                    !(0, routing_id_1.routingIdsEqual)(current.nodeRid, actorRef.nodeRid));
+            },
+            isCurrentHandoffTarget: (actorId, spotId) => {
+                const currentSpotId = this.actorManager?.getState(actorId)?.spotId;
+                return currentSpotId !== undefined && String(currentSpotId) === spotId;
+            },
+            isCurrentActorRef: (actorId, actorRef) => {
+                const current = this.actorManager?.getState(actorId)?.nativeActorRef;
+                return current !== undefined
+                    && current.generation === actorRef.objectGeneration
+                    && (0, routing_id_1.routingIdsEqual)(current.nodeRid, actorRef.nodeRid);
+            },
+            currentOwnerFence: (actorId) => {
+                const state = this.actorManager?.getState(actorId);
+                const current = state?.nativeActorRef;
+                const owner = this.locationOwner.currentRuntime?.currentOwnerToken;
+                const node = state?.meshName === undefined
+                    ? undefined
+                    : this.spotNodeRuntime?.meshNode(state.meshName)?.status();
+                if (state === undefined || current === undefined || owner === undefined
+                    || node === undefined || state.locationGeneration === undefined
+                    || state.ownerLeaseGeneration === undefined
+                    || !(0, routing_id_1.routingIdsEqual)(node.routingId, current.nodeRid)) {
+                    return undefined;
+                }
+                return (0, actor_message_follow_context_1.ownerFence)({
+                    ownerId: owner.ownerId,
+                    ownerLeaseGeneration: state.ownerLeaseGeneration,
+                    nodeRid: String(current.nodeRid),
+                    nodeRidHex: (0, routing_id_1.encodeRoutingIdStorageHex)(current.nodeRid),
+                    nodeGeneration: node.lifecycleGeneration,
+                    authorityOwnerGeneration: state.locationGeneration
+                });
+            }
+        });
+        this.actorTransferRegistry = new actors_2.ZLinkActorTransferRegistry(options.registration.spotNodes, options.providerResolver, options.registration.messageSerializers);
+        this.boundSessionFactory = new streams_1.DefaultZLinkBoundSessionFactory(this.streamBindingRuntime);
+        this.boundSessionRelay = new bound_session_relay_1.ZLinkBoundSessionRelay({
+            requestTimeoutMs: options.registration.requestTimeoutMs,
+            sessionRelocationSealTimeoutMs: options.registration.locations.options.sessionRelocationSealTimeoutMs
+                ?? Locations_1.zlinkDefaultLocationOptions.sessionRelocationSealTimeoutMs,
+            routeTransport: this.routeTransport,
+            streamBindingRuntime: () => this.streamBindingRuntime,
+            meshRouters: this.meshRouters,
+            actorManager: () => this.actorManager,
+            spotManager: () => this.spotManager,
+            spotNodeRuntime: () => this.spotNodeRuntime,
+            detachedTaskRunner: this.detachedTaskRunner(),
+            actorSessionNode: (actorId) => {
+                const state = this.actorManager?.getState(actorId);
+                const meshName = state?.meshName
+                    ?? (state?.actorType === undefined
+                        ? undefined
+                        : this.meshRouters.actorMeshName(state.actorType));
+                const runtime = this.spotNodeRuntime;
+                const node = meshName === undefined || typeof runtime?.meshNode !== 'function'
+                    ? runtime?.primaryMeshNode
+                    : runtime.meshNode(meshName);
+                return node === undefined
+                    ? undefined
+                    : (0, backend_1.meshActorSessionNodeAdapter)(node, meshName === undefined || typeof runtime?.meshCompletionTable !== 'function'
+                        ? runtime?.primaryMeshCompletions
+                        : runtime.meshCompletionTable(meshName));
+            },
+            actorLocationResolver: () => this.createActorLocationResolver(),
+            authorityStore: () => this.locationOwner.currentStores?.locationStore,
+            flowCreationEnabled: () => this.flowCreationEnabled(),
+            destroyedActorRefs: this.destroyedActorRefs,
+            errorSink: () => this.errorSink ?? this.preStartErrorSink,
+            boundSessionFactory: (actorId) => {
+                const factory = this.createActorManagerOptions().boundSessionFactory;
+                if (factory === undefined) {
+                    throw new Error('Bound session factory is not configured.');
+                }
+                return factory(actorId);
+            }
+        });
+        this.entryActorRuntime = new entry_actor_runtime_1.ZLinkEntryActorRuntimeService({
+            actorManager: () => this.actorManager,
+            spotManager: () => this.spotManager,
+            spotNodeRuntime: () => this.spotNodeRuntime,
+            streamBindingRuntime: this.streamBindingRuntime,
+            boundSessionRelay: this.boundSessionRelay,
+            reportPostCommitError: (error) => (this.errorSink ?? this.preStartErrorSink).reportRuntimeTaskException('entry actor commit', error),
+            shutdownSignal: () => this.executionState?.abortController.signal
+        });
+        this.actorTransferRuntime = new actor_transfer_runtime_1.ZLinkActorTransferRuntime({
+            routeTransport: this.routeTransport,
+            messageSerializers: options.registration.messageSerializers,
+            spotManager: () => this.spotManager,
+            actorManager: () => this.actorManager,
+            primaryMeshNode: () => this.requirePrimaryMeshNode(),
+            notifyEntrySpotActorLeft: (actor, signal) => this.spotNodeRuntime?.notifyPrimaryEntrySpotActorLeft(actor, signal) ?? Promise.resolve(),
+            restoreEntrySpotActorJoined: (actor, signal) => this.spotNodeRuntime?.notifyPrimaryEntrySpotActorJoined(actor, signal) ?? Promise.resolve(),
+            locationLifecycle: () => this.locationOwner.currentLifecycle,
+            spotRouteResolver: () => this.createLocationSpotRouteResolver(),
+            actorHandoff: this.actorHandoff,
+            actorTransferRegistry: this.actorTransferRegistry,
+            authorityStore: () => this.locationOwner.currentStores?.locationStore,
+            currentOwner: () => this.locationOwner.currentRuntime?.currentOwnerToken,
+            relocationStore: () => this.options.registration.locations.relocationStoreInstance,
+            liveDescriptors: (meshName, signal) => {
+                const runtime = this.locationOwner.currentRuntime;
+                if (runtime === undefined) {
+                    throw new Error('Session owner liveness is unavailable without a Location runtime.');
+                }
+                return runtime.listLiveMeshNodes(meshName, signal);
+            },
+            sessionRelocationWire: () => this.serviceRelocation,
+            clearRemoteActorPacketTarget: (actorId) => this.boundSessionRelay.clearRemoteActorPacketTarget(actorId),
+            prepareApplicationJob: async (preparationSignal) => {
+                const runtimeSignal = this.executionState?.abortController.signal;
+                const signal = runtimeSignal === undefined
+                    ? preparationSignal
+                    : AbortSignal.any([runtimeSignal, preparationSignal]);
+                const permit = await this.applicationJobQueue.acquire(signal);
+                let state = 'ready';
+                let closedReason;
+                let abort;
+                const cancel = (reason) => {
+                    if (state !== 'ready')
+                        return;
+                    state = 'closed';
+                    closedReason = reason;
+                    if (abort !== undefined)
+                        signal.removeEventListener('abort', abort);
+                    permit.releaseAfterInternalProcessing();
+                };
+                try {
+                    if (signal.aborted) {
+                        cancel(signal.reason);
+                        throw signal.reason;
+                    }
+                    permit.markApplicationQueued();
+                    abort = () => cancel(signal.reason);
+                    signal.addEventListener('abort', abort, { once: true });
+                }
+                catch (error) {
+                    cancel(error);
+                    throw error;
+                }
+                return {
+                    run: async (operation) => {
+                        if (state !== 'ready') {
+                            throw closedReason ?? new Error('Prepared application job is no longer runnable.');
+                        }
+                        state = 'running';
+                        signal.removeEventListener('abort', abort);
+                        try {
+                            return await (0, application_job_queue_scope_1.runWithApplicationJobPermit)(permit, operation);
+                        }
+                        finally {
+                            state = 'closed';
+                        }
+                    },
+                    cancel
+                };
+            },
+            reportPostCommitError: (error) => (this.errorSink ?? this.preStartErrorSink).reportRuntimeTaskException('source actor departure', error),
+            onSourceDepartureCompleted: (actorId) => this.publishActorHandoffEvent({ marker: 'source_cleanup', actorId }),
+            shutdownSignal: () => this.executionState?.abortController.signal,
+            metrics: this.metrics
+        });
+        this.serviceRelocation = new service_relocation_host_runtime_1.ZLinkHostServiceRelocationRuntime({
+            registration: options.registration,
+            providerResolver: options.providerResolver,
+            locationStore: () => this.locationOwner.currentStores?.locationStore,
+            currentOwner: () => this.locationOwner.currentRuntime?.currentOwnerToken,
+            liveDescriptors: (meshName, signal) => this.locationOwner.currentRuntime?.listLiveMeshNodes(meshName, signal)
+                ?? Promise.resolve([]),
+            localDescriptor: (meshName) => this.spotNodeRuntime?.meshNodeDescriptor(meshName),
+            meshNode: (meshName) => this.spotNodeRuntime?.meshNode(meshName),
+            completions: (meshName) => this.spotNodeRuntime?.meshCompletionTable(meshName),
+            spotManager: () => this.spotManager,
+            spotNodeRuntime: () => this.spotNodeRuntime,
+            actorManager: () => this.actorManager,
+            actorTransfer: this.actorTransferRuntime,
+            boundSessionRelocation: {
+                receiveSeal: (value, signal) => this.boundSessionRelay.boundSessions.receiveServiceWireSessionRelocationSeal(value, signal),
+                receiveRoute: value => this.boundSessionRelay.boundSessions.receiveServiceWireSessionRelocationRoute(value),
+                clear: () => this.boundSessionRelay.boundSessions.clearServiceWireSessionRelocations()
+            },
+            trackInstanceSpot: (input) => this.locationOwner.currentLifecycle?.trackInstanceSpot(input),
+            invalidateActorRoute: (actorId) => this.actorClientLocationResolver?.invalidateActorRoute(actorId),
+            reconcileStatefulAuthorityRoutes: (signal) => this.statefulAuthorityRoutes?.reconcile(signal) ?? Promise.resolve(),
+            runtimeEventPublisher: this.runtimeEventPublisher,
+            metrics: this.metrics
+        });
+        this.actorTransferAuthorityRuntime = new actor_transfer_authority_runtime_1.ZLinkActorTransferAuthorityRuntime({
+            store: () => this.locationOwner.actorTransferStore(),
+            recoveryOwnerId: () => this.locationOwner.currentRuntime?.ownerId,
+            recoveryLeaseTtlMs: {
+                ...Locations_1.zlinkDefaultLocationOptions,
+                ...options.registration.locations.options
+            }.ownerLeaseTtlMs
+        });
+        this.routeMeshCoordinator = new route_mesh_runtime_1.ZLinkRouteMeshRuntimeCoordinator({
+            meshNames: [...options.registration.spotNodes.keys()],
+            meshOptions: options.registration.spotNodes,
+            meshNode: (meshName) => this.spotNodeRuntime?.meshNode(meshName),
+            meshNodeDescriptor: (meshName) => this.spotNodeRuntime?.meshNodeDescriptor(meshName),
+            localPlacementCounts: (meshName) => {
+                const spotManager = this.spotManager;
+                const actorManager = this.actorManager;
+                if (spotManager === undefined || actorManager === undefined)
+                    return undefined;
+                return {
+                    activeActorCount: actorManager.activeActorCount(meshName),
+                    activeSpotCount: spotManager.activeSpotCount(meshName)
+                };
+            },
+            isLocationStoreHealthy: () => {
+                if (!hasConfiguredLocationStore(options.registration)) {
+                    return true;
+                }
+                const runtime = this.locationOwner.currentRuntime;
+                return runtime !== undefined
+                    && runtime.ownerLeaseUsable
+                    && runtime.lastError === undefined;
+            },
+            hostState: () => this.runtimeState,
+            admission: this.admission,
+            publishRetiring: (meshName, signal) => this.publishMeshRetiring(meshName, signal),
+            rollbackRetiring: (meshName, signal) => this.publishMeshServing(meshName, signal),
+            publishDraining: (meshName, signal) => this.publishMeshDraining(meshName, signal),
+            publishHostDraining: (signal) => this.publishHostDraining(signal),
+            drainResources: (meshName, signal, stopStartingSignal) => this.performMeshDrain(meshName, signal, stopStartingSignal),
+            shutdownResources: (meshName, signal) => this.performMeshShutdown(meshName, signal),
+            cleanupHostResources: (signal) => this.cleanupOwnerForDrain(signal),
+            forceStopResources: (meshName) => this.forceStopMesh(meshName)
+        });
+        this.metricRegistrations.push(this.metrics.registerHostState(() => runtimeStateMetricName(this.runtimeState)), this.metrics.registerHostCapacity(() => this.capacityStatus.snapshot(this.context?.getCoreHwmBudgetSnapshot())), this.metrics.registerApplicationJobQueuePressure(() => this.applicationJobQueue.snapshot()), this.metrics.registerMeshSnapshots(() => this.runtimeMetricMeshSnapshots()));
+        this.routeMeshRuntime = this.routeMeshCoordinator;
+    }
+    get isStarted() {
+        return this.executionState !== undefined;
+    }
+    get status() {
+        return {
+            state: this.runtimeState,
+            isReady: (0, runtime_state_projections_1.runtimeStateIsReady)(this.runtimeState),
+            acceptingWork: (0, runtime_state_projections_1.runtimeAcceptsWork)(this.runtimeState, this.admission.acceptsNewWork),
+            capacity: this.capacityStatus.snapshot(this.context?.getCoreHwmBudgetSnapshot()),
+            safeToShutdown: this.serviceRelocation.isSafeToShutdown(),
+            deadline: this.runtimeDeadline,
+            relocationResult: this.runtimeRelocationResult,
+            terminationResult: this.runtimeTerminationResult,
+            sequence: this.runtimeSequence,
+            observedAt: new Date()
+        };
+    }
+    observe(signal) {
+        const queue = new runtime_observation_queue_1.RuntimeEventQueue(undefined, signal);
+        this.runtimeObservers.add(queue);
+        queue.onClose(() => this.runtimeObservers.delete(queue));
+        return queue;
+    }
+    resetCapacityMetrics() {
+        const context = this.context;
+        if (context === undefined) {
+            throw new Error('Capacity metrics reset requires a started Framework runtime.');
+        }
+        this.capacityStatus.reset(() => context.resetCoreHwmBudgetMetrics());
+    }
+    relocate(options) {
+        const effectiveTargetApplicationVersion = validateRelocationOptions(options, this.options.registration.applicationVersion);
+        const deadlineMs = options.deadlineMs ?? 30_000;
+        if (!Number.isFinite(deadlineMs) || deadlineMs <= 0) {
+            return Promise.reject(new RangeError('Relocation deadlineMs must be greater than zero.'));
+        }
+        if (this.runtimeRelocationResult?.outcome === contracts_1.ZLinkFrameworkRelocationOutcome.Relocated) {
+            return Promise.resolve(this.runtimeRelocationResult);
+        }
+        if (this.shutdownOperation !== undefined) {
+            return Promise.resolve({
+                mode: options.mode,
+                effectiveTargetApplicationVersion,
+                outcome: contracts_1.ZLinkFrameworkRelocationOutcome.Blocked,
+                reason: contracts_1.ZLinkFrameworkRelocationReason.ShutdownRequested
+            });
+        }
+        const operationKey = `${options.mode}:${effectiveTargetApplicationVersion}`;
+        if (this.relocationOperation !== undefined) {
+            if (this.relocationOperationKey === operationKey) {
+                return waitForRuntimeOperation(this.relocationOperation, options.signal);
+            }
+            return Promise.resolve({
+                mode: options.mode,
+                effectiveTargetApplicationVersion,
+                outcome: contracts_1.ZLinkFrameworkRelocationOutcome.Blocked,
+                reason: contracts_1.ZLinkFrameworkRelocationReason.OperationInProgress
+            });
+        }
+        if (this.runtimeState !== contracts_1.ZLinkFrameworkRuntimeState.Serving) {
+            return Promise.resolve({
+                mode: options.mode,
+                effectiveTargetApplicationVersion,
+                outcome: contracts_1.ZLinkFrameworkRelocationOutcome.Blocked,
+                reason: this.runtimeState === contracts_1.ZLinkFrameworkRuntimeState.Relocating
+                    ? contracts_1.ZLinkFrameworkRelocationReason.OperationInProgress
+                    : contracts_1.ZLinkFrameworkRelocationReason.RuntimeNotReady
+            });
+        }
+        if (hasUnsupportedManualTopology(this.options.registration)) {
+            return Promise.resolve({
+                mode: options.mode,
+                effectiveTargetApplicationVersion,
+                outcome: contracts_1.ZLinkFrameworkRelocationOutcome.Blocked,
+                reason: contracts_1.ZLinkFrameworkRelocationReason.ManualTopologyUnsupported
+            });
+        }
+        this.runtimeDeadline = new Date(Date.now() + deadlineMs);
+        this.relocationTargetApplicationVersion = effectiveTargetApplicationVersion;
+        this.relocationOperationKey = operationKey;
+        this.relocationOperationStartedAt = performance.now();
+        this.relocationStopStarting = new AbortController();
+        this.relocationOperation = this.runRelocation(options.mode, effectiveTargetApplicationVersion, deadlineMs, this.relocationStopStarting.signal);
+        return waitForRuntimeOperation(this.relocationOperation, options.signal);
+    }
+    shutdown(options) {
+        const deadlineMs = options?.deadlineMs ?? 30_000;
+        if (!Number.isFinite(deadlineMs) || deadlineMs <= 0) {
+            return Promise.reject(new RangeError('Shutdown deadlineMs must be greater than zero.'));
+        }
+        if (this.shutdownOperation === undefined) {
+            this.runtimeDeadline = new Date(Date.now() + deadlineMs);
+            this.relocationStopStarting?.abort(new Error('Shutdown requested.'));
+            this.shutdownOperationStartedAt = performance.now();
+            this.shutdownOperation = this.runShutdown(deadlineMs);
+        }
+        return waitForRuntimeOperation(this.shutdownOperation, options?.signal);
+    }
+    async runRelocation(mode, effectiveTargetApplicationVersion, deadlineMs, stopStartingSignal) {
+        if (!this.isStarted) {
+            return this.completeRelocation(blockedRelocation(mode, effectiveTargetApplicationVersion, contracts_1.ZLinkFrameworkRelocationReason.RuntimeNotReady));
+        }
+        const deadlineAtMs = performance.now() + deadlineMs;
+        const remainingDeadlineMs = () => Math.max(1, deadlineAtMs - performance.now());
+        try {
+            // Runtime weight changes publish a newer descriptor asynchronously. A
+            // maintenance operation must observe that publication before it writes
+            // Retiring/Draining, otherwise two descriptor revisions can race and
+            // make a valid drain look like a Store failure.
+            await this.spotNodeRuntime?.waitForRuntimeWeightPublication();
+            const blocker = await this.preflightAutomaticPeerReadiness(deadlineAtMs, effectiveTargetApplicationVersion);
+            if (blocker !== undefined) {
+                return this.resetBlockedRelocation(blockedRelocation(mode, effectiveTargetApplicationVersion, blocker));
+            }
+            const descriptorPreparation = await this.routeMeshCoordinator.prepareHostRetire(remainingDeadlineMs());
+            if (descriptorPreparation !== 'prepared') {
+                return this.resetBlockedRelocation(blockedRelocation(mode, effectiveTargetApplicationVersion, descriptorPreparation === 'deadline_exceeded'
+                    ? contracts_1.ZLinkFrameworkRelocationReason.DeadlineExceeded
+                    : contracts_1.ZLinkFrameworkRelocationReason.StoreUnavailable));
+            }
+            this.setRuntimeState(contracts_1.ZLinkFrameworkRuntimeState.Relocating);
+            const drained = await this.routeMeshCoordinator.relocateHost(remainingDeadlineMs(), stopStartingSignal);
+            if (drained.kind === 'forceStopped') {
+                return this.resetBlockedRelocation(blockedRelocation(mode, effectiveTargetApplicationVersion, stopStartingSignal.aborted
+                    ? contracts_1.ZLinkFrameworkRelocationReason.ShutdownRequested
+                    : drained.error instanceof service_relocation_host_runtime_1.ZLinkRelocationStateIncompatibleError
+                        ? contracts_1.ZLinkFrameworkRelocationReason.StateIncompatible
+                        : relocationReason(drained.reason)));
+            }
+            await this.publishHostRelocated();
+            return this.completeRelocation({
+                mode,
+                effectiveTargetApplicationVersion,
+                outcome: contracts_1.ZLinkFrameworkRelocationOutcome.Relocated,
+                reason: contracts_1.ZLinkFrameworkRelocationReason.None
+            });
+        }
+        catch (error) {
+            const result = blockedRelocation(mode, effectiveTargetApplicationVersion, stopStartingSignal.aborted
+                ? contracts_1.ZLinkFrameworkRelocationReason.ShutdownRequested
+                : (0, abort_1.isDeadlineExceededError)(error)
+                    ? contracts_1.ZLinkFrameworkRelocationReason.DeadlineExceeded
+                    : error instanceof service_relocation_host_runtime_1.ZLinkRelocationStateIncompatibleError
+                        ? contracts_1.ZLinkFrameworkRelocationReason.StateIncompatible
+                        : contracts_1.ZLinkFrameworkRelocationReason.RelocationFailed);
+            return error instanceof route_mesh_runtime_1.ZLinkRetiringRollbackError
+                ? this.completeRelocation(result)
+                : this.resetBlockedRelocation(result);
+        }
+    }
+    async runShutdown(deadlineMs) {
+        const deadlineAtMs = performance.now() + deadlineMs;
+        try {
+            this.admission.close();
+            this.setRuntimeState(contracts_1.ZLinkFrameworkRuntimeState.Draining);
+            if (this.relocationOperation !== undefined
+                && this.relocationStopStarting?.signal.aborted === true) {
+                await this.relocationOperation;
+            }
+            // Seal application admission before the public status reports that the
+            // host no longer accepts work. This prevents status polling from racing
+            // with the coordinator's synchronous seal step.
+            const unscopedStreamDrain = this.streamRuntime?.notifyUnscopedServerDrain();
+            const shutdown = this.routeMeshCoordinator.shutdownHost(this.runtimeDeadline, undefined, Math.max(0, deadlineAtMs - performance.now()));
+            const drain = await shutdown;
+            await unscopedStreamDrain;
+            await this.stop();
+            if (drain.kind === 'forceStopped') {
+                return this.completeTermination({
+                    outcome: contracts_1.ZLinkFrameworkTerminationOutcome.ForceStopped,
+                    reason: drain.reason === 'deadline_exceeded'
+                        ? contracts_1.ZLinkFrameworkTerminationReason.DeadlineExceeded
+                        : contracts_1.ZLinkFrameworkTerminationReason.TeardownFailed
+                });
+            }
+            if (performance.now() >= deadlineAtMs) {
+                throw (0, abort_1.createDeadlineExceededError)('Shutdown resource cleanup exceeded its deadline.');
+            }
+            return this.completeTermination({
+                outcome: contracts_1.ZLinkFrameworkTerminationOutcome.Stopped,
+                reason: contracts_1.ZLinkFrameworkTerminationReason.None
+            });
+        }
+        catch (error) {
+            await this.stop().catch(() => undefined);
+            return this.completeTermination({
+                outcome: contracts_1.ZLinkFrameworkTerminationOutcome.ForceStopped,
+                reason: (0, abort_1.isDeadlineExceededError)(error)
+                    ? contracts_1.ZLinkFrameworkTerminationReason.DeadlineExceeded
+                    : contracts_1.ZLinkFrameworkTerminationReason.TeardownFailed
+            });
+        }
+    }
+    resetBlockedRelocation(result) {
+        this.recordRelocationResult(result);
+        if (this.runtimeState === contracts_1.ZLinkFrameworkRuntimeState.Relocating) {
+            this.setRuntimeState(contracts_1.ZLinkFrameworkRuntimeState.Serving);
+        }
+        this.runtimeDeadline = undefined;
+        this.relocationTargetApplicationVersion = undefined;
+        this.relocationStopStarting = undefined;
+        this.relocationOperation = undefined;
+        this.relocationOperationKey = undefined;
+        this.relocationOperationStartedAt = undefined;
+        return result;
+    }
+    completeRelocation(result) {
+        this.runtimeRelocationResult = result;
+        this.runtimeDeadline = undefined;
+        this.recordRelocationResult(result);
+        this.setRuntimeState(result.outcome === contracts_1.ZLinkFrameworkRelocationOutcome.Relocated
+            ? contracts_1.ZLinkFrameworkRuntimeState.Relocated
+            : contracts_1.ZLinkFrameworkRuntimeState.Error);
+        return result;
+    }
+    recordRelocationResult(result) {
+        if (this.relocationOperationStartedAt !== undefined) {
+            this.metrics.duration('zlink.host.relocation.duration', Math.max(0, performance.now() - this.relocationOperationStartedAt) / 1000, {
+                mode: relocationModeMetricName(result.mode),
+                outcome: result.outcome === contracts_1.ZLinkFrameworkRelocationOutcome.Relocated
+                    ? 'relocated'
+                    : 'blocked'
+            });
+        }
+        if (result.outcome === contracts_1.ZLinkFrameworkRelocationOutcome.Blocked) {
+            this.metrics.count('zlink.host.relocation.blocked', 1, {
+                mode: relocationModeMetricName(result.mode),
+                reason: relocationReasonMetricName(result.reason)
+            });
+        }
+        void this.runtimeEventPublisher.publish({
+            sourceName: 'zlink.runtime.host',
+            timestamp: new Date(),
+            identifier: 'zlink.runtime.host.relocation_changed',
+            mode: result.mode,
+            effectiveTargetApplicationVersion: result.effectiveTargetApplicationVersion,
+            outcome: result.outcome,
+            reason: result.reason
+        });
+    }
+    completeTermination(result) {
+        this.runtimeTerminationResult = result;
+        this.runtimeDeadline = undefined;
+        if (this.shutdownOperationStartedAt !== undefined) {
+            this.metrics.duration('zlink.host.shutdown.duration', Math.max(0, performance.now() - this.shutdownOperationStartedAt) / 1000, {
+                outcome: result.outcome === contracts_1.ZLinkFrameworkTerminationOutcome.Stopped
+                    ? 'stopped'
+                    : 'force_stopped'
+            });
+        }
+        if (result.outcome === contracts_1.ZLinkFrameworkTerminationOutcome.ForceStopped) {
+            this.metrics.count('zlink.host.shutdown.forced', 1, {
+                reason: terminationReasonMetricName(result.reason)
+            });
+        }
+        void this.runtimeEventPublisher.publish({
+            sourceName: 'zlink.runtime.host',
+            timestamp: new Date(),
+            identifier: 'zlink.runtime.host.termination_changed',
+            outcome: result.outcome,
+            reason: result.reason
+        });
+        this.setRuntimeState(contracts_1.ZLinkFrameworkRuntimeState.Stopped);
+        return result;
+    }
+    setRuntimeState(state) {
+        if (this.runtimeState === state)
+            return;
+        this.runtimeState = state;
+        this.runtimeSequence += 1n;
+        this.notifyTopologyHostStateChanged();
+        const status = this.status;
+        for (const observer of this.runtimeObservers) {
+            if (state === contracts_1.ZLinkFrameworkRuntimeState.Stopped) {
+                observer.seal(status, this.runtimeObservationSource);
+            }
+            else {
+                observer.push(status, this.runtimeObservationSource);
+            }
+        }
+        if (state === contracts_1.ZLinkFrameworkRuntimeState.Stopped) {
+            this.runtimeObservers.clear();
+        }
+    }
+    notifyTopologyHostStateChanged() {
+        const callbacks = [
+            () => this.routeMeshCoordinator.hostStateChanged(),
+            () => this.clientServerRuntime
+                .hostStateChanged(),
+            () => this.fanoutRuntime
+                .hostStateChanged()
+        ];
+        for (const callback of callbacks) {
+            try {
+                callback();
+            }
+            catch (error) {
+                try {
+                    this.runtimeOrPreStartErrorSink.reportRuntimeTaskException('topology lifecycle observation', error);
+                }
+                catch {
+                    // Monitoring must not change the host lifecycle result.
+                }
+            }
+        }
+    }
+    stopTopologyObservers() {
+        const callbacks = [
+            () => this.routeMeshCoordinator.stopObservers(),
+            () => this.clientServerRuntime
+                .stopObservers(),
+            () => this.fanoutRuntime
+                .stopObservers()
+        ];
+        for (const callback of callbacks) {
+            try {
+                callback();
+            }
+            catch (error) {
+                try {
+                    this.runtimeOrPreStartErrorSink.reportRuntimeTaskException('topology observer shutdown', error);
+                }
+                catch {
+                    // Monitoring must not change the host lifecycle result.
+                }
+            }
+        }
+    }
+    publishActorHandoffEvent(event) {
+        void this.runtimeEventPublisher.publish({
+            sourceName: 'zlink.framework.actor-handoff',
+            timestamp: new Date(),
+            ...event
+        });
+    }
+    get locationRuntimeQuery() {
+        return this.ensureLocationRuntime();
+    }
+    /**
+     * 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) {
+        void this.setMessageFlowModeAsync(mode);
+    }
+    setMessageFlowModeAsync(mode) {
+        this.messageFlowModeCell.mode = (0, DiagnosticsValidation_1.requireMessageFlowLogMode)(mode);
+        return Promise.resolve();
+    }
+    messageFlowMode() {
+        return this.messageFlowModeCell.mode;
+    }
+    get context() {
+        return this.executionState?.context;
+    }
+    get taskRunner() {
+        return this.executionState?.taskRunner;
+    }
+    get errorSink() {
+        return this.executionState?.errorSink;
+    }
+    async start() {
+        await this.runLifecycle(() => this.startCore());
+    }
+    async startCore() {
+        if (this.executionState !== undefined) {
+            return;
+        }
+        this.setRuntimeState(contracts_1.ZLinkFrameworkRuntimeState.Preparing);
+        this.lifecycleSink?.push('framework:start');
+        const channelAdapter = this.backendAdapterFactory.createChannelAdapter();
+        const context = channelAdapter.createContext();
+        const coreHwm = this.options.registration.coreHwm;
+        if (coreHwm !== undefined) {
+            context.configureCoreHwm(coreHwm);
+        }
+        let channelRuntime;
+        let spotNodeRuntime;
+        let streamRuntime;
+        let startedLocationRuntime;
+        let statefulAuthorityRoutes;
+        try {
+            this.executionState = new execution_1.ZLinkFrameworkExecutionState(context);
+            // Seed the shared live-mode cell from the configured mode (default errorsOnly).
+            this.messageFlowModeCell.mode =
+                this.options.registration.dispatch?.diagnostics.messageFlow ??
+                    'errors';
+            const dispatchErrors = this.createDispatchErrorReporter(this.executionState.errorSink);
+            channelRuntime = new channels_1.ZLinkChannelRuntimeManager(this.options.registration, channelAdapter, context, this.options.providerResolver, this.createChannelRuntimeOptions());
+            this.channelRuntime = channelRuntime;
+            channelRuntime.prepareMeshDispatch(this.executionState.taskRunner);
+            spotNodeRuntime = new spots_1.ZLinkSpotNodeRuntimeManager(this.createSpotNodeRuntimeOptions(context, dispatchErrors));
+            await spotNodeRuntime.start();
+            this.spotNodeRuntime = spotNodeRuntime;
+            this.registerUserSpotHandlers?.(spotNodeRuntime);
+            channelRuntime.bindRouteMeshRouters();
+            // Start bound receivers before publishing Serving descriptors. A
+            // discovered ClientServer endpoint must already be able to dispatch.
+            this.executionState.listenerTasks.push(...channelRuntime.start(this.executionState.taskRunner));
+            const locationRuntime = await this.locationOwner.startForRuntime(this.meshRouters.primaryMeshName(), spotNodeRuntime, channelRuntime);
+            startedLocationRuntime = locationRuntime;
+            if (locationRuntime !== undefined) {
+                this.installOwnerLeaseRecoveryPublication(locationRuntime, spotNodeRuntime, channelRuntime);
+            }
+            const locationStore = this.locationOwner.currentStores?.locationStore;
+            if (locationStore !== undefined && locationRuntime?.ownerLeaseUsable !== false) {
+                await spotNodeRuntime.publishMeshNodeState(contracts_1.ZLinkFrameworkRuntimeState.Preparing, this.executionState.abortController.signal);
+                if (this.requiresStatefulAuthorityRuntime()) {
+                    this.installLocationBackedAuthorities(locationStore, spotNodeRuntime);
+                    statefulAuthorityRoutes = this.createStatefulAuthorityRoutes(locationStore, spotNodeRuntime);
+                    await statefulAuthorityRoutes.start(this.executionState.abortController.signal);
+                    this.statefulAuthorityRoutes = statefulAuthorityRoutes;
+                }
+            }
+            streamRuntime = new streams_1.ZLinkStreamRuntimeManager({
+                registration: this.options.registration,
+                backendAdapterFactory: this.backendAdapterFactory,
+                context,
+                bindingRuntime: this.streamBindingRuntime,
+                providerResolver: this.options.providerResolver,
+                dispatchErrors,
+                metrics: this.metrics,
+                applicationJobQueue: this.applicationJobQueue,
+                acceptNewSession: (meshName) => meshName === undefined
+                    ? this.admission.acceptsNewWork
+                    : this.admission.accepts(meshName),
+                primaryMeshName: this.meshRouters.primaryMeshName(),
+                nativeMeshNode: spotNodeRuntime.primaryMeshNode,
+                meshCompletions: spotNodeRuntime.primaryMeshCompletions,
+                nativeMeshNodeForName: (meshName) => spotNodeRuntime?.meshNode(meshName),
+                meshCompletionsForName: (meshName) => spotNodeRuntime?.meshCompletionTable(meshName)
+            });
+            streamRuntime.start();
+            this.streamRuntime = streamRuntime;
+            if (locationRuntime === undefined || locationRuntime.ownerLeaseUsable) {
+                await spotNodeRuntime.publishMeshNodeState(contracts_1.ZLinkFrameworkRuntimeState.Serving, this.executionState.abortController.signal);
+            }
+            this.routeMeshCoordinator.markServing();
+            this.setRuntimeState(contracts_1.ZLinkFrameworkRuntimeState.Serving);
+            this.lifecycleSink?.push('framework:started');
+        }
+        catch (error) {
+            await statefulAuthorityRoutes?.stop();
+            await (0, runtime_shutdown_1.rollbackRuntimeStart)({
+                context,
+                startedLocationRuntime,
+                streamRuntime,
+                spotNodeRuntime,
+                channelRuntime,
+                ownedStores: registeredRuntimeStores(this.options.registration)
+            });
+            this.executionState = undefined;
+            this.channelRuntime = undefined;
+            this.spotNodeRuntime = undefined;
+            this.streamRuntime = undefined;
+            this.statefulAuthorityRoutes = undefined;
+            this.removeOwnerLeaseRecoveryPublication();
+            this.locationOwner.clearForStop();
+            this.cachedLocationSpotRouteResolver = undefined;
+            throw error;
+        }
+    }
+    async stop() {
+        await this.runLifecycle(() => this.stopCore());
+    }
+    runtimeMetricMeshSnapshots() {
+        const snapshots = [];
+        for (const [meshName, options] of this.options.registration.spotNodes) {
+            let status;
+            try {
+                status = this.routeMeshCoordinator.snapshot(meshName);
+            }
+            catch {
+                continue;
+            }
+            const descriptor = this.spotNodeRuntime?.meshNodeDescriptor(meshName);
+            const hasManual = (options.router?.manualConnections?.length ?? 0) > 0
+                || (options.router?.manualPeerConnections?.length ?? 0) > 0
+                || (options.pubSub?.manualConnections?.length ?? 0) > 0;
+            const hasDiscovery = hasConfiguredLocationStore(this.options.registration);
+            const source = hasManual && hasDiscovery
+                ? 'manual_and_redis'
+                : hasManual ? 'manual' : 'redis';
+            const emptyCapacity = { active: 0, reserved: 0, limit: 0 };
+            snapshots.push({
+                meshName,
+                source,
+                configuredPeers: status.peers.length,
+                connectedPeers: status.peers.filter(peer => peer.state !== contracts_1.ZLinkPeerState.NotConnected).length,
+                readyPeers: status.readyPeerCount,
+                channels: status.channels.map(channel => ({
+                    channelName: channel.channelName,
+                    readyMembers: channel.readyTargetCount
+                })),
+                actorCapacity: descriptor?.populationCapacity.actors ?? emptyCapacity,
+                spotCapacity: descriptor?.populationCapacity.spots ?? emptyCapacity,
+                spotTypeCapacities: (descriptor?.populationCapacity.spotTypes ?? []).map(capacity => ({
+                    spotKind: capacity.objectKind === 'instance_spot' ? 'instance' : 'user',
+                    stableType: capacity.stableType,
+                    active: capacity.active,
+                    reserved: capacity.reserved,
+                    limit: capacity.limit
+                })),
+                activation: descriptor?.activationConcurrency ?? { active: 0, limit: 0 },
+                instanceSpots: []
+            });
+        }
+        return snapshots;
+    }
+    async stopCore() {
+        const state = this.executionState;
+        if (state === undefined) {
+            return;
+        }
+        const channelRuntime = this.channelRuntime;
+        const spotNodeRuntime = this.spotNodeRuntime;
+        const streamRuntime = this.streamRuntime;
+        const statefulAuthorityRoutes = this.statefulAuthorityRoutes;
+        this.stopTopologyObservers();
+        this.removeOwnerLeaseRecoveryPublication();
+        const locationSnapshot = this.locationOwner.clearForStop();
+        this.executionState = undefined;
+        this.channelRuntime = undefined;
+        this.spotNodeRuntime = undefined;
+        this.streamRuntime = undefined;
+        this.statefulAuthorityRoutes = undefined;
+        this.cachedLocationSpotRouteResolver = undefined;
+        this.lifecycleSink?.push('framework:stop');
+        await statefulAuthorityRoutes?.stop();
+        await (0, runtime_shutdown_1.stopRuntimeParts)({
+            state,
+            locationSnapshot,
+            cleanupDeadline: this.runtimeDeadline,
+            streamRuntime,
+            spotNodeRuntime,
+            channelRuntime,
+            serviceRelocation: this.serviceRelocation,
+            ownedStores: registeredRuntimeStores(this.options.registration)
+        });
+        this.lifecycleSink?.push('framework:stopped');
+        if (this.shutdownOperation === undefined) {
+            this.setRuntimeState(contracts_1.ZLinkFrameworkRuntimeState.Stopped);
+        }
+    }
+    installOwnerLeaseRecoveryPublication(runtime, spotNodeRuntime, channelRuntime) {
+        let publishing = false;
+        let lastPublishedOwnerToken = runtime.currentOwnerToken;
+        let recoveryRequired = false;
+        let recoveringServices;
+        let stoppingServices;
+        let transportFence = Promise.resolve();
+        const handler = () => {
+            const ownerToken = runtime.currentOwnerToken;
+            if (publishing
+                || ownerToken === undefined
+                || (ownerToken === lastPublishedOwnerToken && !recoveryRequired))
+                return;
+            if (runtime.ownerLeaseUsable === false)
+                return;
+            publishing = true;
+            const signal = this.executionState?.abortController.signal;
+            const recoverServices = async () => {
+                if (stoppingServices !== undefined) {
+                    await stoppingServices;
+                    stoppingServices = undefined;
+                }
+                if (this.statefulAuthorityRoutes !== undefined)
+                    return;
+                const store = this.locationOwner.currentStores?.locationStore;
+                if (store === undefined || this.executionState === undefined)
+                    return;
+                if (recoveringServices !== undefined)
+                    return await recoveringServices;
+                recoveringServices = (async () => {
+                    if (this.requiresStatefulAuthorityRuntime()) {
+                        const routes = this.createStatefulAuthorityRoutes(store, spotNodeRuntime);
+                        await routes.start(this.executionState?.abortController.signal);
+                        this.statefulAuthorityRoutes = routes;
+                    }
+                })();
+                try {
+                    await recoveringServices;
+                }
+                finally {
+                    recoveringServices = undefined;
+                }
+            };
+            void transportFence
+                .then(() => spotNodeRuntime.publishMeshNodeState(contracts_1.ZLinkFrameworkRuntimeState.Preparing, signal))
+                .then(() => recoverServices())
+                .then(() => {
+                const currentOwnerToken = runtime.currentOwnerToken;
+                if (runtime.ownerLeaseUsable === false
+                    || currentOwnerToken === undefined
+                    || currentOwnerToken.ownerId !== ownerToken.ownerId
+                    || currentOwnerToken.leaseGeneration !== ownerToken.leaseGeneration) {
+                    throw new Error('Owner lease changed during recovery.');
+                }
+                return spotNodeRuntime.publishMeshNodeState(this.runtimeState, signal);
+            })
+                .then(() => spotNodeRuntime.startLocationAutoConnect(signal))
+                .then(() => channelRuntime.reclaimLocationOwnerRows(signal))
+                .then(() => this.locationOwner.currentLifecycle?.reclaimOwnerRows() ?? Promise.resolve())
+                .then(() => {
+                lastPublishedOwnerToken = ownerToken;
+                recoveryRequired = false;
+                publishing = false;
+            }, error => {
+                this.runtimeOrPreStartErrorSink.reportRuntimeTaskException('owner lease recovery', error);
+                publishing = false;
+            });
+        };
+        this.ownerLeaseRecoveryRuntime = runtime;
+        this.ownerLeaseRecoveryHandler = handler;
+        const failureHandler = () => {
+            recoveryRequired = true;
+            if (runtime.ownerLeaseUsable)
+                return;
+            // A Store failure invalidates new ownership and discovery work, but it
+            // must not tear down transports that were already established. The
+            // auto-connect reconciler applies storeFailureGraceMs to the last
+            // complete descriptor set; fencing here would bypass that contract and
+            // make existing requests fail during the grace window.
+            const routes = this.statefulAuthorityRoutes;
+            if (routes === undefined)
+                return;
+            this.statefulAuthorityRoutes = undefined;
+            stoppingServices = routes.stop();
+            void stoppingServices.catch(error => this.runtimeOrPreStartErrorSink.reportRuntimeTaskException('stateful authority route fencing', error));
+        };
+        this.ownerLeaseFailureHandler = failureHandler;
+        runtime.addOwnerLeaseRenewedHandler(handler);
+        if (typeof runtime.addOwnerLeaseRenewalFailedHandler === 'function') {
+            runtime.addOwnerLeaseRenewalFailedHandler(failureHandler);
+        }
+    }
+    createStatefulAuthorityRoutes(locationStore, spotNodeRuntime) {
+        return new stateful_authority_route_runtime_1.ZLinkStatefulAuthorityRouteRuntime({
+            store: locationStore,
+            creationStore: locationStore,
+            relocationStore: this.options.registration.locations.relocationStoreInstance,
+            meshNodes: spotNodeRuntime.meshNodesByName,
+            pollingIntervalMs: this.options.registration.locations.options.pollingIntervalMs
+                ?? Locations_1.zlinkDefaultLocationOptions.pollingIntervalMs,
+            pageSize: 1000,
+            reportError: (error) => this.runtimeOrPreStartErrorSink.reportRuntimeTaskException('stateful authority route reconciliation', error),
+            onSpotRouteChanged: (spotId) => this.cachedLocationSpotRouteResolver?.invalidate?.(spotId)
+        });
+    }
+    requiresStatefulAuthorityRuntime() {
+        for (const options of this.options.registration.spotNodes.values()) {
+            if (Object.keys(options.spotFactoryRegistrations ?? {}).length > 0
+                || Object.keys(options.instanceSpotFactoryRegistrations ?? {}).length > 0
+                || Object.keys(options.actorFactoryRegistrations ?? {}).length > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    installLocationBackedAuthorities(locationStore, spotNodeRuntime) {
+        for (const [meshName, node] of spotNodeRuntime.meshNodesByName) {
+            const activationNode = node;
+            const spotManager = this.spotManager;
+            if (spotManager !== undefined) {
+                this.registerInstanceApplicationLifecycle(meshName, activationNode, spotManager);
+            }
+            activationNode.registerAsyncInstanceActivationAuthority?.(new instance_activation_authority_1.ZLinkInstanceActivationAuthority({
+                store: locationStore,
+                relocationStore: this.options.registration.locations.relocationStoreInstance,
+                meshName,
+                owner: () => this.locationOwner.currentRuntime?.currentOwnerToken,
+                metrics: this.metrics,
+                onReady: (target, route) => {
+                    activationNode.registerInstanceIntent(target.stableType, route);
+                    this.locationOwner.currentLifecycle?.trackInstanceSpot({
+                        meshName,
+                        spotId: target.targetSpotId,
+                        stableType: target.stableType,
+                        nodeRid: route.targetNodeRid,
+                        nodeGeneration: route.targetNodeGeneration,
+                        objectGeneration: route.objectGeneration,
+                        authorityOwnerGeneration: route.authorityOwnerGeneration,
+                        ownerId: route.ownerId,
+                        ownerLeaseGeneration: route.leaseGeneration,
+                        storeVersion: route.storeVersion,
+                        deactivate: async () => {
+                            await spotManager?.close(meshName, target.targetSpotId);
+                        }
+                    });
+                }
+            }));
+        }
+    }
+    removeOwnerLeaseRecoveryPublication() {
+        if (this.ownerLeaseRecoveryRuntime !== undefined && this.ownerLeaseRecoveryHandler !== undefined) {
+            this.ownerLeaseRecoveryRuntime.removeOwnerLeaseRenewedHandler(this.ownerLeaseRecoveryHandler);
+        }
+        if (this.ownerLeaseRecoveryRuntime !== undefined && this.ownerLeaseFailureHandler !== undefined) {
+            if (typeof this.ownerLeaseRecoveryRuntime.removeOwnerLeaseRenewalFailedHandler === 'function') {
+                this.ownerLeaseRecoveryRuntime.removeOwnerLeaseRenewalFailedHandler(this.ownerLeaseFailureHandler);
+            }
+        }
+        this.ownerLeaseRecoveryRuntime = undefined;
+        this.ownerLeaseRecoveryHandler = undefined;
+        this.ownerLeaseFailureHandler = undefined;
+    }
+    async onApplicationBootstrap() {
+        await this.start();
+    }
+    async onApplicationShutdown() {
+        await this.shutdown();
+    }
+    async performMeshDrain(meshName, signal, stopStartingSignal) {
+        await this.serviceRelocation.relocateMesh(meshName, this.relocationTargetApplicationVersion, signal, stopStartingSignal);
+    }
+    async performMeshShutdown(meshName, signal) {
+        await this.spotManager?.drainForShutdown(meshName, signal, this.runtimeDeadline);
+        await awaitWithDrainSignal(this.streamRuntime?.notifyServerDrain(meshName), signal);
+    }
+    async publishMeshRetiring(meshName, signal) {
+        await this.spotNodeRuntime?.publishMeshNodeState(contracts_1.ZLinkFrameworkRuntimeState.Relocating, signal, meshName);
+    }
+    async publishMeshServing(meshName, signal) {
+        await this.spotNodeRuntime?.reconcileAndPublishMeshNodeState(contracts_1.ZLinkFrameworkRuntimeState.Serving, meshName, signal);
+        // A failed relocation rolls the local object barriers back before the
+        // descriptor is published as Serving. Reconcile the durable authority
+        // routes before returning so the next local request cannot observe the
+        // brief window where the Location row is ready but the route cache still
+        // reflects the failed capture.
+        await this.statefulAuthorityRoutes?.reconcile(signal);
+    }
+    async publishMeshDraining(meshName, signal) {
+        const node = this.spotNodeRuntime?.meshNode(meshName);
+        if (node !== undefined) {
+            await node.publishDraining?.();
+        }
+        await this.spotNodeRuntime?.publishMeshNodeState(contracts_1.ZLinkFrameworkRuntimeState.Draining, signal, meshName);
+    }
+    async preflightAutomaticPeerReadiness(deadlineAt, targetApplicationVersion) {
+        // A host with no local stateful workload has nothing to move. The public
+        // Relocate contract completes that case without requiring a replacement
+        // target; the host drain still publishes its retiring state below.
+        if (!this.hasLocalStatefulRelocationWork())
+            return undefined;
+        if (this.options.registration.spotNodes.size === 0)
+            return undefined;
+        const location = this.locationOwner.currentRuntime;
+        if (location === undefined)
+            return contracts_1.ZLinkFrameworkRelocationReason.StoreUnavailable;
+        let storeUnavailable = false;
+        while (performance.now() < deadlineAt) {
+            try {
+                if (await this.hasExactAutomaticPeerReadiness(location, targetApplicationVersion))
+                    return undefined;
+                storeUnavailable = false;
+            }
+            catch {
+                storeUnavailable = true;
+            }
+            await new Promise((resolve) => setTimeout(resolve, Math.min(this.options.registration.locations.options.pollingIntervalMs
+                ?? Locations_1.zlinkDefaultLocationOptions.pollingIntervalMs, Math.max(1, deadlineAt - performance.now()))));
+        }
+        return storeUnavailable
+            ? contracts_1.ZLinkFrameworkRelocationReason.StoreUnavailable
+            : contracts_1.ZLinkFrameworkRelocationReason.TargetUnavailable;
+    }
+    hasLocalStatefulRelocationWork() {
+        const spotManager = this.spotManager;
+        if (spotManager !== undefined) {
+            for (const meshName of this.options.registration.spotNodes.keys()) {
+                if (spotManager.relocationActivations(meshName).length > 0)
+                    return true;
+            }
+        }
+        return this.actorManager?.snapshotStates().some((state) => state.hasActorOrCreation) ?? false;
+    }
+    async hasExactAutomaticPeerReadiness(location, targetApplicationVersion) {
+        for (const [meshName, registration] of this.options.registration.spotNodes) {
+            if ((registration.router?.manualConnections?.length ?? 0) > 0
+                || (registration.router?.manualPeerConnections?.length ?? 0) > 0) {
+                continue;
+            }
+            const node = this.spotNodeRuntime?.meshNode(meshName);
+            if (node === undefined)
+                return false;
+            const local = node.status();
+            const localDescriptor = this.spotNodeRuntime?.meshNodeDescriptor(meshName);
+            if (localDescriptor === undefined)
+                return false;
+            const descriptors = await location.listLiveMeshNodes(meshName);
+            const peers = node.peers();
+            if (!hasExactPeerReadiness(descriptors, {
+                ...local,
+                applicationVersion: targetApplicationVersion,
+                maintenanceWave: localDescriptor.maintenanceWave
+            }, peers))
+                return false;
+        }
+        return true;
+    }
+    async publishHostRelocated() {
+        await Promise.all([...this.options.registration.spotNodes.keys()].map(meshName => this.spotNodeRuntime?.publishMeshNodeState(contracts_1.ZLinkFrameworkRuntimeState.Relocated, undefined, meshName)));
+    }
+    async publishHostDraining(signal) {
+        try {
+            const runtime = this.locationOwner.currentRuntime;
+            if (runtime !== undefined && !await runtime.publishDraining(signal)) {
+                throw new Error('Draining descriptor publication returned false.');
+            }
+        }
+        catch (error) {
+            throw new ZLinkDrainingStatePublishError(error);
+        }
+    }
+    async cleanupOwnerForDrain(signal) {
+        const runtime = this.locationOwner.currentRuntime;
+        if (runtime === undefined)
+            return;
+        try {
+            await runtime.cleanupOwner(signal);
+        }
+        catch (error) {
+            throw new locations_1.ZLinkOwnerCleanupError(error);
+        }
+    }
+    async forceStopMesh(meshName) {
+        await waitForForcedSessionNotification(this.streamRuntime?.notifyServerDrain(meshName));
+        await this.spotManager?.drainForShutdown(meshName, undefined, this.runtimeDeadline);
+    }
+    registerInstanceApplicationLifecycle(meshName, node, spotManager) {
+        const activationNode = node;
+        activationNode.registerInstanceApplicationLifecycle?.({
+            isMaterialized: (target) => spotManager.isInstanceMaterialized(meshName, target.stableType, target.targetSpotId),
+            isMaterializing: (target) => spotManager.isInstanceMaterializing(meshName, target.targetSpotId),
+            isClosing: (target) => spotManager.isInstanceClosing(meshName, target.targetSpotId),
+            isIdleEvicting: (target) => spotManager.isInstanceSpotIdleEvicting(meshName, target.targetSpotId),
+            beginIdleEviction: (target) => spotManager.beginInstanceSpotIdleEviction(meshName, target.targetSpotId),
+            materialize: (target, objectGeneration) => spotManager.materializeInstance(meshName, target.stableType, target.targetSpotId, objectGeneration, this.executionState?.abortController.signal),
+            discard: (target) => spotManager.discardInstance(meshName, target.targetSpotId),
+            beginTerminal: (target) => spotManager.beginInstanceTerminal(meshName, target.targetSpotId, target.objectGeneration),
+            completeTerminal: (target) => spotManager.completeInstanceTerminal(meshName, target.targetSpotId, target.objectGeneration)
+        });
+    }
+    setActorManager(actorManager) {
+        this.actorManager = actorManager;
+    }
+    setSpotManager(spotManager) {
+        this.spotManager = spotManager;
+        for (const [meshName, node] of this.spotNodeRuntime?.meshNodesByName ?? []) {
+            this.registerInstanceApplicationLifecycle(meshName, node, spotManager);
+        }
+    }
+    createActorManagerOptions() {
+        this.ensureLocationRuntime();
+        return {
+            ...this.actorRuntimeOptionsFactory().createActorManagerOptions(),
+            placementCreate: async (actorId, actorType, createOnly, call, signal) => {
+                const placement = this.actorPlacement;
+                if (placement === undefined) {
+                    throw new ConfigurationException_1.ZLinkConfigurationException('Actor placement runtime is not initialized.');
+                }
+                const requestPayload = (0, creation_payload_codec_1.encodeFrameworkCreationPayload)(call.request, this.options.registration.messageSerializers);
+                return await placement.create(actorId, actorType, createOnly, call.meshName, requestPayload, call.timeoutMs, signal);
+            }
+        };
+    }
+    createActorClientOptions() {
+        this.ensureLocationRuntime();
+        const options = this.actorRuntimeOptionsFactory().createActorClientOptions();
+        this.actorClientLocationResolver = options.locationResolver();
+        return options;
+    }
+    createLocationHandleResolver() {
+        this.ensureLocationRuntime();
+        return this.locationOwner.createRefResolver(this.meshRouters.spotLocationMeshNames());
+    }
+    createSpotManagerOptions() {
+        this.ensureLocationRuntime();
+        return {
+            ...new spot_runtime_options_factory_1.ZLinkSpotRuntimeOptionsFactory({
+                registration: this.options.registration,
+                channelTransport: this.channelTransport,
+                routeTransport: this.routeTransport,
+                addressTransport: this.spotAddressTransport,
+                spotPublisherTransport: this.spotPublisherTransport,
+                meshRouters: this.meshRouters,
+                runtimeEventPublisher: this.runtimeEventPublisher,
+                spotNodeRuntime: () => this.spotNodeRuntime,
+                actorManager: () => this.actorManager,
+                // User Spot visibility is published only by the generic authority
+                // coordinator after application initialization. The legacy location
+                // claim would expose a Creating object before that Ready barrier.
+                locationLifecycle: () => undefined,
+                releaseInstanceAuthority: (meshName, spotId, objectGeneration) => this.locationOwner.currentLifecycle?.releaseSpot(meshName, spotId, objectGeneration)
+                    ?? Promise.resolve(),
+                beginInstanceIdleClosingAuthority: (meshName, spotId) => this.locationOwner.currentLifecycle?.beginInstanceSpotClosing(meshName, spotId)
+                    ?? Promise.resolve(undefined),
+                beginInstanceClosingAuthority: (meshName, spotId) => this.locationOwner.currentLifecycle?.beginInstanceSpotClosing(meshName, spotId)
+                    ?? Promise.resolve(undefined),
+                createLocationSpotRouteResolver: () => this.createLocationSpotRouteResolver(),
+                boundSessionRelay: this.boundSessionRelay,
+                actorHandoff: this.actorHandoff,
+                dispatchErrorReporter: (errorSink) => this.createDispatchErrorReporter(errorSink),
+                runtimeOrPreStartErrorSink: this.runtimeOrPreStartErrorSink,
+                detachedTaskRunner: this.detachedTaskRunner(),
+                metrics: this.metrics,
+                admission: this.admission,
+                statefulExecutionAllowed: () => {
+                    const locationRuntime = this.locationOwner.currentRuntime;
+                    if (locationRuntime !== undefined)
+                        return locationRuntime.ownerLeaseUsable;
+                    // A host configured with a Location Store must not execute stateful
+                    // timers while its lease runtime is unavailable. Hosts without a
+                    // Location Store have no owner lease to fence.
+                    return this.locationOwner.currentStores?.locationStore === undefined;
+                }
+            }).create(this.actorTransferRuntime),
+            activationConcurrencyLimitProvider: (meshName) => this.options.registration.spotNodes.get(meshName)?.activationConcurrencyLimit ?? 128,
+            onInstanceActivationConcurrencyChanged: (meshName) => {
+                void this.spotNodeRuntime?.publishMeshNodeState(this.runtimeState, this.executionState?.abortController.signal, meshName).catch(() => undefined);
+            }
+        };
+    }
+    createPublicSpotManager(local) {
+        const locationStore = this.locationOwner.locationStore();
+        if (locationStore === undefined) {
+            throw new ConfigurationException_1.ZLinkConfigurationException('User Spot creation requires a Location Store.');
+        }
+        this.actorPlacement ??= new actor_placement_coordinator_1.ZLinkActorPlacementCoordinator({
+            store: locationStore,
+            remoteCreate: (meshName, targetNodeRid, request, timeoutMs) => {
+                const node = this.spotNodeRuntime?.meshNode(meshName);
+                if (node === undefined) {
+                    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ObjectClientNotConfigured, `RouteMesh '${meshName}' has no local client node.`);
+                }
+                return node.requestActorCreate(targetNodeRid, request, timeoutMs);
+            },
+            decodeRemoteReply: payload => {
+                const message = runtime_message_1.ZLinkBufferMessage.from(payload);
+                try {
+                    return (0, payload_codec_1.decodeFrameworkPayloadMessage)(message, this.options.registration.messageSerializers);
+                }
+                finally {
+                    message.close();
+                }
+            },
+            target: async (requestedMesh, stableType, signal, excludedNodeRids) => {
+                const clientMeshes = [...this.options.registration.spotNodes]
+                    .filter(([, node]) => (0, spot_address_transport_1.hasObjectClientCapability)(node.objectRole))
+                    .map(([meshName]) => meshName);
+                const meshes = requestedMesh === undefined ? clientMeshes : [requestedMesh];
+                if (meshes.length === 0) {
+                    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ObjectClientNotConfigured, 'No object-client RouteMesh is configured.');
+                }
+                if (requestedMesh === undefined && meshes.length > 1) {
+                    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.MeshSelectionRequired, 'Multiple object-client RouteMeshes are configured; call inMesh(...).');
+                }
+                const meshName = meshes[0];
+                if (!clientMeshes.includes(meshName)) {
+                    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ObjectClientNotConfigured, `RouteMesh '${meshName}' has no object-client role.`);
+                }
+                const meshNode = this.spotNodeRuntime?.meshNode(meshName);
+                const descriptors = (await locationStore.listMeshNodes(meshName, undefined, signal)).items;
+                const selected = await selectReadyLocationPlacementDescriptor(descriptors, meshNode, signal, descriptor => {
+                    const capability = descriptor.objectCapabilities.find(candidate => candidate.objectKind === 'actor'
+                        && candidate.stableType === stableType);
+                    const actors = descriptor.populationCapacity.actors;
+                    return descriptor.state === contracts_1.ZLinkFrameworkRuntimeState.Serving
+                        && descriptor.objectRole === 'server'
+                        && descriptor.placementWeight > 0
+                        && descriptor.entrySpotId !== undefined
+                        && excludedNodeRids?.has(String(descriptor.rid)) !== true
+                        && (actors.limit === 0 || actors.active + actors.reserved < actors.limit)
+                        && capability !== undefined;
+                });
+                if (selected === undefined)
+                    return undefined;
+                const localStatus = meshNode?.status();
+                return {
+                    meshName,
+                    nodeRid: selected.rid,
+                    nodeGeneration: selected.lifecycleGeneration,
+                    entrySpotId: selected.entrySpotId,
+                    owner: {
+                        ownerId: selected.ownerId,
+                        leaseGeneration: selected.leaseGeneration
+                    },
+                    isLocal: localStatus !== undefined
+                        && String(localStatus.routingId) === String(selected.rid)
+                        && localStatus.lifecycleGeneration === selected.lifecycleGeneration
+                };
+            }
+        });
+        const coordinator = new user_spot_creation_coordinator_1.ZLinkUserSpotCreationCoordinator({
+            store: locationStore,
+            publishReadyRoute: (meshName, route) => {
+                this.cachedLocationSpotRouteResolver?.invalidate?.(route.spot.spotId);
+                this.spotNodeRuntime?.meshNode(meshName)?.rememberSpotRoute?.(route);
+            },
+            forgetReadyRoute: (meshName, route) => {
+                this.cachedLocationSpotRouteResolver?.invalidate?.(route.spot.spotId);
+                this.spotNodeRuntime?.meshNode(meshName)?.forgetSpotRoute?.(route.spot, route.authorityOwnerGeneration, route.storeVersion);
+            },
+            remoteCreate: (meshName, targetNodeRid, request, timeoutMs) => {
+                const node = this.spotNodeRuntime?.meshNode(meshName);
+                if (node === undefined) {
+                    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ObjectClientNotConfigured, `RouteMesh '${meshName}' has no local client node.`);
+                }
+                return node.requestUserSpotCreate(targetNodeRid, request, timeoutMs);
+            },
+            decodeRemoteReply: payload => {
+                const message = runtime_message_1.ZLinkBufferMessage.from(payload);
+                try {
+                    return (0, payload_codec_1.decodeFrameworkPayloadMessage)(message, this.options.registration.messageSerializers);
+                }
+                finally {
+                    message.close();
+                }
+            },
+            target: async (request, signal, excludedNodeRids) => {
+                const clientMeshes = [...this.options.registration.spotNodes]
+                    .filter(([, node]) => (0, spot_address_transport_1.hasObjectClientCapability)(node.objectRole))
+                    .map(([meshName]) => meshName);
+                const meshes = request.meshName === undefined ? clientMeshes : [request.meshName];
+                if (meshes.length === 0) {
+                    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ObjectClientNotConfigured, 'No object-client RouteMesh is configured.');
+                }
+                if (request.meshName === undefined && meshes.length > 1) {
+                    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.MeshSelectionRequired, 'Multiple object-client RouteMeshes are configured; call inMesh(...).');
+                }
+                const meshName = meshes[0];
+                if (!this.options.registration.spotNodes.has(meshName)) {
+                    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.MeshNotFound, `RouteMesh '${meshName}' is not configured.`);
+                }
+                if (!clientMeshes.includes(meshName)) {
+                    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ObjectClientNotConfigured, `RouteMesh '${meshName}' has no object-client role.`);
+                }
+                const meshNode = this.spotNodeRuntime?.meshNode(meshName);
+                const descriptors = (await locationStore.listMeshNodes(meshName, undefined, signal)).items;
+                const selected = await selectReadyLocationPlacementDescriptor(descriptors, meshNode, signal, descriptor => {
+                    const capability = descriptor.objectCapabilities.find(candidate => candidate.objectKind === 'user_spot'
+                        && candidate.stableType === request.stableType);
+                    const spotTypeCapacity = descriptor.populationCapacity.spotTypes.find(candidate => candidate.objectKind === 'user_spot'
+                        && candidate.stableType === request.stableType);
+                    const spots = descriptor.populationCapacity.spots;
+                    return descriptor.state === 1
+                        && descriptor.objectRole === 'server'
+                        && descriptor.placementWeight > 0
+                        && excludedNodeRids?.has(String(descriptor.rid)) !== true
+                        && (spots.limit === 0 || spots.active + spots.reserved < spots.limit)
+                        && capability !== undefined
+                        && (spotTypeCapacity === undefined
+                            || spotTypeCapacity.limit === 0
+                            || spotTypeCapacity.active + spotTypeCapacity.reserved
+                                < spotTypeCapacity.limit);
+                });
+                if (selected === undefined)
+                    return undefined;
+                const localStatus = meshNode?.status();
+                return {
+                    meshName,
+                    nodeRid: selected.rid,
+                    nodeGeneration: selected.lifecycleGeneration,
+                    owner: {
+                        ownerId: selected.ownerId,
+                        leaseGeneration: selected.leaseGeneration
+                    },
+                    isLocal: localStatus !== undefined
+                        && String(localStatus.routingId) === String(selected.rid)
+                        && localStatus.lifecycleGeneration === selected.lifecycleGeneration
+                };
+            }
+        });
+        const factories = new Map([...this.options.registration.spotNodes].map(([meshName, node]) => [
+            meshName,
+            new Map(Object.entries(node.spotFactoryRegistrations ?? {}))
+        ]));
+        const registerUserSpotHandlers = (runtime) => {
+            for (const [meshName] of this.options.registration.spotNodes) {
+                const node = runtime.meshNode(meshName);
+                if (node === undefined)
+                    continue;
+                node.registerUserSpotOperationHandler({
+                    create: async (record, signal) => {
+                        const coordinated = await coordinator.handleRemoteCreate(record, async (requestPayload, authority, createSignal) => {
+                            const selected = factories.get(meshName)?.get(record.stableType);
+                            if (selected === undefined) {
+                                throw new ConfigurationException_1.ZLinkConfigurationException(`User Spot factory '${record.stableType}' is not registered on RouteMesh '${meshName}'.`);
+                            }
+                            const request = (0, creation_payload_codec_1.decodeFrameworkCreationPayload)(requestPayload, this.options.registration.messageSerializers);
+                            local.beginUserSpotPublication(meshName, record.spotId);
+                            try {
+                                const result = await local.getOrCreateWithAuthority(meshName, selected.implementation, record.spotId, request, {
+                                    stableType: record.stableType,
+                                    objectGeneration: authority.objectGeneration,
+                                    authorityOwnerGeneration: authority.authorityOwnerGeneration
+                                }, createSignal);
+                                return {
+                                    ...result,
+                                    publication: {
+                                        publish: () => local.publishUserSpot(meshName, record.spotId),
+                                        abort: () => local.abortUserSpotPublication(meshName, record.spotId)
+                                    }
+                                };
+                            }
+                            catch (error) {
+                                local.abortUserSpotPublication(meshName, record.spotId);
+                                throw error;
+                            }
+                        }, async (cleanupSignal) => {
+                            await local.close(meshName, record.spotId, cleanupSignal);
+                        }, signal);
+                        const reply = coordinated.result.reply;
+                        let payload;
+                        if (reply !== undefined
+                            && coordinated.result.state !== contracts_1.ZLinkSpotCreateState.Existing) {
+                            const message = (0, payload_codec_1.encodeFrameworkPayloadMessage)(reply, this.options.registration.messageSerializers);
+                            try {
+                                payload = {
+                                    packetName: 'ZLinkFrameworkUserSpotReply',
+                                    contentType: 'application/octet-stream',
+                                    payload: Buffer.from(message.data())
+                                };
+                            }
+                            finally {
+                                message.close();
+                            }
+                        }
+                        return {
+                            terminalResult: runtime_values_1.RequestResult.Ok,
+                            failureCode: 0,
+                            tail: {
+                                kind: 'userSpotCreate',
+                                createResult: coordinated.result.state === contracts_1.ZLinkSpotCreateState.Existing
+                                    ? 'existing'
+                                    : coordinated.result.state === contracts_1.ZLinkSpotCreateState.Created
+                                        ? 'created'
+                                        : 'rejected',
+                                spotId: String(coordinated.spot.spotId),
+                                objectGeneration: coordinated.spot.objectGeneration
+                            },
+                            ...(payload === undefined ? {} : { payload })
+                        };
+                    },
+                    createActor: async (record, signal) => {
+                        const actorPlacement = this.actorPlacement;
+                        const actors = this.actorManager;
+                        if (actorPlacement === undefined || actors === undefined) {
+                            throw new ConfigurationException_1.ZLinkConfigurationException('Actor placement target runtime is not initialized.');
+                        }
+                        return await actorPlacement.handleRemoteCreate(record, async (requestPayload, authority, createSignal) => {
+                            const request = (0, creation_payload_codec_1.decodeFrameworkCreationPayload)(requestPayload, this.options.registration.messageSerializers);
+                            const entrySpot = node.entrySpot().status();
+                            const nativeActorRef = node.restoreActorAuthority?.(record.actorId, record.stableType, authority.objectGeneration, authority.authorityOwnerGeneration, String(entrySpot.routingId), entrySpot.lifecycleGeneration, 1n);
+                            if (nativeActorRef === undefined) {
+                                throw new ConfigurationException_1.ZLinkConfigurationException('Remote Actor creation requires native authority restoration support.');
+                            }
+                            const local = await actors.createReservedActorResult(record.actorId, record.stableType, request, createSignal, nativeActorRef);
+                            if (local.status === 'rejected') {
+                                let reply;
+                                if (local.reply !== undefined) {
+                                    const encoded = (0, payload_codec_1.encodeFrameworkPayloadMessage)(local.reply, this.options.registration.messageSerializers);
+                                    try {
+                                        reply = Buffer.from(encoded.data());
+                                    }
+                                    finally {
+                                        encoded.close();
+                                    }
+                                }
+                                return {
+                                    result: 'rejected',
+                                    ...(reply === undefined ? {} : { reply })
+                                };
+                            }
+                            if (local.actorRef.objectGeneration !== authority.objectGeneration
+                                || String(local.actorRef.nodeRid) !== record.reservation.targetNodeRid) {
+                                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorCreateFailed, `Actor '${record.actorId}' native authority does not match its placement reservation.`);
+                            }
+                            let reply;
+                            if (local.reply !== undefined) {
+                                const encoded = (0, payload_codec_1.encodeFrameworkPayloadMessage)(local.reply, this.options.registration.messageSerializers);
+                                try {
+                                    reply = Buffer.from(encoded.data());
+                                }
+                                finally {
+                                    encoded.close();
+                                }
+                            }
+                            return {
+                                result: 'created',
+                                actor: {
+                                    ...local.actorRef,
+                                    meshName
+                                },
+                                entrySpotId: String(entrySpot.routingId),
+                                entrySpotGeneration: entrySpot.lifecycleGeneration,
+                                ...(reply === undefined ? {} : { reply }),
+                                onPublished: () => actors.adoptCreatedAuthority(record.actorId, authority.authorityOwnerGeneration, authority.ownerLeaseGeneration)
+                            };
+                        }, signal);
+                    },
+                    close: async (record, signal) => {
+                        if (!local.hasActiveSpot(record.target.spotId)) {
+                            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, `User Spot '${record.target.spotId}' is not materialized on its authority owner.`, true);
+                        }
+                        if (!local.canCloseUserSpot(meshName, record.target.spotId)) {
+                            return {
+                                terminalResult: runtime_values_1.RequestResult.Ok,
+                                failureCode: 0,
+                                tail: {
+                                    kind: 'userSpotClose',
+                                    closed: false
+                                }
+                            };
+                        }
+                        return {
+                            terminalResult: runtime_values_1.RequestResult.Ok,
+                            failureCode: 0,
+                            tail: {
+                                kind: 'userSpotClose',
+                                closed: await coordinator.handleRemoteClose(record, (spot, closeSignal) => local.close(spot.meshName, spot.spotId, closeSignal), signal)
+                            }
+                        };
+                    }
+                });
+            }
+        };
+        this.registerUserSpotHandlers = registerUserSpotHandlers;
+        if (this.spotNodeRuntime !== undefined) {
+            registerUserSpotHandlers(this.spotNodeRuntime);
+        }
+        return new spots_1.ZLinkPublicSpotManager({
+            local,
+            coordinator,
+            factories,
+            resolver: () => this.createLocationSpotRouteResolver(),
+            forgetReadyRoute: (spot, snapshot) => {
+                coordinator.forgetReadyRoute(spot.spotId, snapshot);
+            },
+            isLocalNode: (meshName, nodeRid) => {
+                const status = this.spotNodeRuntime?.meshNode(meshName)?.status();
+                return status !== undefined && String(status.routingId) === String(nodeRid);
+            },
+            remoteClose: (meshName, targetNodeRid, request, timeoutMs) => {
+                const node = this.spotNodeRuntime?.meshNode(meshName);
+                if (node === undefined) {
+                    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ObjectClientNotConfigured, `RouteMesh '${meshName}' has no local client node.`);
+                }
+                return node.requestUserSpotClose(targetNodeRid, request, timeoutMs);
+            },
+            defaultTimeoutMs: this.options.registration.requestTimeoutMs ?? 30_000,
+            messageSerializers: this.options.registration.messageSerializers
+        });
+    }
+    actorRuntimeOptionsFactory() {
+        return new actor_runtime_options_factory_1.ZLinkActorRuntimeOptionsFactory({
+            registration: this.options.registration,
+            messageFlow: () => this.createDispatchErrorReporter(this.runtimeOrPreStartErrorSink).flow,
+            routeTransport: this.routeTransport,
+            streamBindingRuntime: this.streamBindingRuntime,
+            providerResolver: this.options.providerResolver,
+            spotManager: () => this.spotManager,
+            actorManager: () => this.actorManager,
+            primaryMeshNode: () => this.requirePrimaryMeshNode(),
+            primaryMeshNodeOrUndefined: () => this.spotNodeRuntime?.primaryMeshNode,
+            primaryMeshCompletions: () => this.spotNodeRuntime?.primaryMeshCompletions,
+            meshNode: (meshName) => this.spotNodeRuntime?.meshNode(meshName),
+            meshCompletions: (meshName) => this.spotNodeRuntime?.meshCompletionTable(meshName),
+            notifyEntrySpotActorCreated: (nodeRid, actor, createRequest, signal) => this.spotNodeRuntime?.notifyEntrySpotActorCreated(nodeRid, actor, createRequest, signal)
+                ?? Promise.resolve(undefined),
+            locationLifecycle: () => this.locationOwner.currentLifecycle,
+            primaryMeshName: () => this.meshRouters.primaryMeshName(),
+            actorMeshName: (actorType) => this.meshRouters.actorMeshName(actorType),
+            createLocationSpotRouteResolver: () => this.createLocationSpotRouteResolver(),
+            createActorLocationResolver: () => this.createActorLocationResolver(),
+            forgetDestroyedActorRef: (actorId) => this.destroyedActorRefs.delete(actorId),
+            rememberDestroyedActorRef: (actorId, actorRef) => this.destroyedActorRefs.set(actorId, actorRef),
+            invalidateActorRoute: (actorId) => this.actorClientLocationResolver?.invalidateActorRoute(actorId),
+            publishActorAuthority: async (actorType, actorRef, ownerNodeGeneration, signal) => {
+                const store = this.locationOwner.currentStores?.locationStore;
+                if (store === undefined)
+                    return;
+                const owner = this.locationOwner.currentRuntime?.currentOwnerToken;
+                const meshName = this.meshRouters.actorMeshName(actorType);
+                if (owner === undefined || meshName === undefined) {
+                    throw new ConfigurationException_1.ZLinkConfigurationException(`Actor '${actorRef.actorId}' authority requires an active owner and Actor RouteMesh.`);
+                }
+                const entrySpotId = this.spotNodeRuntime?.entrySpotIdForMesh(meshName);
+                if (entrySpotId === undefined) {
+                    throw new ConfigurationException_1.ZLinkConfigurationException(`Actor '${actorRef.actorId}' authority requires its RouteMesh Entry Spot.`);
+                }
+                await (0, actors_2.publishInitialActorAuthority)(store, {
+                    actorType,
+                    actor: actorRef,
+                    meshName,
+                    ownerNodeGeneration,
+                    owner,
+                    spotId: entrySpotId,
+                    spotGeneration: ownerNodeGeneration,
+                    spotKind: contracts_1.ZLinkSpotKind.Entry
+                }, signal);
+                this.actorClientLocationResolver?.invalidateActorRoute(actorRef.actorId);
+            },
+            reportPostCommitError: (error) => this.runtimeOrPreStartErrorSink.reportRuntimeTaskException('post-commit actor binding', error),
+            reportBoundSessionSendError: (error) => this.runtimeOrPreStartErrorSink.reportRuntimeTaskException('bound session one-way submit', error),
+            actorHandoff: this.actorHandoff,
+            actorTransferRuntime: this.actorTransferRuntime,
+            actorJoinRelocation: this.serviceRelocation,
+            actorTransferRegistry: this.actorTransferRegistry,
+            shutdownSignal: () => this.executionState?.abortController.signal,
+            metrics: this.metrics,
+            admission: this.admission,
+            actorPacketTargetForState: (actorId) => this.boundSessionRelay.actorPackets.actorPacketTargetForState(actorId),
+            flowCreationEnabled: () => this.flowCreationEnabled(),
+            traceBoundSessionSend: (actorId, packetName) => {
+                const flow = this.createDispatchErrorReporter(this.runtimeOrPreStartErrorSink).flow;
+                (0, diagnostics_1.flowIfEnabled)(flow, ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent)?.trace({
+                    outcome: ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent,
+                    surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.SpotActor,
+                    messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorSend,
+                    packetName,
+                    actorId
+                });
+            }
+        });
+    }
+    createChannelRuntimeOptions() {
+        return new channel_runtime_options_factory_1.ZLinkChannelRuntimeOptionsFactory({
+            monitoringAdapter: this.backendAdapterFactory.createMonitoringAdapter(),
+            messageFlowModeCell: this.messageFlowModeCell,
+            boundSessionRelay: this.boundSessionRelay,
+            applicationJobQueue: this.applicationJobQueue,
+            spotManager: () => this.spotManager,
+            oneWayFailureSink: (error) => this.runtimeOrPreStartErrorSink.reportRuntimeTaskException('channel one-way submit', error)
+        }).create();
+    }
+    createSpotNodeRuntimeOptions(context, dispatchErrors) {
+        const options = new spot_node_runtime_options_factory_1.ZLinkSpotNodeRuntimeOptionsFactory({
+            registration: this.options.registration,
+            backendAdapterFactory: this.backendAdapterFactory,
+            context,
+            channelTransport: this.channelTransport,
+            routeTransport: this.routeTransport,
+            spotPublisherTransport: this.spotPublisherTransport,
+            meshRouters: this.meshRouters,
+            providerResolver: this.options.providerResolver,
+            dispatchErrors,
+            runtimeEventPublisher: this.runtimeEventPublisher,
+            entryActorRuntime: this.entryActorRuntime,
+            actorTransferRuntime: this.actorTransferRuntime,
+            boundSessionRelay: this.boundSessionRelay,
+            actorHandoff: this.actorHandoff,
+            detachedTaskRunner: this.detachedTaskRunner(),
+            metrics: this.metrics,
+            applicationJobQueue: this.applicationJobQueue,
+            applicationJobReceiveFlowFailureSink: (error) => this.runtimeOrPreStartErrorSink.reportRuntimeTaskException('RouteMesh receive-flow configuration', error)
+        }).create();
+        return {
+            ...options,
+            peerAdmissionSealed: (meshName) => !this.admission.accepts(meshName),
+            messageFollowReceiver: (record) => {
+                if (record.source.kind === 'actor') {
+                    this.actorClientLocationResolver?.invalidateActorRouteIfMatches({
+                        actorId: record.source.actor.actorId,
+                        objectGeneration: record.source.actor.generation,
+                        targetNodeRid: record.source.targetNodeRid,
+                        targetNodeGeneration: record.source.targetNodeGeneration,
+                        authorityOwnerGeneration: record.source.authorityOwnerGeneration,
+                        ownerLeaseGeneration: record.source.ownerLeaseGeneration
+                    });
+                    return;
+                }
+                this.actorClientLocationResolver?.invalidateSpotRouteIfMatches({
+                    spotId: record.source.spot.spotId,
+                    objectGeneration: record.source.spot.generation,
+                    targetNodeRid: record.source.targetNodeRid,
+                    targetNodeGeneration: record.source.targetNodeGeneration,
+                    authorityOwnerGeneration: record.source.authorityOwnerGeneration,
+                    ownerLeaseGeneration: record.source.ownerLeaseGeneration
+                });
+            },
+            meshRecordDispatcher: (meshName, owner, record) => this.dispatchMeshRecord(meshName, owner, record, this.executionState?.abortController.signal),
+            instanceActivationConcurrencyProvider: (meshName) => {
+                return this.spotManager?.instanceActivationConcurrency(meshName)
+                    ?? { active: 0, limit: this.options.registration.spotNodes.get(meshName)?.activationConcurrencyLimit ?? 128 };
+            }
+        };
+    }
+    async dispatchMeshRecord(meshName, owner, record, signal) {
+        if (record.operationKind === service_runtime_contracts_1.OperationKind.ActorJoin) {
+            if (this.spotManager === undefined) {
+                throw new ConfigurationException_1.ZLinkConfigurationException('MeshNode Actor join dispatch requires the Spot manager.');
+            }
+            return this.spotManager.dispatchMeshActorJoin(meshName, owner, record);
+        }
+        if (record.kind === service_runtime_contracts_1.ReceiveKind.ActorBinding) {
+            if (record.kindData?.kind !== 'actorBinding') {
+                throw new ConfigurationException_1.ZLinkConfigurationException('MeshNode Actor binding record has no binding generation.');
+            }
+            const binding = record.kindData;
+            const replyBindingFailure = (kind, message) => {
+                const terminal = kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorGenerationStale
+                    ? { terminalResult: runtime_values_1.RequestResult.InvalidState, failureCode: 0 }
+                    : (0, framework_errors_internal_1.internalFrameworkWireReply)((0, framework_errors_internal_1.createInternalFrameworkException)(kind, message));
+                if (record.replyFailure?.(terminal.terminalResult, terminal.failureCode)
+                    !== runtime_values_1.SubmitResult.Ok) {
+                    throw new ConfigurationException_1.ZLinkConfigurationException(`MeshNode Actor binding target '${binding.actor.actorId}' failure acknowledgement failed.`);
+                }
+            };
+            const replyBindingSuccess = () => {
+                if (record.reply(Buffer.alloc(0)) !== runtime_values_1.SubmitResult.Ok) {
+                    throw new ConfigurationException_1.ZLinkConfigurationException(`MeshNode Actor binding target '${binding.actor.actorId}' acknowledgement failed.`);
+                }
+            };
+            const state = this.actorManager?.getState(binding.actor.actorId);
+            const nativeActorRef = state?.nativeActorRef;
+            if (state === undefined
+                || nativeActorRef === undefined
+                || nativeActorRef.actorId !== binding.actor.actorId
+                || !(0, routing_id_1.routingIdsEqual)(nativeActorRef.nodeRid, binding.actor.nodeRid)) {
+                replyBindingFailure(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${binding.actor.actorId}' binding target is no longer current.`);
+                return;
+            }
+            if (nativeActorRef.generation !== binding.actor.generation) {
+                replyBindingFailure(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorGenerationStale, `Actor '${binding.actor.actorId}' binding object generation is stale.`);
+                return;
+            }
+            const node = state.meshName === meshName
+                ? this.spotNodeRuntime?.meshNode(meshName)
+                : undefined;
+            const localStatus = node?.status();
+            // ownsLocation tracks local cleanup responsibility, not Actor authority.
+            // A relocation target can exact-read committed authority without owning that cleanup.
+            if (localStatus === undefined
+                || !(0, routing_id_1.routingIdsEqual)(localStatus.routingId, binding.actor.nodeRid)
+                || localStatus.lifecycleGeneration !== binding.actorNodeGeneration
+                || state.locationGeneration !== binding.authorityOwnerGeneration
+                || state.isMoving) {
+                replyBindingFailure(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${binding.actor.actorId}' binding authority fence is stale.`);
+                return;
+            }
+            const sessionOwnerIsLocal = (0, routing_id_1.routingIdsEqual)(localStatus.routingId, binding.sessionNodeRid) && localStatus.lifecycleGeneration === binding.sessionOwnerNodeGeneration;
+            if (binding.transition === 'tombstone') {
+                const actorRef = {
+                    actorId: binding.actor.actorId,
+                    objectGeneration: binding.actor.generation,
+                    meshName,
+                    nodeRid: binding.actor.nodeRid
+                };
+                if (sessionOwnerIsLocal) {
+                    await this.streamBindingRuntime.retireRemoteBinding(actorRef, binding.sessionRid, binding.bindingGeneration, signal);
+                }
+                state.retireBoundSessionBinding(binding);
+                replyBindingSuccess();
+                return;
+            }
+            const target = this.boundSessionRelay.boundSessions.resolveRemoteBoundSessionTarget(binding.sessionNodeRid, binding.sessionRid);
+            if (target === undefined) {
+                replyBindingFailure(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${binding.actor.actorId}' Session route is unavailable.`);
+                return;
+            }
+            const installed = state.installBoundSessionBinding({
+                ...target,
+                sessionNodeRid: binding.sessionNodeRid,
+                sessionRid: binding.sessionRid,
+                sessionOwnerNodeGeneration: binding.sessionOwnerNodeGeneration,
+                sessionOwnerId: binding.sessionOwnerId,
+                sessionOwnerLeaseGeneration: binding.sessionOwnerLeaseGeneration,
+                bindingGeneration: binding.bindingGeneration
+            });
+            if (!installed) {
+                replyBindingFailure(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale, `Actor '${binding.actor.actorId}' Session binding generation is stale.`);
+                return;
+            }
+            replyBindingSuccess();
+            return Promise.resolve();
+        }
+        switch (record.kind) {
+            case service_runtime_contracts_1.ReceiveKind.TransferControl:
+                if (record.kindData?.kind !== 'transferControl') {
+                    throw new ConfigurationException_1.ZLinkConfigurationException('MeshNode transfer control record has no typed control payload.');
+                }
+                return this.actorTransferAuthorityRuntime.handle(meshName, record.kindData, signal);
+            case service_runtime_contracts_1.ReceiveKind.ChannelSend:
+            case service_runtime_contracts_1.ReceiveKind.ChannelRequest: {
+                const channelRuntime = this.channelRuntime;
+                if (channelRuntime === undefined) {
+                    throw new ConfigurationException_1.ZLinkConfigurationException('MeshNode channel dispatch requires the channel runtime.');
+                }
+                return this.admission.run(meshName, 'RouteMesh channel dispatch', () => channelRuntime.dispatchMeshChannel(meshName, record, signal));
+            }
+            case service_runtime_contracts_1.ReceiveKind.NodeSend:
+            case service_runtime_contracts_1.ReceiveKind.NodeRequest: {
+                if (await this.serviceRelocation.tryHandleControl(meshName, record, signal)) {
+                    return;
+                }
+                if (record.kind === service_runtime_contracts_1.ReceiveKind.NodeRequest && record.parts.length === 1) {
+                    const terminal = (0, actors_2.decodeRemoteActorSourceLeaveTerminal)(record.parts[0].data());
+                    if (terminal !== undefined) {
+                        if (await this.spotManager?.completeFormalSourceLeaveTerminal(terminal.actorId, terminal.transferId, terminal.succeeded) !== true) {
+                            throw new ConfigurationException_1.ZLinkConfigurationException(`Actor '${terminal.actorId}' has no matching formal transfer terminal gate.`);
+                        }
+                        if (record.reply(Buffer.alloc(0)) !== runtime_values_1.SubmitResult.Ok) {
+                            throw new ConfigurationException_1.ZLinkConfigurationException(`Actor '${terminal.actorId}' formal transfer terminal acknowledgement failed.`);
+                        }
+                        return Promise.resolve();
+                    }
+                }
+                const channelRuntime = this.channelRuntime;
+                if (channelRuntime === undefined) {
+                    throw new ConfigurationException_1.ZLinkConfigurationException('MeshNode node-direct dispatch requires the channel runtime.');
+                }
+                return this.admission.run(meshName, 'RouteMesh node dispatch', () => channelRuntime.dispatchMeshRoute(meshName, record, signal));
+            }
+            case service_runtime_contracts_1.ReceiveKind.SpotSend:
+            case service_runtime_contracts_1.ReceiveKind.SpotRequest:
+            case service_runtime_contracts_1.ReceiveKind.SpotMulticast:
+                return this.admission.run(meshName, 'RouteMesh Spot dispatch', () => this.dispatchMeshSpotRecord(meshName, owner, record));
+            case service_runtime_contracts_1.ReceiveKind.InstanceSpotActivation:
+                if (this.spotManager === undefined) {
+                    throw new ConfigurationException_1.ZLinkConfigurationException('MeshNode Instance Spot dispatch requires the Spot manager.');
+                }
+                return this.admission.run(meshName, 'RouteMesh Instance Spot dispatch', () => this.spotManager.dispatchMeshInstance(meshName, owner, record));
+            case service_runtime_contracts_1.ReceiveKind.SpotControl:
+                if (this.spotManager === undefined) {
+                    throw new ConfigurationException_1.ZLinkConfigurationException('MeshNode Spot control dispatch requires the Spot manager.');
+                }
+                return this.spotManager.dispatchMeshSpotControl(meshName, owner, record);
+            case service_runtime_contracts_1.ReceiveKind.ActorSend:
+            case service_runtime_contracts_1.ReceiveKind.ActorRequest:
+                if (this.spotManager === undefined) {
+                    throw new ConfigurationException_1.ZLinkConfigurationException('MeshNode Actor dispatch requires the Spot manager.');
+                }
+                return this.admission.run(meshName, 'RouteMesh Actor dispatch', () => this.spotManager.dispatchMeshActor(meshName, owner, record));
+            case service_runtime_contracts_1.ReceiveKind.SendReady:
+                return Promise.resolve();
+            default:
+                throw new ConfigurationException_1.ZLinkConfigurationException(`MeshNode record kind '${record.kind}' does not yet have a registered framework consumer.`);
+        }
+    }
+    submitLocalMeshRoute(meshName, sourceNodeRid, parts) {
+        const state = this.executionState;
+        const channelRuntime = this.channelRuntime;
+        if (state === undefined || channelRuntime === undefined || !this.admission.accepts(meshName)) {
+            return { status: submission_result_1.ZLinkSubmitStatus.Shutdown };
+        }
+        if (!channelRuntime.canDispatchLocalMeshRoute(meshName)) {
+            return { status: submission_result_1.ZLinkSubmitStatus.TargetNotFound };
+        }
+        const claim = this.admission.claim(meshName, 'RouteMesh local node dispatch');
+        const ownedParts = [];
+        try {
+            for (const part of parts) {
+                ownedParts.push(runtime_message_1.ZLinkBufferMessage.from(typeof part.data === 'function'
+                    ? part.data()
+                    : part));
+            }
+        }
+        catch (error) {
+            for (const part of ownedParts)
+                part.close();
+            claim.close();
+            throw error;
+        }
+        try {
+            state.taskRunner.runDetached('mesh-node-local-route-dispatch', async () => {
+                try {
+                    const permit = await this.applicationJobQueue.acquire(state.abortController.signal);
+                    permit.markApplicationQueued();
+                    await (0, application_job_queue_scope_1.runWithApplicationJobPermit)(permit, () => channelRuntime.dispatchLocalMeshRoute(meshName, sourceNodeRid, ownedParts));
+                }
+                finally {
+                    for (const part of ownedParts)
+                        part.close();
+                    claim.close();
+                }
+            });
+        }
+        catch (error) {
+            for (const part of ownedParts)
+                part.close();
+            claim.close();
+            throw error;
+        }
+        return { status: submission_result_1.ZLinkSubmitStatus.Submitted };
+    }
+    async dispatchMeshSpotRecord(meshName, owner, record) {
+        const envelope = (0, channel_envelope_1.decodeChannelEnvelope)(record.parts, undefined, this.flowCreationEnabled());
+        if (envelope.packetName === actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET) {
+            const payload = (0, channel_envelope_1.decodeChannelPayload)(envelope, { serializers: this.options.registration.messageSerializers });
+            const context = {
+                meshName,
+                packetName: envelope.packetName,
+                contentType: envelope.header.contentType,
+                sourceNodeRid: String(record.sourceNodeRid ?? ''),
+                metadata: (0, contracts_1.zlinkMessageMetadata)(envelope.header.metadata),
+                correlationId: envelope.header.correlationId ?? undefined
+            };
+            try {
+                const response = await this.boundSessionRelay.actorPackets
+                    .receiveRemoteActorPacketRelay(payload, context);
+                if (record.kind === service_runtime_contracts_1.ReceiveKind.SpotRequest) {
+                    record.reply((0, channel_envelope_1.encodeChannelReplyParts)(envelope.header, response));
+                }
+            }
+            catch (error) {
+                if (record.kind !== service_runtime_contracts_1.ReceiveKind.SpotRequest) {
+                    throw error;
+                }
+                record.reply((0, channel_envelope_1.encodeChannelErrorReplyParts)(envelope.header, error instanceof Error ? error.message : String(error)));
+            }
+            return;
+        }
+        if (await this.spotNodeRuntime?.dispatchEntrySpotRecord(meshName, owner, record) === true) {
+            return;
+        }
+        if (this.spotManager === undefined) {
+            throw new ConfigurationException_1.ZLinkConfigurationException('MeshNode Spot dispatch requires the Spot manager.');
+        }
+        await this.spotManager.dispatchMeshSpot(meshName, owner, record);
+    }
+    createDispatchErrorReporter(errorSink) {
+        const existing = this.dispatchErrorReporters.get(errorSink);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const reporter = new channels_1.ZLinkDispatchErrorReporter(undefined, undefined, errorSink, this.diagnosticsContext(), this.metrics);
+        this.dispatchErrorReporters.set(errorSink, reporter);
+        return reporter;
+    }
+    detachedTaskRunner() {
+        return {
+            runDetached: (taskName, callback) => {
+                const runner = this.executionState?.taskRunner;
+                if (runner !== undefined) {
+                    runner.runDetached(taskName, () => callback());
+                    return;
+                }
+                void callback().catch((error) => this.preStartErrorSink.reportRuntimeTaskException(taskName, error));
+            }
+        };
+    }
+    diagnosticsContext() {
+        this.cachedDiagnosticsContext ??= (0, diagnostics_1.createDiagnosticsContext)(this.options.registration.dispatch, this.options.providerResolver, this.messageFlowModeCell);
+        return this.cachedDiagnosticsContext;
+    }
+    flowCreationEnabled() {
+        const mode = this.executionState === undefined
+            ? this.options.registration.dispatch?.diagnostics.messageFlow ?? 'errors'
+            : this.messageFlowModeCell.mode;
+        return mode !== 'off';
+    }
+    runLifecycle(operation) {
+        const current = (0, diagnostics_1.currentOrCreateFlow)('Lifecycle', false);
+        const flow = current?.flowOrigin === 'Lifecycle'
+            ? current
+            : (0, diagnostics_1.createInboundFlow)(undefined, 'Lifecycle', this.flowCreationEnabled());
+        return (0, diagnostics_1.runWithFlow)(flow, operation);
+    }
+    requirePrimaryMeshNode() {
+        const node = this.spotNodeRuntime?.primaryMeshNode;
+        if (node === undefined) {
+            throw new Error('Primary Entry Spot node is not started.');
+        }
+        return node;
+    }
+    ensureLocationRuntime() {
+        return this.locationOwner.ensureRuntime(this.meshRouters.primaryMeshName());
+    }
+    createLocationSpotRouteResolver() {
+        if (this.cachedLocationSpotRouteResolver !== undefined) {
+            return this.cachedLocationSpotRouteResolver;
+        }
+        this.ensureLocationRuntime();
+        const legacy = this.locationOwner.createSpotRouteResolver(this.meshRouters.spotLocationMeshNames(), this.meshRouters.spotRouterChannelIdByMesh(), (spotId) => this.spotManager?.resolveLocalSpotRoute(spotId));
+        const authority = this.locationOwner.currentStores?.locationStore;
+        const resolver = authority === undefined
+            ? legacy
+            : new locations_1.ZLinkAuthoritySpotRouteResolver(authority, this.meshRouters.spotRouterChannelIdByMesh(), legacy, this.locationOwner.currentLeaseTracker, this.options.registration.locations.options.routeCacheMaxAgeMs, undefined, async (meshName, nodeRid, expectedLifecycleGeneration, signal) => {
+                const descriptor = (await authority.listMeshNodes(meshName, undefined, signal)).items.find((candidate) => (0, routing_id_1.routingIdsEqual)(candidate.rid, nodeRid)
+                    && candidate.lifecycleGeneration === expectedLifecycleGeneration);
+                return descriptor?.state;
+            });
+        this.cachedLocationSpotRouteResolver = resolver;
+        this.locationOwner.setSpotRouteInvalidator(resolver === undefined ? undefined : spotId => resolver.invalidate?.(spotId));
+        return resolver;
+    }
+    createActorLocationResolver() {
+        return this.locationOwner.createActorLocationResolver(this.meshRouters.spotLocationMeshNames());
+    }
+}
+exports.ZLinkFrameworkRuntimeHost = ZLinkFrameworkRuntimeHost;
+function hasUnsupportedManualTopology(registration) {
+    if ([...registration.routeChannelOptions.values()].some((route) => (route.manualConnections?.length ?? 0) > 0)) {
+        return true;
+    }
+    for (const node of registration.spotNodes.values()) {
+        if ((node.router?.manualConnections?.length ?? 0) > 0
+            || (node.router?.manualPeerConnections?.length ?? 0) > 0) {
+            return true;
+        }
+    }
+    for (const channel of registration.channels.values()) {
+        if ((channel.client?.manualConnections?.length ?? 0) > 0
+            || (channel.subscriber?.manualConnections?.length ?? 0) > 0) {
+            return true;
+        }
+        if (channel.publisher !== undefined
+            && !registration.locations.useInMemoryStores
+            && registration.locations.storeInstance === undefined) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasConfiguredLocationStore(registration) {
+    return registration.locations.useInMemoryStores
+        || registration.locations.storeInstance !== undefined;
+}
+function hasExactPeerReadiness(descriptors, local, peers) {
+    const replacementDescriptors = descriptors.filter((descriptor) => !(String(descriptor.rid) === String(local.routingId)
+        && descriptor.lifecycleGeneration === local.lifecycleGeneration)
+        && descriptor.state === contracts_1.ZLinkFrameworkRuntimeState.Serving
+        && local.applicationVersion !== undefined
+        && descriptor.applicationVersion === local.applicationVersion
+        && descriptor.objectRole === contracts_1.ZLinkObjectRole.Server
+        && (local.maintenanceWave === undefined
+            || descriptor.maintenanceWave !== local.maintenanceWave));
+    return replacementDescriptors.length > 0
+        && replacementDescriptors.some((descriptor) => peers.some((peer) => peer.routingId !== null
+            && String(peer.routingId) === String(descriptor.rid)
+            && peer.lifecycleGeneration === descriptor.lifecycleGeneration
+            && peer.state === 3));
+}
+var actor_transfer_authority_runtime_2 = require("./actor-transfer-authority-runtime");
+Object.defineProperty(exports, "ZLinkActorTransferAuthorityRuntime", { enumerable: true, get: function () { return actor_transfer_authority_runtime_2.ZLinkActorTransferAuthorityRuntime; } });
+Object.defineProperty(exports, "transferIdString", { enumerable: true, get: function () { return actor_transfer_authority_runtime_2.transferIdString; } });
+var route_mesh_runtime_2 = require("./route-mesh-runtime");
+Object.defineProperty(exports, "ZLinkRetiringRollbackError", { enumerable: true, get: function () { return route_mesh_runtime_2.ZLinkRetiringRollbackError; } });
+Object.defineProperty(exports, "ZLinkRouteMeshRuntimeCoordinator", { enumerable: true, get: function () { return route_mesh_runtime_2.ZLinkRouteMeshRuntimeCoordinator; } });
+var service_relocation_host_runtime_2 = require("./service-relocation-host-runtime");
+Object.defineProperty(exports, "ZLinkRelocationStateIncompatibleError", { enumerable: true, get: function () { return service_relocation_host_runtime_2.ZLinkRelocationStateIncompatibleError; } });
+var spot_address_transport_2 = require("./spot-address-transport");
+Object.defineProperty(exports, "ZLinkHostSpotAddressTransport", { enumerable: true, get: function () { return spot_address_transport_2.ZLinkHostSpotAddressTransport; } });
+var user_spot_creation_coordinator_2 = require("./user-spot-creation-coordinator");
+Object.defineProperty(exports, "ZLinkUserSpotCreationCoordinator", { enumerable: true, get: function () { return user_spot_creation_coordinator_2.ZLinkUserSpotCreationCoordinator; } });
+async function waitForForcedSessionNotification(operation) {
+    if (operation === undefined)
+        return;
+    let timeoutHandle;
+    const timeout = new Promise((resolve) => {
+        timeoutHandle = setTimeout(resolve, 100);
+    });
+    try {
+        await Promise.race([operation.catch(() => undefined), timeout]);
+    }
+    finally {
+        if (timeoutHandle !== undefined)
+            clearTimeout(timeoutHandle);
+    }
+}
+async function awaitWithDrainSignal(operation, signal) {
+    if (operation === undefined)
+        return;
+    if (signal.aborted)
+        throw signal.reason;
+    await new Promise((resolve, reject) => {
+        const onAbort = () => {
+            reject(signal.reason);
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        void operation.then(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, error => {
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+}
+class ZLinkDrainingStatePublishError extends Error {
+    constructor(cause) {
+        super('Failed to publish draining peer rows.', { cause });
+        this.name = 'ZLinkDrainingStatePublishError';
+    }
+}
+function resolveBackendAdapterFactory(internalOptions) {
+    if (typeof internalOptions === 'object'
+        && internalOptions !== null
+        && 'backendAdapterFactory' in internalOptions) {
+        const factory = internalOptions.backendAdapterFactory;
+        if (factory !== undefined) {
+            return factory;
+        }
+    }
+    return new backend_1.ZLinkNodeBackendAdapterFactory();
+}
+function resolveStreamPayloadCodec(registration) {
+    const codec = registration.codecs.streamCodecs.values().next().value;
+    if (isStreamPayloadCodec(codec)) {
+        return codec;
+    }
+    return undefined;
+}
+function runtimeStateMetricName(state) {
+    switch (state) {
+        case contracts_1.ZLinkFrameworkRuntimeState.Preparing: return 'preparing';
+        case contracts_1.ZLinkFrameworkRuntimeState.Serving: return 'serving';
+        case contracts_1.ZLinkFrameworkRuntimeState.Relocating: return 'relocating';
+        case contracts_1.ZLinkFrameworkRuntimeState.Relocated: return 'relocated';
+        case contracts_1.ZLinkFrameworkRuntimeState.Draining: return 'draining';
+        case contracts_1.ZLinkFrameworkRuntimeState.Stopped: return 'stopped';
+        case contracts_1.ZLinkFrameworkRuntimeState.Error: return 'error';
+    }
+}
+function relocationModeMetricName(mode) {
+    return mode === contracts_1.ZLinkFrameworkRelocationMode.RollingUpdate
+        ? 'rolling_update'
+        : 'planned_maintenance';
+}
+function relocationReasonMetricName(reason) {
+    switch (reason) {
+        case contracts_1.ZLinkFrameworkRelocationReason.None: return 'none';
+        case contracts_1.ZLinkFrameworkRelocationReason.TargetUnavailable: return 'target_unavailable';
+        case contracts_1.ZLinkFrameworkRelocationReason.StoreUnavailable: return 'store_unavailable';
+        case contracts_1.ZLinkFrameworkRelocationReason.RelocationDisabled: return 'relocation_disabled';
+        case contracts_1.ZLinkFrameworkRelocationReason.StateIncompatible: return 'state_incompatible';
+        case contracts_1.ZLinkFrameworkRelocationReason.DeadlineExceeded: return 'deadline_exceeded';
+        case contracts_1.ZLinkFrameworkRelocationReason.RelocationFailed: return 'relocation_failed';
+        case contracts_1.ZLinkFrameworkRelocationReason.RuntimeNotReady: return 'runtime_not_ready';
+        case contracts_1.ZLinkFrameworkRelocationReason.ManualTopologyUnsupported: return 'manual_topology_unsupported';
+        case contracts_1.ZLinkFrameworkRelocationReason.ShutdownRequested: return 'shutdown_requested';
+        case contracts_1.ZLinkFrameworkRelocationReason.OperationInProgress: return 'operation_in_progress';
+    }
+}
+function terminationReasonMetricName(reason) {
+    switch (reason) {
+        case contracts_1.ZLinkFrameworkTerminationReason.None: return 'none';
+        case contracts_1.ZLinkFrameworkTerminationReason.DeadlineExceeded: return 'deadline_exceeded';
+        case contracts_1.ZLinkFrameworkTerminationReason.TeardownFailed: return 'teardown_failed';
+    }
+}
+function isStreamPayloadCodec(codec) {
+    return typeof codec === 'object'
+        && codec !== null
+        && typeof codec.encode === 'function';
+}
+function selectLocationPlacementDescriptor(descriptors) {
+    const total = descriptors.reduce((sum, descriptor) => sum + BigInt(descriptor.placementWeight), 0n);
+    if (total === 0n)
+        return undefined;
+    let point = randomBigIntBelow(total);
+    for (const descriptor of descriptors) {
+        const weight = BigInt(descriptor.placementWeight);
+        if (point < weight)
+            return descriptor;
+        point -= weight;
+    }
+    return descriptors.at(-1);
+}
+async function selectReadyLocationPlacementDescriptor(descriptors, node, signal, isEligible) {
+    const eligible = descriptors.filter(isEligible);
+    if (eligible.length === 0)
+        return undefined;
+    for (;;) {
+        const localStatus = node?.status();
+        const selected = selectLocationPlacementDescriptor(eligible.filter(descriptor => isPlacementTargetReady(node, localStatus, descriptor)));
+        if (selected !== undefined)
+            return selected;
+        try {
+            await waitForPlacementReadiness(signal);
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+function isPlacementTargetReady(node, localStatus, descriptor) {
+    if (node === undefined)
+        return true;
+    if (localStatus !== undefined
+        && String(localStatus.routingId) === String(descriptor.rid)
+        && localStatus.lifecycleGeneration === descriptor.lifecycleGeneration) {
+        return true;
+    }
+    return node.isPeerRouteReady?.(descriptor.rid, descriptor.lifecycleGeneration) ?? true;
+}
+function waitForPlacementReadiness(signal) {
+    if (signal?.aborted === true)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', abort);
+            resolve();
+        }, 10);
+        const abort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', abort);
+            reject(signal?.reason);
+        };
+        signal?.addEventListener('abort', abort, { once: true });
+    });
+}
+function randomBigIntBelow(exclusiveUpperBound) {
+    if (exclusiveUpperBound <= 0n) {
+        throw new RangeError('Random selection upper bound must be positive.');
+    }
+    const bitLength = exclusiveUpperBound.toString(2).length;
+    const byteLength = Math.ceil(bitLength / 8);
+    const highBitMask = 0xff >> (byteLength * 8 - bitLength);
+    for (;;) {
+        const bytes = (0, node_crypto_1.randomBytes)(byteLength);
+        bytes[0] = bytes[0] & highBitMask;
+        const value = BigInt(`0x${bytes.toString('hex')}`);
+        if (value < exclusiveUpperBound)
+            return value;
+    }
+}
+function relocationReason(reason) {
+    switch (reason) {
+        case 'deadline_exceeded': return contracts_1.ZLinkFrameworkRelocationReason.DeadlineExceeded;
+        case 'store_unavailable': return contracts_1.ZLinkFrameworkRelocationReason.StoreUnavailable;
+        case 'target_unavailable': return contracts_1.ZLinkFrameworkRelocationReason.TargetUnavailable;
+        default: return contracts_1.ZLinkFrameworkRelocationReason.RelocationFailed;
+    }
+}
+function rewriteAuthorityPayloadForOwner(payload, owner) {
+    const applicationPayload = (0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(payload);
+    const rewritten = (0, actors_2.isActorAuthorityPayload)(applicationPayload)
+        ? (0, actors_2.rewriteActorAuthorityOwner)(applicationPayload, owner)
+        : (0, service_authority_payload_codec_1.rewriteServiceAuthorityOwner)(applicationPayload, owner) ?? applicationPayload;
+    return (0, service_relocation_runtime_1.replaceServiceRelocationAuthorityApplicationPayload)(payload, rewritten);
+}
+function validateRelocationOptions(options, sourceApplicationVersion) {
+    if (options === undefined) {
+        throw new TypeError('Relocation mode is required.');
+    }
+    const mode = options.mode;
+    if (mode !== contracts_1.ZLinkFrameworkRelocationMode.PlannedMaintenance
+        && mode !== contracts_1.ZLinkFrameworkRelocationMode.RollingUpdate) {
+        throw new TypeError('Relocation mode is required.');
+    }
+    if (options.mode === contracts_1.ZLinkFrameworkRelocationMode.PlannedMaintenance) {
+        if (options.targetApplicationVersion !== undefined) {
+            throw new TypeError('PlannedMaintenance relocation cannot define targetApplicationVersion.');
+        }
+        return sourceApplicationVersion;
+    }
+    if (typeof options.targetApplicationVersion !== 'bigint'
+        || options.targetApplicationVersion <= sourceApplicationVersion) {
+        throw new TypeError('RollingUpdate relocation requires a targetApplicationVersion greater than the source version.');
+    }
+    return options.targetApplicationVersion;
+}
+function blockedRelocation(mode, effectiveTargetApplicationVersion, reason) {
+    return {
+        mode,
+        effectiveTargetApplicationVersion,
+        outcome: contracts_1.ZLinkFrameworkRelocationOutcome.Blocked,
+        reason
+    };
+}
+function waitForRuntimeOperation(operation, signal) {
+    if (signal === undefined)
+        return operation;
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const aborted = () => reject(signal.reason);
+        signal.addEventListener('abort', aborted, { once: true });
+        operation.then(resolve, reject).finally(() => signal.removeEventListener('abort', aborted));
+    });
+}
+function registeredRuntimeStores(registration) {
+    const stores = [
+        registration.locations.storeInstance,
+        registration.locations.relocationStoreInstance
+    ];
+    return stores.filter((store) => store !== undefined);
+}