@zlink-systems/framework 0.30.3 → 0.32.0

package/src/runtime/diagnostics/message-flow.ts

@@ -1,23 +1,22 @@
-import { trace as openTelemetryTrace, SpanStatusCode, type Attributes } from '@opentelemetry/api';
-import { logs as openTelemetryLogs, SeverityNumber } from '@opentelemetry/api-logs';
+import type { ZLinkFlowOrigin } from '../../contracts/Dispatch/ZLinkFlowOrigin';
 import {
   MESSAGE_FLOW_MODE_RANK,
   type ZLinkDiagnosticsOptions,
-  type ZLinkFlowOrigin,
-  type ZLinkMessageFlowLogMode
-} from '../../contracts';
-import {
+  type ZLinkMessageFlowLogMode,
   ZLinkDispatchErrorSurface,
   ZLinkDispatchMessageKind,
   ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome,
-  type ZLinkRuntimeMessageFlowEvent,
   type ZLinkRuntimeMessageFlowResult
 } from '../../contracts/Dispatch/ZLinkDispatchOptions';
-import { ERROR_MESSAGE_MAX_LENGTH, dispatchErrorDetails } from './dispatch-error-details';
-import type { ZLinkDispatchErrorSink } from './dispatch-error-port';
-import { currentFlowContext, FLOW_ORIGIN_VALUES } from './flow-context';
-const MESSAGE_FLOW_EVENT_ID = 'zlink.message_flow';
-const DISPATCH_ERROR_EVENT_ID = 'zlink.dispatch_error';
+import { dispatchErrorDetails } from './dispatch-error-details';
+import { currentFlowContext } from './flow-context';
+import { toTelemetryRecord, type MessageFlowInput } from './message-flow-record';
+import {
+  messageFlowDelivery,
+  openTelemetryLease,
+  telemetryProviderFailureCount,
+  type ZLinkTelemetryLease
+} from './message-flow-delivery';
 
 export interface ZLinkMessageFlowModeCell {
   mode: ZLinkMessageFlowLogMode;
@@ -27,6 +26,7 @@ export interface ZLinkDiagnosticsContext {
   readonly diagnostics: ZLinkDiagnosticsOptions;
   readonly liveMode: ZLinkMessageFlowModeCell;
   readonly sourceMeshGeneration: bigint;
+  readonly telemetryLease?: ZLinkTelemetryLease;
 }
 
 export const DEFAULT_ZLINK_DIAGNOSTICS: ZLinkDiagnosticsOptions = {
@@ -35,54 +35,8 @@ export const DEFAULT_ZLINK_DIAGNOSTICS: ZLinkDiagnosticsOptions = {
   includeMessageSizes: false
 };
 
-export const telemetryLogger = openTelemetryLogs.getLogger('@zlink-systems/framework');
-const telemetryTracer = openTelemetryTrace.getTracer('@zlink-systems/framework');
-
 let diagnosticsGeneration = 0n;
 
-interface ZLinkTelemetryRecord {
-  readonly severity?: 'warning';
-  readonly eventId: typeof MESSAGE_FLOW_EVENT_ID | typeof DISPATCH_ERROR_EVENT_ID;
-  readonly timestamp: Date;
-  readonly phase?: string;
-  readonly outcome: ZLinkRuntimeMessageFlowResult;
-  readonly surface:
-    | 'node'
-    | 'channel'
-    | 'spot'
-    | 'instance_spot'
-    | 'actor'
-    | 'stream'
-    | 'actor_relocation'
-    | 'classic_fanout';
-  readonly messageKind: 'request' | 'send' | 'response' | 'error' | 'control';
-  readonly reason?: string;
-  readonly action?: string;
-  readonly packetName?: string;
-  readonly channelName?: string;
-  readonly channelRouteKind?: 'route_mesh' | 'client_server';
-  readonly meshName?: string;
-  readonly topic?: string;
-  readonly correlationId?: string;
-  readonly sourceRid?: string;
-  readonly targetRid?: string;
-  readonly serverRid?: string;
-  readonly flowId?: string;
-  readonly flowOrigin?: string;
-  readonly spotId?: string;
-  readonly instanceSpotType?: string;
-  readonly activationState?: string;
-  readonly actorId?: string;
-  readonly streamSessionId?: string;
-  readonly commandId?: number;
-  readonly messageSizeBytes?: number;
-  readonly durationSeconds?: number;
-  readonly errorType?: string;
-  readonly errorMessage?: string;
-  readonly errorCauseType?: string;
-  readonly errorCauseMessage?: string;
-}
-
 export function effectiveMessageFlow(ctx: ZLinkDiagnosticsContext): ZLinkMessageFlowLogMode {
   return ctx.liveMode.mode;
 }
@@ -105,12 +59,14 @@ export function createMessageFlowModeCell(
 export function createDiagnosticsContext(
   dispatch: { diagnostics?: ZLinkDiagnosticsOptions } | undefined,
   _providerResolver: unknown,
-  liveMode: ZLinkMessageFlowModeCell
+  liveMode: ZLinkMessageFlowModeCell,
+  telemetryLease: ZLinkTelemetryLease = openTelemetryLease()
 ): ZLinkDiagnosticsContext {
   return {
     diagnostics: dispatch?.diagnostics ?? DEFAULT_ZLINK_DIAGNOSTICS,
     liveMode,
-    sourceMeshGeneration: ++diagnosticsGeneration
+    sourceMeshGeneration: ++diagnosticsGeneration,
+    telemetryLease
   };
 }
 
@@ -169,32 +125,24 @@ export function traceSessionBindingControlDrop(
   });
 }
 
-type MessageFlowInput = Omit<
-  ZLinkRuntimeMessageFlowEvent,
-  'effectiveMode' | 'flowId' | 'flowOrigin'
-> & {
-  readonly severity?: 'warning';
-  readonly effectiveMode?: ZLinkMessageFlowLogMode;
-  readonly flowId?: string;
-  readonly flowOrigin?: import('../../contracts').ZLinkFlowOrigin;
-};
-
 export class ZLinkMessageFlowTracer {
   private tracedEvents = 0;
-  private providerFailures = 0;
+  private readonly telemetryLease: ZLinkTelemetryLease;
   private localSamplingSequence = 0n;
   private errorsTracePoint?: ZLinkMessageFlowTracePoint;
   private normalTracePoint?: ZLinkMessageFlowTracePoint;
   private detailedTracePoint?: ZLinkMessageFlowTracePoint;
 
-  constructor(
-    private readonly ctx: ZLinkDiagnosticsContext,
-    private readonly errorSink: ZLinkDispatchErrorSink
-  ) {}
+  constructor(private readonly ctx: ZLinkDiagnosticsContext) {
+    this.telemetryLease = ctx.telemetryLease ?? openTelemetryLease();
+  }
 
   enabled(outcome: ZLinkMessageFlowOutcome): boolean {
     const mode = effectiveMessageFlow(this.ctx);
-    return MESSAGE_FLOW_MODE_RANK[mode] >= MESSAGE_FLOW_MODE_RANK[requiredMode(outcome)];
+    return (
+      MESSAGE_FLOW_MODE_RANK[mode] >= MESSAGE_FLOW_MODE_RANK[requiredMode(outcome)] &&
+      messageFlowDelivery().accepts(this.telemetryLease)
+    );
   }
 
   accepts(outcome: ZLinkMessageFlowOutcome): boolean {
@@ -211,7 +159,10 @@ export class ZLinkMessageFlowTracer {
     if (MESSAGE_FLOW_MODE_RANK[mode] < MESSAGE_FLOW_MODE_RANK[requiredMode(outcome, result)]) {
       return undefined;
     }
-    const samplingFlowId = flowId ?? currentFlowContext()?.flowId;
+    if (!messageFlowDelivery().accepts(this.telemetryLease)) return undefined;
+    const samplingFlowId = messageFlowTracingEnabled(mode)
+      ? (flowId ?? currentFlowContext()?.flowId)
+      : undefined;
     if (!this.acceptsSample(outcome, result, samplingFlowId, sourceMeshGeneration)) {
       return undefined;
     }
@@ -244,8 +195,10 @@ export class ZLinkMessageFlowTracer {
       MESSAGE_FLOW_MODE_RANK[requiredMode(flowInput.outcome, flowInput.result)]
     )
       return;
-    const ambient = currentFlowContext();
-    const flowId = flowInput.flowId ?? ambient?.flowId;
+    if (!messageFlowDelivery().accepts(this.telemetryLease)) return;
+    const tracingEnabled = messageFlowTracingEnabled(effectiveMode);
+    const ambient = tracingEnabled ? currentFlowContext() : undefined;
+    const flowId = tracingEnabled ? (flowInput.flowId ?? ambient?.flowId) : undefined;
     if (
       !this.acceptsSample(
         flowInput.outcome,
@@ -264,17 +217,28 @@ export class ZLinkMessageFlowTracer {
     acceptedFlowId?: string,
     acceptedFlowOrigin?: ZLinkFlowOrigin
   ): void {
-    const ambient = currentFlowContext();
-    const flowId = flowInput.flowId ?? acceptedFlowId ?? ambient?.flowId;
-    const flowOrigin = flowInput.flowOrigin ?? acceptedFlowOrigin ?? ambient?.flowOrigin;
+    if (!messageFlowDelivery().accepts(this.telemetryLease)) return;
+    const tracingEnabled = messageFlowTracingEnabled(effectiveMode);
+    const ambient = tracingEnabled ? currentFlowContext() : undefined;
+    const flowId = tracingEnabled
+      ? (flowInput.flowId ?? acceptedFlowId ?? ambient?.flowId)
+      : undefined;
+    const flowOrigin = tracingEnabled
+      ? (flowInput.flowOrigin ?? acceptedFlowOrigin ?? ambient?.flowOrigin)
+      : undefined;
     const flow: MessageFlowInput = {
       ...flowInput,
-      ...(flowId === undefined ? {} : { flowId, flowOrigin }),
+      ...(tracingEnabled
+        ? flowId === undefined
+          ? {}
+          : { flowId, flowOrigin }
+        : { flowId: undefined, flowOrigin: undefined }),
       streamSessionId: flowInput.streamSessionId ?? ambient?.streamSessionId,
       effectiveMode
     };
     this.tracedEvents += 1;
-    this.publish(
+    messageFlowDelivery().submit(
+      this.telemetryLease,
       toTelemetryRecord(
         flow,
         effectiveMode === 'detailed' && this.ctx.diagnostics.includeMessageSizes
@@ -307,7 +271,7 @@ export class ZLinkMessageFlowTracer {
   }
 
   get providerFailureCount(): number {
-    return this.providerFailures;
+    return telemetryProviderFailureCount();
   }
 
   private sample(
@@ -327,275 +291,6 @@ export class ZLinkMessageFlowTracer {
     this.localSamplingSequence += 1n;
     return this.localSamplingSequence;
   }
-
-  private publish(record: ZLinkTelemetryRecord): void {
-    this.publishToLogger(record);
-    this.publishToTrace(record);
-  }
-
-  private publishToLogger(record: ZLinkTelemetryRecord): void {
-    try {
-      const severity =
-        record.severity === 'warning'
-          ? 'WARN'
-          : record.eventId === DISPATCH_ERROR_EVENT_ID
-            ? 'ERROR'
-            : 'INFO';
-      telemetryLogger.emit({
-        eventName: record.eventId,
-        timestamp: record.timestamp,
-        severityNumber: SeverityNumber[severity],
-        severityText: severity,
-        body: structuredLogBody(record),
-        attributes: structuredLogAttributes(record)
-      });
-    } catch (error) {
-      this.reportProviderFailure('logger-provider', error);
-    }
-  }
-
-  private publishToTrace(record: ZLinkTelemetryRecord): void {
-    try {
-      const span = telemetryTracer.startSpan(record.eventId, {
-        attributes: traceAttributes(record)
-      });
-      if (record.eventId === DISPATCH_ERROR_EVENT_ID) {
-        span.setStatus({ code: SpanStatusCode.ERROR, message: record.reason });
-      }
-      span.end();
-    } catch (error) {
-      this.reportProviderFailure('trace-provider', error);
-    }
-  }
-
-  private reportProviderFailure(source: string, error: unknown): void {
-    this.providerFailures += 1;
-    try {
-      this.errorSink.reportRuntimeTaskException(source, error);
-    } catch {
-      // The fallback diagnostics path is isolated for the same reason.
-    }
-  }
-}
-
-function toTelemetryRecord(
-  flow: MessageFlowInput,
-  messageSizeBytes: number | undefined,
-  durationSeconds: number | undefined
-): ZLinkTelemetryRecord {
-  return {
-    severity: flow.severity,
-    eventId:
-      flow.outcome === ZLinkMessageFlowOutcome.Error
-        ? DISPATCH_ERROR_EVENT_ID
-        : MESSAGE_FLOW_EVENT_ID,
-    timestamp: new Date(),
-    phase: messageFlowPhase(flow.outcome),
-    outcome: flow.result ?? messageFlowOutcome(flow.outcome),
-    surface: messageFlowSurface(flow.surface),
-    messageKind: messageFlowKind(flow.messageKind),
-    reason: flow.errorReason,
-    action: flow.errorAction,
-    packetName: flow.packetName,
-    channelName: flow.channelName,
-    channelRouteKind: flow.channelRouteKind ?? channelRouteKind(flow.surface),
-    meshName: flow.meshName,
-    topic: flow.topic,
-    correlationId: flow.correlationId,
-    sourceRid: flow.sourceRid,
-    targetRid: flow.targetRid,
-    serverRid: flow.serverRid,
-    flowId: flow.flowId,
-    flowOrigin: flow.flowOrigin === undefined ? undefined : FLOW_ORIGIN_VALUES[flow.flowOrigin],
-    spotId: flow.spotId,
-    instanceSpotType: flow.instanceSpotType,
-    activationState: flow.activationState,
-    actorId: flow.actorId,
-    streamSessionId: flow.streamSessionId,
-    commandId: flow.commandId,
-    messageSizeBytes,
-    durationSeconds,
-    errorType: flow.errorType,
-    errorMessage: flow.errorMessage,
-    errorCauseType: flow.errorCauseType,
-    errorCauseMessage: boundedText(flow.errorCauseMessage)
-  };
-}
-
-function traceAttributes(record: ZLinkTelemetryRecord): Attributes {
-  const attributes: Attributes = {};
-  for (const [name, value] of Object.entries(record)) {
-    if (value === undefined || name === 'timestamp' || name === 'severity') continue;
-    attributes[toSnakeCase(name)] = value instanceof Date ? value.toISOString() : value;
-  }
-  return attributes;
-}
-
-function structuredLogAttributes(record: ZLinkTelemetryRecord): Attributes {
-  //  기록의 attribute 이름은 Message flow tracing 3.2가 고정한다. 로그 본문의
-  //  `zlink flow:` 축약 key(`kind`, `mesh` …)와 다른 집합이다 —
-  //  structuredLogBodyAttributes를 참고.
-  return compactAttributes({
-    event_id: record.eventId,
-    timestamp: record.timestamp.toISOString(),
-    phase: record.phase,
-    surface: record.surface,
-    message_kind: record.messageKind,
-    mesh_name: record.meshName,
-    channel_name: record.channelName,
-    channel_route_kind: record.channelRouteKind,
-    source_rid: record.sourceRid,
-    target_rid: record.targetRid,
-    server_rid: record.serverRid,
-    packet_name: record.packetName,
-    topic: record.topic,
-    spot_id: record.spotId,
-    instance_spot_type: record.instanceSpotType,
-    activation_state: record.activationState,
-    actor_id: record.actorId,
-    stream_session_id: record.streamSessionId,
-    correlation_id: record.correlationId,
-    flow_id: record.flowId,
-    flow_origin: record.flowOrigin,
-    outcome: record.outcome,
-    reason: record.reason,
-    action: record.action,
-    command_id: record.commandId,
-    error_type: record.errorType,
-    error_message: record.errorMessage,
-    error_cause_type: record.errorCauseType,
-    error_cause_message: record.errorCauseMessage,
-    message_size_bytes: record.messageSizeBytes,
-    duration_seconds: record.durationSeconds
-  });
-}
-
-function structuredLogBodyAttributes(record: ZLinkTelemetryRecord): Attributes {
-  //  `zlink flow:` 본문 전용 축약 key — Message flow tracing "Structured log 대체 표기".
-  return compactAttributes({
-    event: record.eventId,
-    phase: record.phase,
-    surface: record.surface,
-    kind: record.messageKind,
-    mesh: record.meshName,
-    channel: record.channelName,
-    channel_route: record.channelRouteKind,
-    source_rid: record.sourceRid,
-    target_rid: record.targetRid,
-    server_rid: record.serverRid,
-    packet: record.packetName,
-    topic: record.topic,
-    spot: record.spotId,
-    instance_type: record.instanceSpotType,
-    activation_state: record.activationState,
-    actor: record.actorId,
-    session: record.streamSessionId,
-    corr: record.correlationId,
-    flow: record.flowId,
-    origin: record.flowOrigin,
-    outcome: record.outcome,
-    reason: record.reason,
-    action: record.action,
-    error_type: record.errorType,
-    error_message: record.errorMessage,
-    size: record.messageSizeBytes
-  });
-}
-
-function structuredLogBody(record: ZLinkTelemetryRecord): string {
-  return `zlink flow: ${Object.entries(structuredLogBodyAttributes(record))
-    .map(([key, value]) => `${key}=${String(value)}`)
-    .join(' ')}`;
-}
-
-function compactAttributes(values: Record<string, string | number | undefined>): Attributes {
-  const attributes: Attributes = {};
-  for (const [key, value] of Object.entries(values)) {
-    if (value !== undefined) attributes[key] = value;
-  }
-  return attributes;
-}
-
-function messageFlowPhase(outcome: ZLinkMessageFlowOutcome): string | undefined {
-  switch (outcome) {
-    case ZLinkMessageFlowOutcome.Received:
-      return 'received';
-    case ZLinkMessageFlowOutcome.Admitted:
-      return 'admitted';
-    case ZLinkMessageFlowOutcome.Dispatched:
-      return 'dispatched';
-    case ZLinkMessageFlowOutcome.Completed:
-      return 'completed';
-    case ZLinkMessageFlowOutcome.Replied:
-      return 'replied';
-    case ZLinkMessageFlowOutcome.Dropped:
-      return 'dropped';
-    case ZLinkMessageFlowOutcome.Sent:
-      return 'sent';
-    case ZLinkMessageFlowOutcome.ReplyReceived:
-      return 'reply_received';
-    case ZLinkMessageFlowOutcome.Backpressured:
-      return 'backpressured';
-    case ZLinkMessageFlowOutcome.Error:
-      return undefined;
-  }
-}
-
-function messageFlowOutcome(outcome: ZLinkMessageFlowOutcome): ZLinkTelemetryRecord['outcome'] {
-  if (outcome === ZLinkMessageFlowOutcome.Error) return 'failed';
-  if (outcome === ZLinkMessageFlowOutcome.Backpressured) return 'backpressured';
-  if (outcome === ZLinkMessageFlowOutcome.Dropped) return 'dropped';
-  return 'succeeded';
-}
-
-function messageFlowSurface(surface: ZLinkDispatchErrorSurface): ZLinkTelemetryRecord['surface'] {
-  switch (surface) {
-    case ZLinkDispatchErrorSurface.Node:
-      return 'node';
-    case ZLinkDispatchErrorSurface.Channel:
-    case ZLinkDispatchErrorSurface.RouteMeshChannel:
-      return 'channel';
-    case ZLinkDispatchErrorSurface.SpotRoute:
-    case ZLinkDispatchErrorSurface.SpotSubscription:
-      return 'spot';
-    case ZLinkDispatchErrorSurface.InstanceSpot:
-      return 'instance_spot';
-    case ZLinkDispatchErrorSurface.SpotActor:
-      return 'actor';
-    case ZLinkDispatchErrorSurface.StreamSession:
-      return 'stream';
-    case ZLinkDispatchErrorSurface.ActorRelocation:
-      return 'actor_relocation';
-    case ZLinkDispatchErrorSurface.ClassicFanout:
-      return 'classic_fanout';
-  }
-}
-
-function messageFlowKind(kind: ZLinkDispatchMessageKind): ZLinkTelemetryRecord['messageKind'] {
-  switch (kind) {
-    case ZLinkDispatchMessageKind.Request:
-    case ZLinkDispatchMessageKind.ActorRequest:
-      return 'request';
-    case ZLinkDispatchMessageKind.Send:
-    case ZLinkDispatchMessageKind.ActorSend:
-      return 'send';
-    case ZLinkDispatchMessageKind.Response:
-      return 'response';
-    case ZLinkDispatchMessageKind.Error:
-      return 'error';
-    case ZLinkDispatchMessageKind.Control:
-      return 'control';
-    case ZLinkDispatchMessageKind.Publish:
-      throw new Error('Classic fanout publish must not create a normal message-flow record.');
-  }
-}
-
-function channelRouteKind(
-  surface: ZLinkDispatchErrorSurface
-): ZLinkTelemetryRecord['channelRouteKind'] {
-  if (surface === ZLinkDispatchErrorSurface.RouteMeshChannel) return 'route_mesh';
-  if (surface === ZLinkDispatchErrorSurface.Channel) return 'client_server';
-  return undefined;
 }
 
 function hashFlowId(flowId: string): number {
@@ -606,11 +301,3 @@ function hashFlowId(flowId: string): number {
   }
   return hash >>> 0;
 }
-
-function boundedText(value: string | undefined): string | undefined {
-  return value === undefined ? undefined : value.slice(0, ERROR_MESSAGE_MAX_LENGTH);
-}
-
-function toSnakeCase(value: string): string {
-  return value.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}

package/src/runtime/diagnostics/runtime-metrics.ts

@@ -148,7 +148,7 @@ export const METRIC_NAMES = Object.freeze({
     'zlink.host.application_job_queue.flow_state_config_failures'
 } as const);
 
-const COUNTERS = Object.freeze({
+export const COUNTER_UNITS = Object.freeze({
   [METRIC_NAMES.StreamConnectionsOpened]: '{connection}',
   [METRIC_NAMES.StreamConnectionsClosed]: '{connection}',
   [METRIC_NAMES.MeshNodeChannelSelectionFailures]: '{failure}',
@@ -222,7 +222,7 @@ const OBSERVABLE_COUNTERS = Object.freeze({
   [METRIC_NAMES.HostApplicationJobQueueFlowStateConfigFailures]: '{failure}'
 } as const);
 
-type CounterName = keyof typeof COUNTERS;
+type CounterName = keyof typeof COUNTER_UNITS;
 type UpDownName = keyof typeof UP_DOWN_COUNTERS;
 type HistogramName = keyof typeof HISTOGRAMS;
 
@@ -238,7 +238,7 @@ class MetricRegistry {
   >();
 
   constructor(meter: ZLinkObservableMeter) {
-    for (const [name, unit] of Object.entries(COUNTERS)) {
+    for (const [name, unit] of Object.entries(COUNTER_UNITS)) {
       this.counters.set(name, meter.createCounter(name, { unit }));
     }
     for (const [name, unit] of Object.entries(UP_DOWN_COUNTERS)) {
@@ -450,6 +450,10 @@ export class ZLinkRuntimeMetrics {
     safe(() => this.registry.upDown.get(name)?.add(value, attributes));
   }
 
+  recordSpotCount(meshName: string, kind: 'entry' | 'user' | 'instance', delta: number): void {
+    this.change(METRIC_NAMES.SpotCount, delta, { mesh_name: meshName, spot_kind: kind });
+  }
+
   duration(
     name: HistogramName | string,
     seconds: number,
@@ -570,7 +574,8 @@ export class ZLinkRuntimeMetrics {
   startRelocation(
     meshName: string,
     objectKind: 'actor' | 'user_spot' | 'instance_spot',
-    policy: 'recreate' | 'snapshot'
+    policy: 'recreate' | 'snapshot',
+    onComplete?: (outcome: string) => void
   ): ZLinkRelocationMetricOperation {
     const started = process.hrtime.bigint();
     const startAttributes = { mesh_name: meshName, object_kind: objectKind, policy };
@@ -591,6 +596,7 @@ export class ZLinkRuntimeMetrics {
           Number(process.hrtime.bigint() - started) / NANOSECONDS_PER_SECOND,
           terminal
         );
+        onComplete?.(outcome);
       }
     };
   }

package/src/runtime/execution/index.ts

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
+import { startOutsideStateLane } from './state-lane';
 import { isAbortError } from '../abort';
 import {
   ZLinkFrameworkInternalErrorKind,
@@ -31,6 +32,11 @@ export type ZLinkExecutionArea = 'application' | 'infrastructure';
 
 const executionAreaStorage = new AsyncLocalStorage<ZLinkExecutionArea>();
 
+// Capture once through the execution owners, independently of module load scope.
+export const detachedMeshDispatchScope = startOutsideStateLane(() =>
+  executionAreaStorage.exit(() => spotSerialTurnStorage.exit(() => AsyncLocalStorage.snapshot()))
+);
+
 export function runZLinkExecutionArea<T>(area: ZLinkExecutionArea, operation: () => T): T {
   return executionAreaStorage.run(area, operation);
 }