@zlink-systems/framework 0.26.0 → 0.28.0

package/src/runtime/host/index.ts

@@ -1,81 +1,98 @@
-import { ZLinkListenerRecords } from '../foundation/listener-records';
-import {
-  ZLinkFrameworkInternalErrorKind,
-  createInternalFrameworkException,
-  internalFrameworkWireReply
-} from '../framework-errors-internal';
+import { listAllMeshNodeDescriptors } from '../locations/location-store-pages';
+import { ZlinkStreamContentType } from '@zlink-systems/stream-wire';
 import { randomBytes, randomUUID } from 'node:crypto';
-import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
-import {
-  RequestResult,
-  SubmitResult,
-  type ZLinkBackendMessageLike as MessageLike
-} from '../backend/runtime-values';
-import {
-  OperationKind,
-  ReceiveKind,
-  type ReadyRecord,
-  type ReceiveRecord
-} from '../foundation/service-runtime-contracts';
-import type { ServiceMessageFollowRecord } from '../foundation/service-stateful-wire-codec';
-import { runtimeAcceptsWork, runtimeStateIsReady } from '../foundation/runtime-state-projections';
-import { createDeadlineExceededError, isDeadlineExceededError } from '../abort';
-import { meshActorSessionNodeAdapter, ZLinkNodeBackendAdapterFactory } from '../backend';
-import type {
-  ZLinkBackendAdapterFactory,
-  ZLinkBackendContext,
-  ZLinkBackendMeshNode
-} from '../backend';
-
-const LEGACY_MESH_SEND_TIMEOUT_MS = 1000;
-import type { ZLinkFrameworkRegistration } from '../configuration';
-import type {
-  ActorRef,
-  RoutingId,
-  ZLinkMeshNodeDescriptor,
-  ZLinkClientServerRuntime,
-  ZLinkFanoutRuntime,
-  ZLinkFrameworkRuntime,
-  ZLinkListenerKind,
-  ZLinkListenerStatus,
-  ZLinkFrameworkLifecycleOptions,
-  ZLinkFrameworkRelocationOptions,
-  ZLinkFrameworkRelocationResult,
-  ZLinkObservedStatus,
-  ZLinkFrameworkRuntimeStatus,
-  ZLinkFrameworkTerminationResult,
-  ZLinkRouteMeshRuntime
-} from '../../contracts';
-import type { ZLinkLocationOwnerToken } from '../../contracts/Locations';
-import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
-import type { Type } from '../../contracts/Common/CoreTypes';
-import type { ZLinkRuntimeEventPublisher } from '../diagnostics';
-import type { ZLinkSpotRouteResolver } from '../spots/spot-routing-internal';
 import {
+  type ActorRef,
+  type RoutingId,
+  type ZLinkClientServerRuntime,
+  type ZLinkFanoutRuntime,
+  type ZLinkFrameworkLifecycleOptions,
+  type ZLinkFrameworkRelocationOptions,
+  type ZLinkFrameworkRelocationResult,
+  type ZLinkFrameworkRuntime,
+  type ZLinkFrameworkRuntimeStatus,
+  type ZLinkFrameworkTerminationResult,
+  type ZLinkListenerKind,
+  type ZLinkListenerStatus,
+  type ZLinkMeshNodeDescriptor,
+  type ZLinkMessageFlowControl,
+  type ZLinkMessageFlowLogMode,
+  type ZLinkObservedStatus,
+  type ZLinkRouteMeshRuntime,
   ZLinkFrameworkRelocationMode,
   ZLinkFrameworkRelocationOutcome,
   ZLinkFrameworkRelocationReason,
   ZLinkFrameworkRuntimeState,
   ZLinkFrameworkTerminationOutcome,
   ZLinkFrameworkTerminationReason,
+  zlinkMessageMetadata,
   ZLinkObjectRole,
   ZLinkPeerState,
-  ZLinkSpotKind,
-  zlinkMessageMetadata,
-  ZLinkSpotCreateState
+  ZLinkSpotCreateState,
+  ZLinkSpotKind
 } from '../../contracts';
-import { ZLinkSubmitStatus } from '../messaging/submission-result';
+import type { Type } from '../../contracts/Common/CoreTypes';
+import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
+import { ZLinkConfigurationException } from '../../contracts/Configuration/ConfigurationException';
+import { requireMessageFlowLogMode } from '../../contracts/Configuration/DiagnosticsValidation';
+import { DEFAULT_ACTIVATION_CONCURRENCY_LIMIT } from '../../contracts/Configuration/InternalDefaults';
+import { DEFAULT_REQUEST_TIMEOUT_MS } from '../../contracts/Configuration/Registration';
 import {
-  ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome,
   ZLinkDispatchErrorSurface,
-  ZLinkDispatchMessageKind
+  ZLinkDispatchMessageKind,
+  ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome
 } from '../../contracts/Dispatch/ZLinkDispatchOptions';
-import type { ZLinkMessageFlowControl, ZLinkMessageFlowLogMode } from '../../contracts';
-import { requireMessageFlowLogMode } from '../../contracts/Configuration/DiagnosticsValidation';
+import {
+  type ZLinkLocationOwnerToken,
+  zlinkDefaultLocationOptions,
+  type ZLinkLocationRuntimeQuery
+} from '../../contracts/Locations';
+import { ZLINK_PROVIDER_MAX_PAGE_SIZE } from '../../contracts/Locations/Stores';
+import { createDeadlineExceededError, isAbortError, isDeadlineExceededError } from '../abort';
+import { ZLinkActivationAdmission } from '../activation-admission';
+import {
+  type DefaultZLinkActorManager,
+  type ZLinkActorManagerOptions,
+  decodeRemoteActorSourceLeaveTerminal,
+  DefaultZLinkActorClient,
+  isActorAuthorityPayload,
+  publishInitialActorAuthority,
+  rewriteActorAuthorityOwner,
+  ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET,
+  ZLinkActorHandoffCoordinator,
+  ZLinkActorTransferRegistry
+} from '../actors';
+import { messageFollowOwnerNodeRid, ownerFence } from '../actors/actor-message-follow-context';
+import {
+  ZLINK_INTERNAL_ACTOR_TRANSPORT_DELIVERY_GATE,
+  type ZLinkInternalActorTransportDeliveryGate
+} from '../actors/actor-transport-delivery-gate';
+import { ZLinkRuntimeAdmissionGate } from '../admission';
+import {
+  ZLINK_INTERNAL_APPLICATION_JOB_QUEUE_HANDLER_START_GATE,
+  type ZLinkInternalApplicationJobQueueHandlerStartGate
+} from '../application-jobs/application-job-queue-handler-start-gate';
+import {
+  releaseApplicationJobPermitBeforeHandler,
+  runWithApplicationJobPermit
+} from '../application-jobs/application-job-queue-scope';
+import {
+  type ZLinkBackendAdapterFactory,
+  type ZLinkBackendContext,
+  type ZLinkBackendMeshNode,
+  meshActorSessionNodeAdapter,
+  ZLinkNodeBackendAdapterFactory
+} from '../backend';
+import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
+import {
+  RequestResult,
+  SubmitResult,
+  type ZLinkBackendMessageLike as MessageLike
+} from '../backend/runtime-values';
 import {
   DefaultZLinkChannelRuntimeOptions,
-  ZLinkDispatchErrorReporter,
   ZLinkChannelRuntimeManager,
+  ZLinkDispatchErrorReporter,
   ZLinkRuntimeRouteTransport,
   type ZLinkDispatchErrorSink
 } from '../channels';
@@ -85,33 +102,72 @@ import {
   encodeChannelErrorReplyParts,
   encodeChannelReplyParts
 } from '../channels/channel-envelope';
-import { ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET } from '../actors';
-import {
-  ZLINK_INTERNAL_ACTOR_TRANSPORT_DELIVERY_GATE,
-  type ZLinkInternalActorTransportDeliveryGate
-} from '../actors/actor-transport-delivery-gate';
-import {
-  ZLINK_INTERNAL_APPLICATION_JOB_QUEUE_HANDLER_START_GATE,
-  type ZLinkInternalApplicationJobQueueHandlerStartGate
-} from '../application-jobs/application-job-queue-handler-start-gate';
-import { ZLinkFrameworkExecutionState, ZLinkRuntimeTaskErrorSink } from '../execution';
+import type { ZLinkFrameworkRegistration } from '../configuration';
 import {
+  type ZLinkRuntimeEventPublisher,
   createDiagnosticsContext,
   createInboundFlow,
   currentOrCreateFlow,
   DefaultZLinkRuntimeEventPublisher,
   flowIfEnabled,
   runWithFlow,
+  ZLinkRuntimeMetrics,
   type ZLinkDiagnosticsContext,
   type ZLinkMessageFlowModeCell,
-  type ZLinkRuntimeMetricMeshSnapshot,
-  ZLinkRuntimeMetrics
+  type ZLinkRuntimeMetricMeshSnapshot
 } from '../diagnostics';
+import { METRIC_NAMES, MILLISECONDS_PER_SECOND } from '../diagnostics/runtime-metrics';
+import { RuntimeEventQueue } from '../diagnostics/runtime-observation-queue';
 import {
   ZLinkClientServerRuntimeProjection,
   ZLinkFanoutRuntimeProjection
 } from '../diagnostics/topology-runtime-projections';
-import { RuntimeEventQueue } from '../diagnostics/runtime-observation-queue';
+import { ZLinkFrameworkExecutionState, ZLinkRuntimeTaskErrorSink } from '../execution';
+import { ZLinkListenerRecords } from '../foundation/listener-records';
+import {
+  runtimeAcceptsWork,
+  runtimeObservationIsTerminal,
+  runtimeStateIsReady
+} from '../foundation/runtime-state-projections';
+import { rewriteServiceAuthorityOwner } from '../foundation/service-authority-payload-codec';
+import { ServiceRelocationAuthorityError } from '../foundation/service-relocation-coordinator';
+import {
+  replaceServiceRelocationAuthorityApplicationPayload,
+  serviceRelocationAuthorityApplicationPayload
+} from '../foundation/service-relocation-runtime';
+import {
+  MeshPeerRuntimeState,
+  OperationKind,
+  ReceiveKind,
+  type ReadyRecord,
+  type ReceiveRecord
+} from '../foundation/service-runtime-contracts';
+import type {
+  ServiceAsyncInstanceActivationAuthority,
+  ServiceInstanceApplicationLifecycle
+} from '../foundation/service-stateful-runtime';
+import type { ServiceMessageFollowRecord } from '../foundation/service-stateful-wire-codec';
+import {
+  createInternalFrameworkException,
+  internalFrameworkWireReply,
+  ZLinkFrameworkInternalErrorKind
+} from '../framework-errors-internal';
+import {
+  ZLinkAuthoritySpotRouteResolver,
+  ZLinkOwnerCleanupError,
+  type ZLinkLocationRuntime,
+  type ZLinkStoreLocationResolvers
+} from '../locations';
+import {
+  decodeFrameworkCreationPayload,
+  encodeFrameworkCreationPayload
+} from '../messaging/creation-payload-codec';
+import {
+  decodeFrameworkPayloadMessage,
+  encodeFrameworkPayloadMessage
+} from '../messaging/payload-codec';
+import { ZLinkSubmitStatus } from '../messaging/submission-result';
+import { decodeRoutingId, encodeRoutingIdStorageHex, routingIdsEqual } from '../routing-id';
 import {
   DefaultZLinkSpotManager,
   ZLinkPublicSpotManager,
@@ -120,85 +176,50 @@ import {
   type ZLinkDetachedTaskRunner,
   type ZLinkSpotManagerOptions
 } from '../spots';
-import type { DefaultZLinkActorManager, ZLinkActorManagerOptions } from '../actors';
-import { messageFollowOwnerNodeRid, ownerFence } from '../actors/actor-message-follow-context';
-import {
-  DefaultZLinkActorClient,
-  ZLinkActorHandoffCoordinator,
-  ZLinkActorTransferRegistry,
-  decodeRemoteActorSourceLeaveTerminal,
-  isActorAuthorityPayload,
-  publishInitialActorAuthority,
-  rewriteActorAuthorityOwner
-} from '../actors';
+import type { ZLinkSpotRouteResolver } from '../spots/spot-routing-internal';
 import {
   DefaultZLinkBoundSessionFactory,
-  type DefaultZLinkBoundSession,
-  type ZLinkStreamPayloadCodec,
   ZLinkStreamBindingRuntime,
-  ZLinkStreamRuntimeManager
+  ZLinkStreamRuntimeManager,
+  type DefaultZLinkBoundSession,
+  type ZLinkStreamPayloadCodec
 } from '../streams';
-import {
-  ZLinkOwnerCleanupError,
-  ZLinkAuthoritySpotRouteResolver,
-  type ZLinkLocationRuntime,
-  type ZLinkStoreLocationResolvers
-} from '../locations';
-import {
-  zlinkDefaultLocationOptions,
-  type ZLinkLocationRuntimeQuery
-} from '../../contracts/Locations';
+import { ZLinkActorPlacementCoordinator } from './actor-placement-coordinator';
 import { ZLinkActorRuntimeOptionsFactory } from './actor-runtime-options-factory';
-import { ZLinkActorTransferRuntime } from './actor-transfer-runtime';
 import { ZLinkActorTransferAuthorityRuntime } from './actor-transfer-authority-runtime';
-import { ZLinkEntryActorRuntimeService } from './entry-actor-runtime';
-import { ZLinkLocationRuntimeOwner } from './location-runtime-owner';
-import { MeshRouterResolver } from './mesh-router-resolver';
-import { ZLinkBoundSessionRelay } from './bound-session-relay';
-import { decodeRoutingId, encodeRoutingIdStorageHex, routingIdsEqual } from '../routing-id';
-import { rewriteServiceAuthorityOwner } from '../foundation/service-authority-payload-codec';
+import { ZLinkActorTransferRuntime } from './actor-transfer-runtime';
 import {
-  replaceServiceRelocationAuthorityApplicationPayload,
-  serviceRelocationAuthorityApplicationPayload
-} from '../foundation/service-relocation-runtime';
-import { ZLinkSpotRuntimeOptionsFactory } from './spot-runtime-options-factory';
+  ApplicationJobQueue,
+  nodeEffectiveProcessorCount,
+  resolveApplicationJobQueueConfiguration
+} from './application-job-queue';
+import { ZLinkBoundSessionRelay } from './bound-session-relay';
 import { ZLinkChannelRuntimeOptionsFactory } from './channel-runtime-options-factory';
-import { ZLinkSpotNodeRuntimeOptionsFactory } from './spot-node-runtime-options-factory';
-import { rollbackRuntimeStart, stopRuntimeParts } from './runtime-shutdown';
-import { ZLinkRuntimeAdmissionGate } from '../admission';
-import { ZLinkActivationAdmission } from '../activation-admission';
-import { ZLinkRetiringRollbackError, ZLinkRouteMeshRuntimeCoordinator } from './route-mesh-runtime';
-import { ServiceRelocationAuthorityError } from '../foundation/service-relocation-coordinator';
-import { ZLinkConfigurationException } from '../../contracts/Configuration/ConfigurationException';
-import { ZLinkStatefulAuthorityRouteRuntime } from './stateful-authority-route-runtime';
+import { ZLinkEntryActorRuntimeService } from './entry-actor-runtime';
+import { HostCapacityStatusProjection } from './host-capacity-status';
 import { ZLinkInstanceActivationAuthority } from './instance-activation-authority';
-import type {
-  ServiceAsyncInstanceActivationAuthority,
-  ServiceInstanceApplicationLifecycle
-} from '../foundation/service-stateful-runtime';
-import { hasObjectClientCapability, ZLinkHostSpotAddressTransport } from './spot-address-transport';
-import { ZLinkUserSpotCreationCoordinator } from './user-spot-creation-coordinator';
-import { ZLinkActorPlacementCoordinator } from './actor-placement-coordinator';
-import {
-  decodeFrameworkPayloadMessage,
-  encodeFrameworkPayloadMessage
-} from '../messaging/payload-codec';
+import { ZLinkLocationRuntimeOwner } from './location-runtime-owner';
+import { MeshRouterResolver } from './mesh-router-resolver';
 import {
-  decodeFrameworkCreationPayload,
-  encodeFrameworkCreationPayload
-} from '../messaging/creation-payload-codec';
+  ZLinkDrainingStatePublishError,
+  ZLinkRetiringRollbackError,
+  ZLinkRouteMeshRuntimeCoordinator
+} from './route-mesh-runtime';
 import { DefaultZLinkRouteMeshRuntimeOptions } from './route-mesh-runtime-options';
+import { rollbackRuntimeStart, stopRuntimeParts } from './runtime-shutdown';
 import {
   ZLinkHostServiceRelocationRuntime,
   ZLinkRelocationStateIncompatibleError
 } from './service-relocation-host-runtime';
-import {
-  ApplicationJobQueue,
-  nodeEffectiveProcessorCount,
-  resolveApplicationJobQueueConfiguration
-} from './application-job-queue';
-import { runWithApplicationJobPermit } from '../application-jobs/application-job-queue-scope';
-import { HostCapacityStatusProjection } from './host-capacity-status';
+import { hasObjectClientCapability, ZLinkHostSpotAddressTransport } from './spot-address-transport';
+import { ZLinkSpotNodeRuntimeOptionsFactory } from './spot-node-runtime-options-factory';
+import { ZLinkSpotRuntimeOptionsFactory } from './spot-runtime-options-factory';
+import { ZLinkStatefulAuthorityRouteRuntime } from './stateful-authority-route-runtime';
+import { ZLinkUserSpotCreationCoordinator } from './user-spot-creation-coordinator';
+
+const HOST_SHUTDOWN_POLL_INTERVAL_MS = 100;
+const HANDOFF_ACCEPTANCE_POLL_INTERVAL_MS = 10;
+const DEFAULT_HOST_CONTROL_TIMEOUT_MS = 30_000;
 
 export interface ZLinkFrameworkRuntimeLifecycle {
   readonly isStarted: boolean;
@@ -224,6 +245,7 @@ export class ZLinkFrameworkRuntimeHost
   private runtimeSequence = 0n;
   private readonly runtimeObservationSource = Symbol('zlink.framework-runtime');
   private runtimeDeadline?: Date;
+  private shutdownDeadline?: AbortController;
   private runtimeRelocationResult?: ZLinkFrameworkRelocationResult;
   private runtimeTerminationResult?: ZLinkFrameworkTerminationResult;
   private relocationOperation?: Promise<ZLinkFrameworkRelocationResult>;
@@ -264,16 +286,8 @@ export class ZLinkFrameworkRuntimeHost
   private readonly admission = new ZLinkRuntimeAdmissionGate(() => this.ownerAdmissionOpen());
   private readonly activationAdmission = new ZLinkActivationAdmission(
     (meshName) =>
-      this.options.registration.spotNodes.get(meshName)?.activationConcurrencyLimit ?? 128,
-    (meshName) => {
-      void this.spotNodeRuntime
-        ?.publishMeshNodeState(
-          this.runtimeState,
-          this.executionState?.abortController.signal,
-          meshName
-        )
-        .catch(() => undefined);
-    }
+      this.options.registration.spotNodes.get(meshName)?.activationConcurrencyLimit ??
+      DEFAULT_ACTIVATION_CONCURRENCY_LIMIT
   );
   private cachedLocationSpotRouteResolver?: ZLinkSpotRouteResolver;
   private actorClientLocationResolver?: ZLinkStoreLocationResolvers;
@@ -351,25 +365,6 @@ export class ZLinkFrameworkRuntimeHost
     );
     this.meshRouters = new MeshRouterResolver(options.registration);
     this.spotRouterChannelIdForMesh = this.meshRouters.spotRouterChannelIdByMesh();
-    const sendTimeoutMsForSpotMesh = (meshName: string): number =>
-      options.registration.spotNodes.get(meshName)?.router?.sendTimeoutMs ??
-      LEGACY_MESH_SEND_TIMEOUT_MS;
-    const sendTimeoutMsForSpotRouteChannel = (routeChannelId: string): number => {
-      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 ZLinkRuntimeRouteTransport(
       () => this.channelRuntime,
       (routerChannelId) => this.meshRouters.canUseRouterChannel(routerChannelId),
@@ -379,7 +374,8 @@ export class ZLinkFrameworkRuntimeHost
         this.meshRouters.classifyManualNodeTarget(meshName, targetNodeRid),
       (meshName, sourceNodeRid, parts) => this.submitLocalMeshRoute(meshName, sourceNodeRid, parts),
       this.metrics,
-      () => this.flowCreationEnabled()
+      () => this.flowCreationEnabled(),
+      () => this.createDispatchErrorReporter(this.runtimeOrPreStartErrorSink).flow
     );
     this.spotAddressTransport = new ZLinkHostSpotAddressTransport({
       resolver: () => this.createLocationSpotRouteResolver(),
@@ -392,10 +388,7 @@ export class ZLinkFrameworkRuntimeHost
       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,
+      defaultRequestTimeoutMs: options.registration.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
       dispatchErrors: this.createDispatchErrorReporter(this.runtimeOrPreStartErrorSink)
     });
     this.locationOwner = new ZLinkLocationRuntimeOwner({
@@ -406,6 +399,7 @@ export class ZLinkFrameworkRuntimeHost
       rewriteAuthorityPayloadForOwner
     });
     this.streamBindingRuntime = new ZLinkStreamBindingRuntime({
+      dispatchErrors: this.createDispatchErrorReporter(this.runtimeOrPreStartErrorSink),
       streamPayloadCodec: resolveStreamPayloadCodec(options.registration),
       streamCompression: options.registration.streamCompression,
       messageSerializers: options.registration.messageSerializers,
@@ -445,8 +439,8 @@ export class ZLinkFrameworkRuntimeHost
               options
             );
       },
-      relay: (actor, header, payload, signal) =>
-        this.boundSessionRelay.actorPackets.relayActorPacket(actor, header, payload, signal),
+      relay: (actor, header, payload) =>
+        this.boundSessionRelay.actorPackets.relayActorPacket(actor, header, payload),
       notifyDisconnected: (actor, signal) =>
         this.boundSessionRelay.actorPackets.notifyBoundActorDisconnected(actor, signal)
     });
@@ -784,6 +778,7 @@ export class ZLinkFrameworkRuntimeHost
     });
     this.serviceRelocation = new ZLinkHostServiceRelocationRuntime({
       registration: options.registration,
+      targetAdmissionSealed: () => this.shutdownOperationStartedAt !== undefined,
       providerResolver: options.providerResolver,
       locationStore: () => this.locationOwner.currentStores?.locationStore,
       currentOwner: () => this.locationOwner.currentRuntime?.currentOwnerToken,
@@ -870,7 +865,7 @@ export class ZLinkFrameworkRuntimeHost
   }
 
   get isStarted(): boolean {
-    return this.executionState !== undefined;
+    return this.executionState !== undefined && !this.executionState.abortController.signal.aborted;
   }
 
   get status(): ZLinkFrameworkRuntimeStatus {
@@ -905,6 +900,7 @@ export class ZLinkFrameworkRuntimeHost
     const queue = new RuntimeEventQueue<ZLinkFrameworkRuntimeStatus>(undefined, signal);
     this.runtimeObservers.add(queue);
     queue.onClose(() => this.runtimeObservers.delete(queue));
+    this.publishRuntimeStatus(queue, this.status);
     return queue;
   }
 
@@ -921,7 +917,7 @@ export class ZLinkFrameworkRuntimeHost
       options,
       this.options.registration.applicationVersion
     );
-    const deadlineMs = options.deadlineMs ?? 30_000;
+    const deadlineMs = options.deadlineMs ?? DEFAULT_HOST_CONTROL_TIMEOUT_MS;
     if (!Number.isFinite(deadlineMs) || deadlineMs <= 0) {
       return Promise.reject(new RangeError('Relocation deadlineMs must be greater than zero.'));
     }
@@ -990,7 +986,7 @@ export class ZLinkFrameworkRuntimeHost
   }
 
   shutdown(options?: ZLinkFrameworkLifecycleOptions): Promise<ZLinkFrameworkTerminationResult> {
-    const deadlineMs = options?.deadlineMs ?? 30_000;
+    const deadlineMs = options?.deadlineMs ?? DEFAULT_HOST_CONTROL_TIMEOUT_MS;
     if (!Number.isFinite(deadlineMs) || deadlineMs <= 0) {
       return Promise.reject(new RangeError('Shutdown deadlineMs must be greater than zero.'));
     }
@@ -1103,52 +1099,78 @@ export class ZLinkFrameworkRuntimeHost
   }
 
   private async runShutdown(deadlineMs: number): Promise<ZLinkFrameworkTerminationResult> {
-    const deadlineAtMs = performance.now() + deadlineMs;
-    try {
-      this.admission.close();
-      this.setRuntimeState(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 await this.runWithShutdownDeadline(deadlineMs, async () => {
+      const deadlineAtMs = performance.now() + deadlineMs;
+      try {
+        this.admission.close();
+        if (this.runtimeState === ZLinkFrameworkRuntimeState.Preparing) {
+          this.executionState?.abortController.abort();
+        }
+        this.setRuntimeState(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!,
+          this.shutdownDeadline!.signal
+        );
+        const drain = await shutdown;
+        await unscopedStreamDrain;
+        await this.stop();
+        if (drain.kind === 'forceStopped') {
+          return this.completeTermination({
+            outcome: ZLinkFrameworkTerminationOutcome.ForceStopped,
+            reason:
+              drain.reason === 'deadline_exceeded'
+                ? ZLinkFrameworkTerminationReason.DeadlineExceeded
+                : ZLinkFrameworkTerminationReason.TeardownFailed
+          });
+        }
+        if (performance.now() >= deadlineAtMs) {
+          throw createDeadlineExceededError('Shutdown resource cleanup exceeded its deadline.');
+        }
+        return this.completeTermination({
+          outcome: ZLinkFrameworkTerminationOutcome.Stopped,
+          reason: ZLinkFrameworkTerminationReason.None
+        });
+      } catch (error) {
+        await this.stop().catch(() => undefined);
         return this.completeTermination({
           outcome: ZLinkFrameworkTerminationOutcome.ForceStopped,
-          reason:
-            drain.reason === 'deadline_exceeded'
-              ? ZLinkFrameworkTerminationReason.DeadlineExceeded
-              : ZLinkFrameworkTerminationReason.TeardownFailed
+          reason: isDeadlineExceededError(error)
+            ? ZLinkFrameworkTerminationReason.DeadlineExceeded
+            : ZLinkFrameworkTerminationReason.TeardownFailed
         });
       }
-      if (performance.now() >= deadlineAtMs) {
-        throw createDeadlineExceededError('Shutdown resource cleanup exceeded its deadline.');
-      }
-      return this.completeTermination({
-        outcome: ZLinkFrameworkTerminationOutcome.Stopped,
-        reason: ZLinkFrameworkTerminationReason.None
-      });
-    } catch (error) {
-      await this.stop().catch(() => undefined);
-      return this.completeTermination({
-        outcome: ZLinkFrameworkTerminationOutcome.ForceStopped,
-        reason: isDeadlineExceededError(error)
-          ? ZLinkFrameworkTerminationReason.DeadlineExceeded
-          : ZLinkFrameworkTerminationReason.TeardownFailed
-      });
+    });
+  }
+
+  private async runWithShutdownDeadline<T>(
+    deadlineMs: number,
+    operation: () => Promise<T>
+  ): Promise<T> {
+    if (this.shutdownDeadline !== undefined) return await operation();
+    const deadline = new AbortController();
+    this.shutdownDeadline = deadline;
+    const ownsRuntimeDeadline = this.runtimeDeadline === undefined;
+    this.runtimeDeadline ??= new Date(Date.now() + deadlineMs);
+    const timer = setTimeout(
+      () => deadline.abort(createDeadlineExceededError('Shutdown deadline exceeded.')),
+      Math.max(0, this.runtimeDeadline.getTime() - Date.now())
+    );
+    try {
+      return await operation();
+    } finally {
+      clearTimeout(timer);
+      this.shutdownDeadline = undefined;
+      if (ownsRuntimeDeadline) this.runtimeDeadline = undefined;
     }
   }
 
@@ -1185,8 +1207,9 @@ export class ZLinkFrameworkRuntimeHost
   private recordRelocationResult(result: ZLinkFrameworkRelocationResult): void {
     if (this.relocationOperationStartedAt !== undefined) {
       this.metrics.duration(
-        'zlink.host.relocation.duration',
-        Math.max(0, performance.now() - this.relocationOperationStartedAt) / 1000,
+        METRIC_NAMES.HostRelocationDuration,
+        Math.max(0, performance.now() - this.relocationOperationStartedAt) /
+          MILLISECONDS_PER_SECOND,
         {
           mode: relocationModeMetricName(result.mode),
           outcome:
@@ -1195,7 +1218,7 @@ export class ZLinkFrameworkRuntimeHost
       );
     }
     if (result.outcome === ZLinkFrameworkRelocationOutcome.Blocked) {
-      this.metrics.count('zlink.host.relocation.blocked', 1, {
+      this.metrics.count(METRIC_NAMES.HostRelocationBlocked, 1, {
         mode: relocationModeMetricName(result.mode),
         reason: relocationReasonMetricName(result.reason)
       });
@@ -1218,8 +1241,8 @@ export class ZLinkFrameworkRuntimeHost
     this.runtimeDeadline = undefined;
     if (this.shutdownOperationStartedAt !== undefined) {
       this.metrics.duration(
-        'zlink.host.shutdown.duration',
-        Math.max(0, performance.now() - this.shutdownOperationStartedAt) / 1000,
+        METRIC_NAMES.HostShutdownDuration,
+        Math.max(0, performance.now() - this.shutdownOperationStartedAt) / MILLISECONDS_PER_SECOND,
         {
           outcome:
             result.outcome === ZLinkFrameworkTerminationOutcome.Stopped
@@ -1229,7 +1252,7 @@ export class ZLinkFrameworkRuntimeHost
       );
     }
     if (result.outcome === ZLinkFrameworkTerminationOutcome.ForceStopped) {
-      this.metrics.count('zlink.host.shutdown.forced', 1, {
+      this.metrics.count(METRIC_NAMES.HostShutdownForced, 1, {
         reason: terminationReasonMetricName(result.reason)
       });
     }
@@ -1251,14 +1274,18 @@ export class ZLinkFrameworkRuntimeHost
     this.notifyTopologyHostStateChanged();
     const status = this.status;
     for (const observer of this.runtimeObservers) {
-      if (state === ZLinkFrameworkRuntimeState.Stopped) {
-        observer.seal(status, this.runtimeObservationSource);
-      } else {
-        observer.push(status, this.runtimeObservationSource);
-      }
+      this.publishRuntimeStatus(observer, status);
     }
-    if (state === ZLinkFrameworkRuntimeState.Stopped) {
-      this.runtimeObservers.clear();
+  }
+
+  private publishRuntimeStatus(
+    observer: RuntimeEventQueue<ZLinkFrameworkRuntimeStatus>,
+    status: ZLinkFrameworkRuntimeStatus
+  ): void {
+    if (runtimeObservationIsTerminal(status.state)) {
+      observer.complete(status, this.runtimeObservationSource);
+    } else {
+      observer.push(status, this.runtimeObservationSource);
     }
   }
 
@@ -1410,7 +1437,9 @@ export class ZLinkFrameworkRuntimeHost
       const locationRuntime = await this.locationOwner.startForRuntime(
         this.meshRouters.primaryMeshName(),
         spotNodeRuntime,
-        channelRuntime
+        channelRuntime,
+        this.executionState.abortController.signal,
+        () => this.shutdownDeadline!.signal
       );
       startedLocationRuntime = locationRuntime;
       if (locationRuntime !== undefined) {
@@ -1462,15 +1491,27 @@ export class ZLinkFrameworkRuntimeHost
       this.setRuntimeState(ZLinkFrameworkRuntimeState.Serving);
       this.lifecycleSink?.push('framework:started');
     } catch (error) {
+      if (this.shutdownDeadline !== undefined && isAbortError(error)) throw error;
       await statefulAuthorityRoutes?.stop();
-      await rollbackRuntimeStart({
-        context,
-        startedLocationRuntime,
-        streamRuntime,
-        spotNodeRuntime,
-        channelRuntime,
-        ownedStores: registeredRuntimeStores(this.options.registration)
-      });
+      try {
+        await this.runWithShutdownDeadline(DEFAULT_HOST_CONTROL_TIMEOUT_MS, async () =>
+          rollbackRuntimeStart({
+            context,
+            startedLocationRuntime: startedLocationRuntime ?? this.locationOwner.currentRuntime,
+            shutdownSignal: this.shutdownDeadline!.signal,
+            streamRuntime,
+            spotNodeRuntime,
+            channelRuntime,
+            ownedStores: registeredRuntimeStores(this.options.registration)
+          })
+        );
+      } catch (cleanupError) {
+        this.runtimeOrPreStartErrorSink.reportRuntimeTaskException(
+          'framework start rollback',
+          cleanupError
+        );
+        throw new AggregateError([error, cleanupError], 'Framework start and rollback failed.');
+      }
       this.executionState = undefined;
       this.channelRuntime = undefined;
       this.spotNodeRuntime = undefined;
@@ -1484,7 +1525,9 @@ export class ZLinkFrameworkRuntimeHost
   }
 
   async stop(): Promise<void> {
-    await this.runLifecycle(() => this.stopCore());
+    await this.runWithShutdownDeadline(DEFAULT_HOST_CONTROL_TIMEOUT_MS, async () =>
+      this.runLifecycle(() => this.stopCore())
+    );
   }
 
   private runtimeMetricMeshSnapshots(): readonly ZLinkRuntimeMetricMeshSnapshot[] {
@@ -1537,6 +1580,7 @@ export class ZLinkFrameworkRuntimeHost
     if (state === undefined) {
       return;
     }
+    state.abortController.abort();
 
     const channelRuntime = this.channelRuntime;
     const spotNodeRuntime = this.spotNodeRuntime;
@@ -1545,24 +1589,25 @@ export class ZLinkFrameworkRuntimeHost
     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 stopRuntimeParts({
       state,
       locationSnapshot,
       cleanupDeadline: this.runtimeDeadline,
+      shutdownSignal: this.shutdownDeadline!.signal,
       streamRuntime,
       spotNodeRuntime,
       channelRuntime,
       serviceRelocation: this.serviceRelocation,
       ownedStores: registeredRuntimeStores(this.options.registration)
     });
+    this.executionState = undefined;
+    this.channelRuntime = undefined;
+    this.spotNodeRuntime = undefined;
+    this.streamRuntime = undefined;
+    this.statefulAuthorityRoutes = undefined;
+    this.cachedLocationSpotRouteResolver = undefined;
     this.listenerRecords.clear();
     this.lifecycleSink?.push('framework:stopped');
     if (this.shutdownOperation === undefined) {
@@ -1628,7 +1673,7 @@ export class ZLinkFrameworkRuntimeHost
       pollingIntervalMs:
         this.options.registration.locations.options.pollingIntervalMs ??
         zlinkDefaultLocationOptions.pollingIntervalMs,
-      pageSize: 1000,
+      pageSize: ZLINK_PROVIDER_MAX_PAGE_SIZE,
       reportError: (error) =>
         this.runtimeOrPreStartErrorSink.reportRuntimeTaskException(
           'stateful authority route reconciliation',
@@ -1657,11 +1702,6 @@ export class ZLinkFrameworkRuntimeHost
   ): void {
     for (const [meshName, node] of spotNodeRuntime.meshNodesByName) {
       const activationNode = node as typeof node & {
-        setSpotAdmissionProvider?: (provider: {
-          isClosing(spotId: string): boolean;
-          awaitCloseDecision(spotId: string): Promise<void> | undefined;
-          runtimeState(): ZLinkFrameworkRuntimeState;
-        }) => void;
         registerAsyncInstanceActivationAuthority?: (
           authority: ServiceAsyncInstanceActivationAuthority
         ) => void;
@@ -1677,11 +1717,6 @@ export class ZLinkFrameworkRuntimeHost
       };
       const spotManager = this.spotManager;
       if (spotManager !== undefined) {
-        activationNode.setSpotAdmissionProvider?.({
-          isClosing: (spotId) => spotManager.isSpotClosing(meshName, spotId),
-          awaitCloseDecision: (spotId) => spotManager.pendingSpotCloseDecision(meshName, spotId),
-          runtimeState: () => this.runtimeState
-        });
         this.registerInstanceApplicationLifecycle(meshName, activationNode, spotManager);
       }
       activationNode.registerAsyncInstanceActivationAuthority?.(
@@ -1893,6 +1928,7 @@ export class ZLinkFrameworkRuntimeHost
     } catch (error) {
       throw new ZLinkDrainingStatePublishError(error);
     }
+    await awaitWithDrainSignal(this.serviceRelocation.drainTargetAttempts(), signal);
   }
 
   private async cleanupOwnerForDrain(signal: AbortSignal): Promise<void> {
@@ -1929,7 +1965,6 @@ export class ZLinkFrameworkRuntimeHost
         ),
       isMaterializing: (target) =>
         spotManager.isInstanceMaterializing(meshName, target.targetSpotId as never),
-      isClosing: (target) => spotManager.isInstanceClosing(meshName, target.targetSpotId as never),
       isIdleEvicting: (target) =>
         spotManager.isInstanceSpotIdleEvicting(meshName, target.targetSpotId as never),
       beginIdleEviction: (target) =>
@@ -1965,19 +2000,6 @@ export class ZLinkFrameworkRuntimeHost
   setSpotManager(spotManager: DefaultZLinkSpotManager): void {
     this.spotManager = spotManager;
     for (const [meshName, node] of this.spotNodeRuntime?.meshNodesByName ?? []) {
-      const admissionNode = node as typeof node & {
-        setSpotAdmissionProvider?: (provider: {
-          isClosing(spotId: string): boolean;
-          awaitCloseDecision(spotId: string): Promise<void> | undefined;
-          runtimeState(): ZLinkFrameworkRuntimeState;
-        }) => void;
-      };
-      admissionNode.setSpotAdmissionProvider?.({
-        isClosing: (spotId: string) => spotManager.isSpotClosing(meshName, spotId),
-        awaitCloseDecision: (spotId: string) =>
-          spotManager.pendingSpotCloseDecision(meshName, spotId),
-        runtimeState: () => this.runtimeState
-      });
       this.registerInstanceApplicationLifecycle(meshName, node, spotManager);
     }
   }
@@ -2099,7 +2121,10 @@ export class ZLinkFrameworkRuntimeHost
         detachedTaskRunner: this.detachedTaskRunner(),
         metrics: this.metrics,
         admission: this.admission,
-        statefulExecutionAllowed: () => this.ownerAdmissionOpen()
+        statefulExecution: {
+          admissionOpen: () => this.ownerAdmissionOpen(),
+          hostState: () => this.runtimeState
+        }
       }).create(this.actorTransferRuntime),
       activationAdmission: this.activationAdmission
     };
@@ -2160,7 +2185,7 @@ export class ZLinkFrameworkRuntimeHost
           );
         }
         const meshNode = this.spotNodeRuntime?.meshNode(meshName);
-        const descriptors = (await locationStore.listMeshNodes(meshName, undefined, signal)).items;
+        const descriptors = await listAllMeshNodeDescriptors(locationStore, meshName, signal);
         const selected = await selectReadyLocationPlacementDescriptor(
           descriptors,
           meshNode,
@@ -2270,7 +2295,7 @@ export class ZLinkFrameworkRuntimeHost
           );
         }
         const meshNode = this.spotNodeRuntime?.meshNode(meshName);
-        const descriptors = (await locationStore.listMeshNodes(meshName, undefined, signal)).items;
+        const descriptors = await listAllMeshNodeDescriptors(locationStore, meshName, signal);
         const selected = await selectReadyLocationPlacementDescriptor(
           descriptors,
           meshNode,
@@ -2381,7 +2406,7 @@ export class ZLinkFrameworkRuntimeHost
               try {
                 payload = {
                   packetName: 'ZLinkFrameworkUserSpotReply',
-                  contentType: 'application/octet-stream',
+                  contentType: ZlinkStreamContentType.Raw,
                   payload: Buffer.from(message.data())
                 };
               } finally {
@@ -2560,7 +2585,7 @@ export class ZLinkFrameworkRuntimeHost
         }
         return node.requestUserSpotClose(targetNodeRid, request, timeoutMs);
       },
-      defaultTimeoutMs: this.options.registration.requestTimeoutMs ?? 30_000,
+      defaultTimeoutMs: this.options.registration.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
       messageSerializers: this.options.registration.messageSerializers
     });
   }
@@ -2582,6 +2607,10 @@ export class ZLinkFrameworkRuntimeHost
       notifyEntrySpotActorCreated: (nodeRid, actor, createRequest, signal) =>
         this.spotNodeRuntime?.notifyEntrySpotActorCreated(nodeRid, actor, createRequest, signal) ??
         Promise.resolve(undefined),
+      notifyEntrySpotActorJoined: (actor, signal) =>
+        this.spotNodeRuntime?.notifyPrimaryEntrySpotActorJoined(actor, signal) ?? Promise.resolve(),
+      notifyEntrySpotActorLeft: (actor, signal) =>
+        this.spotNodeRuntime?.notifyPrimaryEntrySpotActorLeft(actor, signal) ?? Promise.resolve(),
       locationLifecycle: () => this.locationOwner.currentLifecycle,
       primaryMeshName: () => this.meshRouters.primaryMeshName(),
       actorMeshName: (actorType) => this.meshRouters.actorMeshName(actorType),
@@ -2699,6 +2728,7 @@ export class ZLinkFrameworkRuntimeHost
     }).create();
     return {
       ...options,
+      errorSink: this.runtimeOrPreStartErrorSink,
       peerAdmissionSealed: (meshName: string) => !this.admission.accepts(meshName),
       messageFollowReceiver: (record: ServiceMessageFollowRecord) => {
         if (record.source.kind === 'actor') {
@@ -2753,14 +2783,8 @@ export class ZLinkFrameworkRuntimeHost
         );
       }
       const binding = record.kindData;
-      const replyBindingFailure = (
-        kind: ZLinkFrameworkInternalErrorKind,
-        message: string
-      ): void => {
-        const terminal =
-          kind === ZLinkFrameworkInternalErrorKind.ActorGenerationStale
-            ? { terminalResult: RequestResult.InvalidState, failureCode: 0 }
-            : internalFrameworkWireReply(createInternalFrameworkException(kind, message));
+      const replyBindingFailure = (kind: ZLinkFrameworkInternalErrorKind): void => {
+        const terminal = internalFrameworkWireReply(kind);
         if (
           record.replyFailure?.(terminal.terminalResult, terminal.failureCode) !== SubmitResult.Ok
         ) {
@@ -2784,17 +2808,11 @@ export class ZLinkFrameworkRuntimeHost
         nativeActorRef.actorId !== binding.actor.actorId ||
         !routingIdsEqual(nativeActorRef.nodeRid, binding.actor.nodeRid)
       ) {
-        replyBindingFailure(
-          ZLinkFrameworkInternalErrorKind.ActorLocationStale,
-          `Actor '${binding.actor.actorId}' binding target is no longer current.`
-        );
+        replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
         return;
       }
       if (nativeActorRef.generation !== binding.actor.generation) {
-        replyBindingFailure(
-          ZLinkFrameworkInternalErrorKind.ActorGenerationStale,
-          `Actor '${binding.actor.actorId}' binding object generation is stale.`
-        );
+        replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorGenerationStale);
         return;
       }
       const node =
@@ -2809,10 +2827,7 @@ export class ZLinkFrameworkRuntimeHost
         state.locationGeneration !== binding.authorityOwnerGeneration ||
         state.isMoving
       ) {
-        replyBindingFailure(
-          ZLinkFrameworkInternalErrorKind.ActorLocationStale,
-          `Actor '${binding.actor.actorId}' binding authority fence is stale.`
-        );
+        replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
         return;
       }
       const sessionOwnerIsLocal =
@@ -2826,6 +2841,7 @@ export class ZLinkFrameworkRuntimeHost
           nodeRid: binding.actor.nodeRid
         };
         if (sessionOwnerIsLocal) {
+          releaseApplicationJobPermitBeforeHandler();
           await this.streamBindingRuntime.retireRemoteBinding(
             actorRef,
             binding.sessionRid,
@@ -2842,10 +2858,7 @@ export class ZLinkFrameworkRuntimeHost
         binding.sessionRid
       );
       if (target === undefined) {
-        replyBindingFailure(
-          ZLinkFrameworkInternalErrorKind.ActorLocationStale,
-          `Actor '${binding.actor.actorId}' Session route is unavailable.`
-        );
+        replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
         return;
       }
       const installed = state.installBoundSessionBinding({
@@ -2858,10 +2871,7 @@ export class ZLinkFrameworkRuntimeHost
         bindingGeneration: binding.bindingGeneration
       });
       if (!installed) {
-        replyBindingFailure(
-          ZLinkFrameworkInternalErrorKind.ActorLocationStale,
-          `Actor '${binding.actor.actorId}' Session binding generation is stale.`
-        );
+        replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
         return;
       }
       replyBindingSuccess();
@@ -3082,7 +3092,7 @@ export class ZLinkFrameworkRuntimeHost
     return reporter;
   }
 
-  private detachedTaskRunner(): ZLinkDetachedTaskRunner {
+  detachedTaskRunner(): ZLinkDetachedTaskRunner {
     return {
       runDetached: (taskName, callback) => {
         const runner = this.executionState?.taskRunner;
@@ -3158,8 +3168,8 @@ export class ZLinkFrameworkRuntimeHost
             undefined,
             async (meshName, nodeRid, expectedLifecycleGeneration, signal) => {
               const descriptor = (
-                await authority.listMeshNodes(meshName, undefined, signal)
-              ).items.find(
+                await listAllMeshNodeDescriptors(authority, meshName, signal)
+              ).find(
                 (candidate) =>
                   routingIdsEqual(candidate.rid, nodeRid) &&
                   candidate.lifecycleGeneration === expectedLifecycleGeneration
@@ -3256,7 +3266,7 @@ export function hasExactPeerReadiness(
           peer.routingId !== null &&
           String(peer.routingId) === String(descriptor.rid) &&
           peer.lifecycleGeneration === descriptor.lifecycleGeneration &&
-          peer.state === 3
+          peer.state === MeshPeerRuntimeState.Serving
       )
     )
   );
@@ -3266,7 +3276,11 @@ export {
   ZLinkActorTransferAuthorityRuntime,
   transferIdString
 } from './actor-transfer-authority-runtime';
-export { ZLinkRetiringRollbackError, ZLinkRouteMeshRuntimeCoordinator } from './route-mesh-runtime';
+export {
+  ZLinkDrainingStatePublishError,
+  ZLinkRetiringRollbackError,
+  ZLinkRouteMeshRuntimeCoordinator
+} from './route-mesh-runtime';
 export { ZLinkRelocationStateIncompatibleError } from './service-relocation-host-runtime';
 export {
   ZLinkHostSpotAddressTransport,
@@ -3285,7 +3299,7 @@ async function waitForForcedSessionNotification(
   if (operation === undefined) return;
   let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
   const timeout = new Promise<void>((resolve) => {
-    timeoutHandle = setTimeout(resolve, 100);
+    timeoutHandle = setTimeout(resolve, HOST_SHUTDOWN_POLL_INTERVAL_MS);
   });
   try {
     await Promise.race([operation.catch(() => undefined), timeout]);
@@ -3318,13 +3332,6 @@ async function awaitWithDrainSignal(
   });
 }
 
-class ZLinkDrainingStatePublishError extends Error {
-  constructor(cause: unknown) {
-    super('Failed to publish draining peer rows.', { cause });
-    this.name = 'ZLinkDrainingStatePublishError';
-  }
-}
-
 function resolveBackendAdapterFactory(internalOptions: unknown): ZLinkBackendAdapterFactory {
   if (
     typeof internalOptions === 'object' &&
@@ -3483,7 +3490,7 @@ function waitForPlacementReadiness(signal?: AbortSignal): Promise<void> {
     const timer = setTimeout(() => {
       signal?.removeEventListener('abort', abort);
       resolve();
-    }, 10);
+    }, HANDOFF_ACCEPTANCE_POLL_INTERVAL_MS);
     const abort = () => {
       clearTimeout(timer);
       signal?.removeEventListener('abort', abort);