@unrulysystems/native-motion 0.1.0-alpha.0

package/src/native/driver/uiValueChannel.ts

@@ -0,0 +1,4640 @@
+// Private UI-global value-channel coordinator (REQ-DRIVER-034).
+// Creation-ordered callback/admission records, one timestamp-global begin/invoke/revoke/commit
+// frame transaction, stable callback registration, runner admission/reselection, cold-work relay
+// through preallocated canonical records, private dependency events, sink fanout, and the manual
+// frame group. Every kind-keyed dispatch refuses unrecognized kinds with a typed invariant error
+// and leaves state untouched on refusal.
+
+import type { FrameInfo } from 'react-native-reanimated'
+import type { MotionValue } from '@unrulysystems/native-motion-core'
+import type {
+  DestinationCommitAcknowledgement,
+  ImmutableDestinationCommit,
+  NormalizedRetainedWorkEntry,
+  ValueHandoffDestinationLedgerState,
+} from '../motion/driverValueChannel'
+import type { ChannelMailboxEntry } from '../motion/valueChannel'
+import type {
+  MotionValueDriverPort,
+  PrimitiveNumericHistory,
+  TransportedExecutionGeneratorSample,
+} from '@unrulysystems/native-motion-core/internal-driver'
+
+export type UiCoordinatorFrameInfo = Pick<
+  FrameInfo,
+  'timestamp' | 'timeSincePreviousFrame' | 'timeSinceFirstFrame'
+>
+
+export type UiCallbackLeaseState =
+  | 'REGISTERED_INACTIVE'
+  | 'ACTIVATION_REQUESTED'
+  | 'ADMITTED'
+  | 'RUNNER_CANDIDATE'
+  | 'RETIRING'
+  | 'REVOKED'
+
+export interface UiCallbackRegistrationState {
+  readonly driverId: number
+  readonly callbackIdentityId: number
+  readonly callbackRegistrationGeneration: number
+  readonly callbackLeaseEpoch: number
+  readonly state: UiCallbackLeaseState
+  readonly admittedFromTimestampMs: number | null
+  readonly lastInvocationTimestampMs: number | null
+  readonly observerRevision: number
+  readonly activatorRegistered: boolean
+  readonly reanimatedCallbackActive: boolean
+}
+
+export type UiRelayWorkClass =
+  | 'channel-ordinary-first-sample'
+  | 'private-ordinary-first-sample'
+  | 'instant-target'
+  | 'instant-completion'
+  | 'equal-target-reassertion'
+  | 'direct-write'
+  | 'idle-write'
+  | 'transition-end-carrier'
+  | 'exit-carrier'
+  | 'packet-b-carrier'
+
+export type UiColdWorkRelayLeaseState =
+  | 'ARMED'
+  | 'RELAYED_BY_INCUMBENT'
+  | 'CLAIMED_BY_TARGET'
+  | 'RELEASED'
+
+export type UiColdRelayGeneratorExecutionEntry = Extract<
+  NormalizedRetainedWorkEntry,
+  { readonly kind: 'generator-execution' }
+>
+
+export type UiColdRelayUpdateTaskEntry<
+  TaskClass extends Extract<
+    NormalizedRetainedWorkEntry,
+    { readonly kind: 'update-task' }
+  >['taskClass'],
+> = Extract<NormalizedRetainedWorkEntry, { readonly kind: 'update-task' }> & {
+  readonly taskClass: TaskClass
+}
+
+export type UiColdRelayDirectWriteEntry = Extract<
+  NormalizedRetainedWorkEntry,
+  { readonly kind: 'direct-write' }
+>
+
+export type UiColdRelayCompletionEntry = Extract<
+  NormalizedRetainedWorkEntry,
+  { readonly kind: 'value-completion' }
+>
+
+export type UiColdRelayCarrierEntry<
+  TaskClass extends Extract<
+    NormalizedRetainedWorkEntry,
+    { readonly kind: 'carrier-task' }
+  >['taskClass'],
+> = Extract<NormalizedRetainedWorkEntry, { readonly kind: 'carrier-task' }> & {
+  readonly taskClass: TaskClass
+}
+
+export interface UiColdRelayEnvelopeWatermarks {
+  readonly mailboxDrainId: number
+  readonly drainedThroughAuthoritativeSequence: number
+  readonly deliveredWriteWatermark: number
+  readonly deliveredEventWatermark: number
+}
+
+export type UiColdRelayWriteResultSlot =
+  | {
+      readonly kind: 'GENERATOR_SAMPLE_WRITE'
+      readonly resultSlotId: number
+      readonly entry: UiColdRelayGeneratorExecutionEntry
+    }
+  | {
+      readonly kind: 'UPDATE_TASK_WRITE'
+      readonly resultSlotId: number
+      readonly entry: UiColdRelayUpdateTaskEntry<'instant' | 'equal' | 'idle-direct-write'>
+    }
+  | {
+      readonly kind: 'DIRECT_WRITE'
+      readonly resultSlotId: number
+      readonly entry: UiColdRelayDirectWriteEntry
+    }
+
+export type UiColdRelayCallbackResultSlot =
+  | {
+      readonly kind: 'CHANNEL_TRANSITION_ON_UPDATE'
+      readonly resultSlotId: number
+      readonly callbackId: number
+      readonly eventSequence: number
+    }
+  | {
+      readonly kind: 'TASK_CALLBACK'
+      readonly resultSlotId: number
+      readonly taskId: number
+      readonly callback: UiColdRelayUpdateTaskEntry<
+        'instant' | 'equal' | 'idle-direct-write'
+      >['callbacks'][number]
+    }
+  | {
+      readonly kind: 'VALUE_COMPLETION_CALLBACKS'
+      readonly resultSlotId: number
+      readonly completionSequence: number
+      readonly transitionOnCompleteCallbackId: number | null
+      readonly lifecycleCallbackIds: readonly number[]
+      readonly publicStartPromiseId: number | null
+    }
+
+export interface UiColdRelayCarrierResultSlot<
+  TaskClass extends 'transition-end-carrier' | 'exit-carrier' | 'packet-b-carrier' =
+    | 'transition-end-carrier'
+    | 'exit-carrier'
+    | 'packet-b-carrier',
+> {
+  readonly kind: 'CARRIER'
+  readonly resultSlotId: number
+  readonly entry: UiColdRelayCarrierEntry<TaskClass>
+}
+
+export type UiColdRelayHostCommitResultSlot = Extract<
+  ChannelMailboxEntry,
+  { readonly kind: 'ELEMENT_HOST_COMMIT' }
+>
+
+interface UiColdRelayDeliverySlotsCommon<Class extends UiRelayWorkClass> {
+  readonly workClass: Class
+  readonly envelope: UiColdRelayEnvelopeWatermarks
+}
+
+export type UiColdRelayDeliverySlots =
+  | (UiColdRelayDeliverySlotsCommon<'channel-ordinary-first-sample'> & {
+      readonly writeSlots: readonly [
+        Extract<UiColdRelayWriteResultSlot, { readonly kind: 'GENERATOR_SAMPLE_WRITE' }>,
+      ]
+      readonly callbackSlots: readonly Extract<
+        UiColdRelayCallbackResultSlot,
+        { readonly kind: 'CHANNEL_TRANSITION_ON_UPDATE' }
+      >[]
+      readonly carrierSlots: readonly []
+      readonly hostSlots: readonly [UiColdRelayHostCommitResultSlot]
+    })
+  | (UiColdRelayDeliverySlotsCommon<'private-ordinary-first-sample'> & {
+      readonly writeSlots: readonly [
+        Extract<UiColdRelayWriteResultSlot, { readonly kind: 'GENERATOR_SAMPLE_WRITE' }>,
+      ]
+      readonly callbackSlots: readonly []
+      readonly carrierSlots: readonly []
+      readonly hostSlots: readonly [UiColdRelayHostCommitResultSlot]
+    })
+  | (UiColdRelayDeliverySlotsCommon<'instant-target'> & {
+      readonly writeSlots: readonly [
+        Extract<UiColdRelayWriteResultSlot, { readonly kind: 'UPDATE_TASK_WRITE' }> & {
+          readonly entry: UiColdRelayUpdateTaskEntry<'instant'>
+        },
+      ]
+      readonly callbackSlots: readonly Extract<
+        UiColdRelayCallbackResultSlot,
+        { readonly kind: 'TASK_CALLBACK' }
+      >[]
+      readonly carrierSlots: readonly []
+      readonly hostSlots: readonly [UiColdRelayHostCommitResultSlot]
+    })
+  | (UiColdRelayDeliverySlotsCommon<'instant-completion'> & {
+      readonly writeSlots: readonly []
+      readonly callbackSlots: readonly [
+        Extract<UiColdRelayCallbackResultSlot, { readonly kind: 'VALUE_COMPLETION_CALLBACKS' }>,
+      ]
+      readonly carrierSlots: readonly []
+      readonly hostSlots: readonly []
+    })
+  | (UiColdRelayDeliverySlotsCommon<'equal-target-reassertion'> & {
+      readonly writeSlots: readonly [
+        Extract<UiColdRelayWriteResultSlot, { readonly kind: 'UPDATE_TASK_WRITE' }> & {
+          readonly entry: UiColdRelayUpdateTaskEntry<'equal'>
+        },
+      ]
+      readonly callbackSlots: readonly Extract<
+        UiColdRelayCallbackResultSlot,
+        { readonly kind: 'TASK_CALLBACK' }
+      >[]
+      readonly carrierSlots: readonly []
+      readonly hostSlots: readonly [UiColdRelayHostCommitResultSlot]
+    })
+  | (UiColdRelayDeliverySlotsCommon<'direct-write'> & {
+      readonly writeSlots: readonly [
+        Extract<UiColdRelayWriteResultSlot, { readonly kind: 'DIRECT_WRITE' }>,
+      ]
+      readonly callbackSlots: readonly []
+      readonly carrierSlots: readonly []
+      readonly hostSlots: readonly [UiColdRelayHostCommitResultSlot]
+    })
+  | (UiColdRelayDeliverySlotsCommon<'idle-write'> & {
+      readonly writeSlots: readonly [
+        Extract<UiColdRelayWriteResultSlot, { readonly kind: 'UPDATE_TASK_WRITE' }> & {
+          readonly entry: UiColdRelayUpdateTaskEntry<'idle-direct-write'>
+        },
+      ]
+      readonly callbackSlots: readonly Extract<
+        UiColdRelayCallbackResultSlot,
+        { readonly kind: 'TASK_CALLBACK' }
+      >[]
+      readonly carrierSlots: readonly []
+      readonly hostSlots: readonly [UiColdRelayHostCommitResultSlot]
+    })
+  | (UiColdRelayDeliverySlotsCommon<'transition-end-carrier'> & {
+      readonly writeSlots: readonly []
+      readonly callbackSlots: readonly []
+      readonly carrierSlots: readonly [UiColdRelayCarrierResultSlot<'transition-end-carrier'>]
+      readonly hostSlots: readonly [UiColdRelayHostCommitResultSlot]
+    })
+  | (UiColdRelayDeliverySlotsCommon<'exit-carrier'> & {
+      readonly writeSlots: readonly []
+      readonly callbackSlots: readonly []
+      readonly carrierSlots: readonly [UiColdRelayCarrierResultSlot<'exit-carrier'>]
+      readonly hostSlots: readonly [UiColdRelayHostCommitResultSlot]
+    })
+  | (UiColdRelayDeliverySlotsCommon<'packet-b-carrier'> & {
+      readonly writeSlots: readonly []
+      readonly callbackSlots: readonly []
+      readonly carrierSlots: readonly [UiColdRelayCarrierResultSlot<'packet-b-carrier'>]
+      readonly hostSlots: readonly [UiColdRelayHostCommitResultSlot]
+    })
+
+interface UiColdRelayCommandAuthorityCommon<Class extends UiRelayWorkClass> {
+  readonly workClass: Class
+  readonly destinationRecordId: number
+}
+
+type UiColdRelayCommandAuthority =
+  | (UiColdRelayCommandAuthorityCommon<'channel-ordinary-first-sample'> & {
+      readonly owner: { readonly kind: 'PUBLIC_IDENTITY'; readonly channelId: number }
+      readonly executionId: number
+    })
+  | (UiColdRelayCommandAuthorityCommon<'private-ordinary-first-sample'> & {
+      readonly owner: { readonly kind: 'PRIVATE_CONTROL'; readonly controlId: number }
+      readonly executionId: number
+    })
+  | (UiColdRelayCommandAuthorityCommon<'instant-target'> & {
+      readonly taskId: number
+      readonly taskSequence: number
+    })
+  | (UiColdRelayCommandAuthorityCommon<'instant-completion'> & {
+      readonly completionSequence: number
+      readonly completionControllerId: number
+    })
+  | (UiColdRelayCommandAuthorityCommon<'equal-target-reassertion'> & {
+      readonly taskId: number
+      readonly taskSequence: number
+    })
+  | (UiColdRelayCommandAuthorityCommon<'direct-write'> & {
+      readonly directOperationId: number
+      readonly directOperationEpoch: number
+    })
+  | (UiColdRelayCommandAuthorityCommon<'idle-write'> & {
+      readonly taskId: number
+      readonly taskSequence: number
+    })
+  | (UiColdRelayCommandAuthorityCommon<'transition-end-carrier'> & {
+      readonly carrierControllerId: number
+      readonly taskId: number
+    })
+  | (UiColdRelayCommandAuthorityCommon<'exit-carrier'> & {
+      readonly carrierControllerId: number
+      readonly taskId: number
+    })
+  | (UiColdRelayCommandAuthorityCommon<'packet-b-carrier'> & {
+      readonly carrierControllerId: number
+      readonly taskId: number
+    })
+
+declare const uiColdRelayCanonicalRecordBrand: unique symbol
+
+export interface UiColdRelayCanonicalRecord {
+  readonly [uiColdRelayCanonicalRecordBrand]: true
+}
+
+export interface UiColdWorkRelayValueBearingEntry {
+  readonly kind: 'COMPLETE_TRANSITION_ON_UPDATE'
+  readonly channelId: number
+  readonly targetCallbackIdentityId: number
+  readonly transitionCallbackId: number
+  readonly valueWriteEntryId: number
+  readonly transitionCallbackEntryId: number
+  readonly executionId: number
+  readonly directOperationEpoch: number
+  readonly executionLease: number
+  readonly authoritativeSequence: number
+  readonly writeSequence: number
+  readonly eventSequence: number
+  readonly candidateHistory: PrimitiveNumericHistory
+  readonly completion: TransportedExecutionGeneratorSample['completion']
+}
+
+export type UiColdWorkRelayValueWriteMailboxEntry = Extract<
+  ChannelMailboxEntry,
+  { readonly kind: 'VALUE_WRITE' }
+> & {
+  readonly sample: TransportedExecutionGeneratorSample
+}
+
+export type UiColdWorkRelayTransitionCallbackMailboxEntry = Extract<
+  ChannelMailboxEntry,
+  { readonly kind: 'TRANSITION_CALLBACK' }
+> & {
+  readonly event: Extract<
+    ChannelMailboxEntry,
+    { readonly kind: 'TRANSITION_CALLBACK' }
+  >['event'] & { readonly kind: 'transition-on-update' }
+}
+
+export interface UiColdWorkRelayMailboxPrefix {
+  readonly mailboxOrigin: 'UI'
+  readonly mailboxDrainId: number
+  readonly stagedEntries: readonly [
+    UiColdWorkRelayValueWriteMailboxEntry,
+    UiColdWorkRelayTransitionCallbackMailboxEntry,
+  ]
+  readonly sealed: false
+}
+
+export interface UiColdWorkRelayStagedValueBearingPrefix {
+  readonly mailboxDrainId: number
+  readonly valueWriteEntryId: number
+  readonly transitionCallbackEntryId: number
+  readonly transitionCallbackId: number
+  readonly authoritativeSequence: number
+  readonly writeSequence: number
+  readonly eventSequence: number
+}
+
+/** Canonical public-identity authority retained by the coordinator, never reconstructed by relay. */
+export interface UiPublicIdentityChannelRecord {
+  readonly channelId: number
+  readonly motionValue: MotionValue<number>
+  readonly driverPort: MotionValueDriverPort<number>
+}
+
+interface UiGeneratorExecutionRecordCommon<Class extends UiRelayWorkClass> {
+  readonly workClass: Class
+  readonly executionRecordId: number
+  readonly entry: UiColdRelayGeneratorExecutionEntry
+  readonly valueBearingEntry: UiColdWorkRelayValueBearingEntry | null
+  readonly writeSlot: Extract<
+    UiColdRelayWriteResultSlot,
+    { readonly kind: 'GENERATOR_SAMPLE_WRITE' }
+  >
+  readonly callbackSlots: readonly Extract<
+    UiColdRelayCallbackResultSlot,
+    { readonly kind: 'CHANNEL_TRANSITION_ON_UPDATE' }
+  >[]
+  readonly mailboxDrainId: number
+  readonly hostSinkRecordIds: readonly number[]
+}
+
+export type UiGeneratorExecutionRecord =
+  | (UiGeneratorExecutionRecordCommon<'channel-ordinary-first-sample'> & {
+      readonly owner: { readonly kind: 'PUBLIC_IDENTITY'; readonly channelId: number }
+      readonly publicIdentityChannel: UiPublicIdentityChannelRecord
+      readonly valueBearingEntry: UiColdWorkRelayValueBearingEntry
+    })
+  | (UiGeneratorExecutionRecordCommon<'private-ordinary-first-sample'> & {
+      readonly owner: { readonly kind: 'PRIVATE_CONTROL'; readonly controlId: number }
+      readonly publicIdentityChannel: null
+    })
+
+type UiDueWorkTaskClass = Extract<
+  NormalizedRetainedWorkEntry,
+  { readonly kind: 'update-task' }
+>['taskClass']
+
+interface UiDueWorkTaskRecordCommon<
+  Class extends UiRelayWorkClass,
+  TaskClass extends UiDueWorkTaskClass,
+> {
+  readonly workClass: Class
+  readonly taskRecordId: number
+  readonly entry: UiColdRelayUpdateTaskEntry<TaskClass>
+  readonly writeSlot: Extract<
+    UiColdRelayWriteResultSlot,
+    { readonly kind: 'UPDATE_TASK_WRITE' }
+  > & { readonly entry: UiColdRelayUpdateTaskEntry<TaskClass> }
+  readonly callbackSlots: readonly Extract<
+    UiColdRelayCallbackResultSlot,
+    { readonly kind: 'TASK_CALLBACK' }
+  >[]
+  readonly mailboxDrainId: number
+  readonly hostSinkRecordIds: readonly number[]
+}
+
+export type UiDueWorkTaskRecord =
+  | UiDueWorkTaskRecordCommon<'instant-target', 'instant'>
+  | UiDueWorkTaskRecordCommon<'equal-target-reassertion', 'equal'>
+  | UiDueWorkTaskRecordCommon<'idle-write', 'idle-direct-write'>
+
+export interface UiValueCompletionControllerRecord {
+  readonly workClass: 'instant-completion'
+  readonly completionControllerId: number
+  readonly entry: UiColdRelayCompletionEntry
+  readonly callbackSlot: Extract<
+    UiColdRelayCallbackResultSlot,
+    { readonly kind: 'VALUE_COMPLETION_CALLBACKS' }
+  >
+  readonly mailboxDrainId: number
+}
+
+export interface UiDirectOperationRecord {
+  readonly workClass: 'direct-write'
+  readonly directOperationId: number
+  readonly directOperationEpoch: number
+  readonly entry: UiColdRelayDirectWriteEntry
+  readonly writeSlot: Extract<UiColdRelayWriteResultSlot, { readonly kind: 'DIRECT_WRITE' }>
+  readonly mailboxDrainId: number
+  readonly hostSinkRecordIds: readonly number[]
+}
+
+interface UiCarrierControllerRecordCommon<
+  Class extends 'transition-end-carrier' | 'exit-carrier' | 'packet-b-carrier' =
+    | 'transition-end-carrier'
+    | 'exit-carrier'
+    | 'packet-b-carrier',
+> {
+  readonly workClass: Class
+  readonly carrierControllerId: number
+  readonly entry: UiColdRelayCarrierEntry<Class>
+  readonly carrierSlot: UiColdRelayCarrierResultSlot<Class>
+  readonly mailboxDrainId: number
+  readonly hostSinkRecordIds: readonly number[]
+}
+
+export type UiCarrierControllerRecord = {
+  readonly [Class in
+    | 'transition-end-carrier'
+    | 'exit-carrier'
+    | 'packet-b-carrier']: UiCarrierControllerRecordCommon<Class>
+}['transition-end-carrier' | 'exit-carrier' | 'packet-b-carrier']
+
+export interface UiMailboxTurnRecord {
+  readonly mailboxDrainId: number
+  readonly envelope: UiColdRelayEnvelopeWatermarks
+}
+
+export interface UiHostSinkRecord {
+  readonly hostSinkRecordId: number
+  readonly slot: UiColdRelayHostCommitResultSlot
+}
+
+type UiColdRelayPrimaryRecordByClass = {
+  readonly 'channel-ordinary-first-sample': Extract<
+    UiGeneratorExecutionRecord,
+    { readonly workClass: 'channel-ordinary-first-sample' }
+  >
+  readonly 'private-ordinary-first-sample': Extract<
+    UiGeneratorExecutionRecord,
+    { readonly workClass: 'private-ordinary-first-sample' }
+  >
+  readonly 'instant-target': Extract<UiDueWorkTaskRecord, { readonly workClass: 'instant-target' }>
+  readonly 'instant-completion': UiValueCompletionControllerRecord
+  readonly 'equal-target-reassertion': Extract<
+    UiDueWorkTaskRecord,
+    { readonly workClass: 'equal-target-reassertion' }
+  >
+  readonly 'direct-write': UiDirectOperationRecord
+  readonly 'idle-write': Extract<UiDueWorkTaskRecord, { readonly workClass: 'idle-write' }>
+  readonly 'transition-end-carrier': Extract<
+    UiCarrierControllerRecord,
+    { readonly workClass: 'transition-end-carrier' }
+  >
+  readonly 'exit-carrier': Extract<
+    UiCarrierControllerRecord,
+    { readonly workClass: 'exit-carrier' }
+  >
+  readonly 'packet-b-carrier': Extract<
+    UiCarrierControllerRecord,
+    { readonly workClass: 'packet-b-carrier' }
+  >
+}
+
+type UiColdRelayCallbackRegistrationsByClass = {
+  readonly 'channel-ordinary-first-sample': readonly [UiCallbackRegistrationState]
+  readonly 'private-ordinary-first-sample': readonly []
+  readonly 'instant-target': readonly [UiCallbackRegistrationState]
+  readonly 'instant-completion': readonly [UiCallbackRegistrationState]
+  readonly 'equal-target-reassertion': readonly [UiCallbackRegistrationState]
+  readonly 'direct-write': readonly []
+  readonly 'idle-write': readonly []
+  readonly 'transition-end-carrier': readonly []
+  readonly 'exit-carrier': readonly []
+  readonly 'packet-b-carrier': readonly []
+}
+
+type UiColdRelayHostSinkRecordsByClass = {
+  readonly 'channel-ordinary-first-sample': readonly [UiHostSinkRecord]
+  readonly 'private-ordinary-first-sample': readonly [UiHostSinkRecord]
+  readonly 'instant-target': readonly [UiHostSinkRecord]
+  readonly 'instant-completion': readonly []
+  readonly 'equal-target-reassertion': readonly [UiHostSinkRecord]
+  readonly 'direct-write': readonly [UiHostSinkRecord]
+  readonly 'idle-write': readonly [UiHostSinkRecord]
+  readonly 'transition-end-carrier': readonly [UiHostSinkRecord]
+  readonly 'exit-carrier': readonly [UiHostSinkRecord]
+  readonly 'packet-b-carrier': readonly [UiHostSinkRecord]
+}
+
+const uiColdRelaySourceRecordsBrand = Symbol('UiColdRelaySourceRecords')
+
+export type UiColdRelaySourceRecords = {
+  readonly [Class in UiRelayWorkClass]: {
+    readonly [uiColdRelaySourceRecordsBrand]: true
+    readonly workClass: Class
+    readonly primaryRecord: UiColdRelayPrimaryRecordByClass[Class]
+    readonly callbackRegistrations: UiColdRelayCallbackRegistrationsByClass[Class]
+    readonly mailboxRecord: UiMailboxTurnRecord
+    readonly hostSinkRecords: UiColdRelayHostSinkRecordsByClass[Class]
+  }
+}[UiRelayWorkClass]
+
+export type UiColdRelayCommandProductionRequest =
+  | {
+      readonly kind: 'START_PUBLIC_IDENTITY_EXECUTION'
+      readonly destinationRecordId: number
+      readonly channelId: number
+      readonly executionId: number
+    }
+  | {
+      readonly kind: 'START_PRIVATE_CONTROL_EXECUTION'
+      readonly destinationRecordId: number
+      readonly controlId: number
+      readonly executionId: number
+    }
+  | {
+      readonly kind: 'QUEUE_INSTANT_TARGET'
+      readonly destinationRecordId: number
+      readonly taskId: number
+      readonly taskSequence: number
+    }
+  | {
+      readonly kind: 'ARM_INSTANT_COMPLETION'
+      readonly destinationRecordId: number
+      readonly completionSequence: number
+      readonly completionControllerId: number
+    }
+  | {
+      readonly kind: 'QUEUE_EQUAL_TARGET_REASSERTION'
+      readonly destinationRecordId: number
+      readonly taskId: number
+      readonly taskSequence: number
+    }
+  | {
+      readonly kind: 'APPLY_DIRECT_WRITE'
+      readonly destinationRecordId: number
+      readonly directOperationId: number
+      readonly directOperationEpoch: number
+    }
+  | {
+      readonly kind: 'QUEUE_IDLE_WRITE'
+      readonly destinationRecordId: number
+      readonly taskId: number
+      readonly taskSequence: number
+    }
+  | {
+      readonly kind:
+        | 'QUEUE_TRANSITION_END_CARRIER'
+        | 'QUEUE_EXIT_CARRIER'
+        | 'QUEUE_PACKET_B_CARRIER'
+      readonly destinationRecordId: number
+      readonly carrierControllerId: number
+      readonly taskId: number
+    }
+
+const uiColdRelayProducerReceiptBrand = Symbol('UiColdRelayProducerReceipt')
+
+export interface UiColdRelayCommandProductionTransition {
+  readonly [uiColdRelayProducerReceiptBrand]: true
+  readonly state: UiValueChannelCoordinatorState
+  readonly commandAuthority: UiColdRelayCommandAuthority
+  readonly sourceRecords: UiColdRelaySourceRecords
+}
+
+interface UiColdRelayCanonicalRecordObservationCommon<Class extends UiRelayWorkClass> {
+  readonly recordId: number
+  readonly authority: Extract<UiColdRelayCommandAuthority, { readonly workClass: Class }>
+}
+
+type UiColdRelayFilledCanonicalRecordObservation = {
+  readonly [Class in UiRelayWorkClass]: UiColdRelayCanonicalRecordObservationCommon<Class> & {
+    readonly fillState: 'FILLED_FROM_LIVE_RECORDS'
+    readonly sourceRecords: Extract<UiColdRelaySourceRecords, { readonly workClass: Class }>
+    readonly deliverySlots: Extract<UiColdRelayDeliverySlots, { readonly workClass: Class }>
+  }
+}[UiRelayWorkClass]
+
+export type UiColdRelayCanonicalRecordObservation =
+  | ({
+      readonly fillState: 'EMPTY'
+      readonly sourceRecords: null
+      readonly deliverySlots: null
+    } & {
+      readonly [Class in UiRelayWorkClass]: UiColdRelayCanonicalRecordObservationCommon<Class>
+    }[UiRelayWorkClass])
+  | UiColdRelayFilledCanonicalRecordObservation
+
+export type UiColdRelayEffect =
+  | {
+      readonly kind: 'allocate-empty-canonical-cold-relay-record'
+      readonly relayId: number
+      readonly canonicalRecord: UiColdRelayCanonicalRecord
+    }
+  | {
+      readonly kind: 'fill-canonical-cold-relay-record-from-live-records'
+      readonly relayId: number
+      readonly canonicalRecord: UiColdRelayCanonicalRecord
+      readonly sourceRecords: UiColdRelaySourceRecords
+    }
+  | {
+      readonly kind: 'apply-canonical-cold-relay-record'
+      readonly relayId: number
+      readonly targetDriverId: number
+      readonly canonicalRecord: UiColdRelayCanonicalRecord
+    }
+  | {
+      readonly kind: 'arm-cold-relay-lease-at-command-edge'
+      readonly relayId: number
+      readonly targetDriverId: number
+      readonly targetCallbackRegistrationGeneration: number
+      readonly relayLeaseEpoch: number
+      readonly commandReceipt: UiColdRelayCommandProductionTransition
+      readonly canonicalRecord: UiColdRelayCanonicalRecord
+    }
+  | {
+      readonly kind: 'activate-cold-relay-target-after-command-arm'
+      readonly relayId: number
+      readonly targetDriverId: number
+      readonly targetCallbackRegistrationGeneration: number
+    }
+
+export interface UiColdWorkRelayState {
+  readonly relayId: number
+  readonly targetDriverId: number
+  readonly commandReceipt: UiColdRelayCommandProductionTransition
+  readonly canonicalRecord: UiColdRelayCanonicalRecord
+  readonly commandSequence: number
+  readonly targetCallbackRegistrationGeneration: number
+  readonly relayLeaseEpoch: number
+  readonly leaseState: UiColdWorkRelayLeaseState
+  readonly lifetime: 'ONE_SHOT' | 'ONGOING_EXECUTION'
+  readonly armedAtTimestampMs: number | null
+  readonly lastRelayedStepTimestampMs: number | null
+  readonly claimedAtTimestampMs: number | null
+  readonly claimedByDriverId: number | null
+  readonly pendingValueBearingEntry: UiColdWorkRelayValueBearingEntry | null
+  readonly stagedValueBearingPrefix: UiColdWorkRelayStagedValueBearingPrefix | null
+}
+
+export interface UiRetainedFrameCallbackActivatorRegistry {
+  hasStableActivator(driverId: number, callbackRegistrationGeneration: number): boolean
+  setActive(driverId: number, callbackRegistrationGeneration: number, active: boolean): void
+}
+
+export interface UiRunnerAdmissionRequestState {
+  readonly requestedRunnerLeaseEpoch: number
+  readonly candidateDriverId: number
+  readonly callbackRegistrationGeneration: number
+  readonly admissionToken: number
+  readonly absoluteDeadlineMs: number
+  readonly actualInvocationObserved: boolean
+}
+
+export interface UiIdentityFrameState {
+  readonly channelId: number
+  readonly lastAbsoluteTimestampMs: number | null
+  readonly stepCount: number
+  readonly hostCommitCount: number
+  readonly lastCommittedValueSequence: number
+}
+
+export interface UiOwnedIdentitySinkCommitState {
+  readonly sinkId: number
+  readonly driverId: number
+  readonly handle: number
+  readonly key: string
+  readonly bindingGeneration: number
+  readonly lastCommittedValue: number
+  readonly lastCommittedWriteSequence: number
+  readonly commitCount: number
+}
+
+export interface UiOwnedIdentitySampleFanoutState {
+  readonly channelId: number
+  readonly ownership: 'UI'
+  readonly lastAcceptedAbsoluteTimestampMs: number | null
+  readonly sinks: readonly UiOwnedIdentitySinkCommitState[]
+  readonly uiSinkCommitCount: number
+  readonly jsToUiWriteLaneInvocationCount: number
+}
+
+export interface UiOwnedIdentitySampleFanoutRequest {
+  readonly source: 'UI_OWNED_IDENTITY_SAMPLE'
+  readonly channelId: number
+  readonly executionId: number
+  readonly value: number
+  readonly writeSequence: number
+  readonly absoluteTimestampMs: number
+}
+
+export type UiOwnedIdentitySampleFanoutEffect =
+  | {
+      readonly kind: 'adopt-ui-owned-identity-sample'
+      readonly channelId: number
+      readonly executionId: number
+      readonly value: number
+      readonly writeSequence: number
+      readonly absoluteTimestampMs: number
+    }
+  | {
+      readonly kind: 'fanout-ui-owned-identity-sample-to-sink'
+      readonly sinkId: number
+      readonly driverId: number
+      readonly handle: number
+      readonly key: string
+      readonly bindingGeneration: number
+      readonly value: number
+      readonly writeSequence: number
+    }
+  | {
+      readonly kind: 'commit-ui-owned-identity-sinks-once'
+      readonly channelId: number
+      readonly sinkIds: readonly number[]
+      readonly absoluteTimestampMs: number
+    }
+
+export interface UiOwnedIdentitySampleFanoutObservation {
+  readonly channelId: number
+  readonly sinkCount: number
+  readonly committedSinkCount: number
+  readonly committedSinkIds: readonly number[]
+  readonly uiSinkCommitCount: number
+  readonly jsToUiWriteLaneInvocationCount: number
+}
+
+export interface UiOwnedIdentitySampleFanoutTransition {
+  readonly state: UiOwnedIdentitySampleFanoutState
+  readonly observation: UiOwnedIdentitySampleFanoutObservation
+  readonly orderedEffects: readonly UiOwnedIdentitySampleFanoutEffect[]
+}
+
+interface UiFrameTransactionCommon {
+  readonly lastCommittedTimestampMs: number | null
+  readonly committedFrameCount: number
+}
+
+export type UiFrameTransactionState =
+  | (UiFrameTransactionCommon & { readonly kind: 'CLOSED' })
+  | (UiFrameTransactionCommon & {
+      readonly kind: 'OPEN'
+      readonly mode: 'LIVE' | 'MANUAL'
+      readonly absoluteTimestampMs: number
+      readonly mailboxDrainId: number
+      readonly expectedAttendeeDriverIds: readonly number[]
+      readonly visitedAttendeeDriverIds: readonly number[]
+      readonly revokedAttendeeDriverIds: readonly number[]
+      readonly steppedChannelIds: readonly number[]
+      readonly frozenInvocationOrder: readonly number[]
+    })
+
+export interface UiManualDestinationCommitSlot extends ImmutableDestinationCommit {
+  readonly commitSlotId: number
+  readonly acknowledgementSlotId: number
+}
+
+export interface UiDestinationCommitAuthority {
+  readonly channelId: number
+  readonly sourceRecordId: number
+  readonly destinationRecordId: number
+  readonly direction: 'UI_TO_JS' | 'JS_TO_UI'
+  readonly transferLease: number
+  readonly releaseFenceSequence: number
+}
+
+export interface UiPreparedDestinationRecordState extends UiDestinationCommitAuthority {
+  readonly adoptedCommitSlotId: number | null
+  readonly appliedThroughAuthoritativeSequence: number
+  readonly ledgers: ValueHandoffDestinationLedgerState
+}
+
+export type UiDestinationCommitRefusalReason =
+  | 'envelope-not-open'
+  | 'missing-prepared-destination-record'
+  | 'missing-acknowledgement-slot'
+  | 'wrong-channel'
+  | 'wrong-source-record'
+  | 'wrong-destination-record'
+  | 'wrong-direction'
+  | 'wrong-transfer-lease'
+  | 'wrong-release-fence'
+  | 'ahead-of-sent-watermark'
+  | 'sent-watermark-regressed'
+  | 'prefix-not-contiguous'
+
+export type UiDestinationCommitCanonicalRefusalReason = Exclude<
+  UiDestinationCommitRefusalReason,
+  'envelope-not-open' | 'missing-acknowledgement-slot'
+>
+
+export interface UiDestinationCommitCanonicalValidationRequest {
+  readonly commit: ImmutableDestinationCommit
+  readonly preparedDestinationRecords: readonly UiPreparedDestinationRecordState[]
+}
+
+export type UiDestinationCommitCanonicalValidationOutcome =
+  | {
+      readonly kind: 'VALID'
+      readonly authority: UiPreparedDestinationRecordState
+    }
+  | {
+      readonly kind: 'REFUSED'
+      readonly authority: UiPreparedDestinationRecordState | null
+      readonly reason: UiDestinationCommitCanonicalRefusalReason
+    }
+
+const uiDestinationCommitCanonicalValidatorCapabilityBrand = Symbol(
+  'UiDestinationCommitCanonicalValidatorCapability',
+)
+
+export interface UiDestinationCommitCanonicalValidatorCapability {
+  readonly [uiDestinationCommitCanonicalValidatorCapabilityBrand]: true
+  readonly validate: typeof validateUiDestinationCommitWithCanonicalAuthority
+}
+
+export type UiDestinationCommitCanonicalValidationEffect =
+  | {
+      readonly kind: 'validate-ui-destination-commit-with-canonical-authority'
+      readonly root: 'LIVE'
+      readonly commitSlotId: number
+      readonly authority: UiPreparedDestinationRecordState
+      readonly validator: UiDestinationCommitCanonicalValidatorCapability
+    }
+  | {
+      readonly kind: 'validate-ui-destination-commit-with-canonical-authority'
+      readonly root: 'MANUAL'
+      readonly groupId: number
+      readonly commitSlotId: number
+      readonly authority: UiPreparedDestinationRecordState
+      readonly validator: UiDestinationCommitCanonicalValidatorCapability
+    }
+
+export type UiDestinationCommitRefusalReportEffect =
+  | {
+      readonly kind: 'report-ui-destination-commit-refusal'
+      readonly root: 'LIVE'
+      readonly commitSlotId: number
+      readonly authority: UiPreparedDestinationRecordState | null
+      readonly reason: UiDestinationCommitRefusalReason
+    }
+  | {
+      readonly kind: 'report-ui-destination-commit-refusal'
+      readonly root: 'MANUAL'
+      readonly groupId: number
+      readonly commitSlotId: number
+      readonly authority: UiPreparedDestinationRecordState | null
+      readonly reason: UiDestinationCommitRefusalReason
+    }
+
+export interface UiDestinationCommitAcknowledgementSlotState {
+  readonly acknowledgementSlotId: number
+  readonly commitSlotId: number
+  readonly state: 'EMPTY' | 'FILLED' | 'STAGED_IN_CURRENT_ENVELOPE'
+  readonly acknowledgement: DestinationCommitAcknowledgement | null
+}
+
+export interface ManualFrameGroupState {
+  readonly groupId: number
+  readonly currentAbsoluteTimestampMs: number
+  readonly participantDriverIds: readonly number[]
+  readonly callbackRegistrationGenerations: readonly number[]
+  readonly pendingDestinationCommits: readonly UiManualDestinationCommitSlot[]
+  readonly consumedCommitSlotIds: readonly number[]
+  readonly armedForExplicitStep: boolean
+  readonly explicitStepCount: number
+}
+
+export interface UiValueChannelCoordinatorState {
+  readonly runnerDriverId: number | null
+  readonly runnerLeaseEpoch: number
+  readonly runnerAdmissionRequest: UiRunnerAdmissionRequestState | null
+  readonly nextRunnerAdmissionToken: number
+  readonly nextMailboxDrainId: number
+  readonly publicIdentityChannels: readonly UiPublicIdentityChannelRecord[]
+  readonly generatorExecutions: readonly UiGeneratorExecutionRecord[]
+  readonly dueWorkTasks: readonly UiDueWorkTaskRecord[]
+  readonly valueCompletionControllers: readonly UiValueCompletionControllerRecord[]
+  readonly directOperations: readonly UiDirectOperationRecord[]
+  readonly carrierControllers: readonly UiCarrierControllerRecord[]
+  readonly mailboxTurns: readonly UiMailboxTurnRecord[]
+  readonly hostSinks: readonly UiHostSinkRecord[]
+  readonly preparedDestinationRecords: readonly UiPreparedDestinationRecordState[]
+  readonly destinationCommitAcknowledgementSlots: readonly UiDestinationCommitAcknowledgementSlotState[]
+  readonly callbacks: readonly UiCallbackRegistrationState[]
+  readonly relays: readonly UiColdWorkRelayState[]
+  readonly identities: readonly UiIdentityFrameState[]
+  readonly transaction: UiFrameTransactionState
+  readonly manualGroups: readonly ManualFrameGroupState[]
+}
+
+export interface UiValueChannelObservation {
+  readonly runnerDriverId: number | null
+  readonly runnerLeaseEpoch: number
+  readonly callbackCount: number
+  readonly callbackIdentityIds: readonly number[]
+  readonly callbackRegistrationGenerations: readonly number[]
+  readonly admittedDriverIds: readonly number[]
+  readonly relayCount: number
+  readonly unclaimedRelayCount: number
+  readonly identityCount: number
+  readonly totalIdentityStepCount: number
+  readonly totalHostCommitCount: number
+  readonly transactionKind: UiFrameTransactionState['kind']
+  readonly openTimestampMs: number | null
+  readonly expectedAttendeeCount: number
+  readonly visitedAttendeeCount: number
+  readonly revokedAttendeeCount: number
+  readonly lastCommittedTimestampMs: number | null
+  readonly committedFrameCount: number
+  readonly manualGroupCount: number
+  readonly armedManualGroupIds: readonly number[]
+  readonly pendingManualDestinationCommitCount: number
+}
+
+export type UiCoordinatorEvent =
+  | {
+      readonly kind: 'arm-cold-work-relay-at-command-edge'
+      readonly relayId: number
+      readonly targetDriverId: number
+      readonly commandSequence: number
+      readonly targetCallbackRegistrationGeneration: number
+      readonly relayLeaseEpoch: number
+      readonly lifetime: 'ONE_SHOT' | 'ONGOING_EXECUTION'
+      readonly armedAtTimestampMs: number
+      readonly commandReceipt: UiColdRelayCommandProductionTransition
+    }
+  | {
+      readonly kind: 'refresh-callback-observer'
+      readonly driverId: number
+      readonly callbackRegistrationGeneration: number
+      readonly observerRevision: number
+    }
+  | {
+      readonly kind: 'request-callback-activation'
+      readonly driverId: number
+      readonly callbackRegistrationGeneration: number
+      readonly requestedAtTimestampMs: number
+      readonly requestedRunnerLeaseEpoch: number
+      readonly admissionToken: number
+      readonly absoluteDeadlineMs: number
+    }
+  | {
+      readonly kind: 'invoke-live-callback'
+      readonly driverId: number
+      readonly callbackRegistrationGeneration: number
+      readonly callbackLeaseEpoch: number
+      readonly frame: UiCoordinatorFrameInfo
+    }
+  | {
+      readonly kind: 'acknowledge-callback-admission'
+      readonly candidateDriverId: number
+      readonly callbackRegistrationGeneration: number
+      readonly requestedRunnerLeaseEpoch: number
+      readonly admissionToken: number
+    }
+  | {
+      readonly kind: 'runner-admission-timeout'
+      readonly candidateDriverId: number
+      readonly callbackRegistrationGeneration: number
+      readonly requestedRunnerLeaseEpoch: number
+      readonly admissionToken: number
+      readonly nowMs: number
+    }
+  | {
+      readonly kind: 'retire-callback'
+      readonly driverId: number
+      readonly callbackRegistrationGeneration: number
+    }
+  | {
+      readonly kind: 'dispose-callback'
+      readonly driverId: number
+      readonly callbackRegistrationGeneration: number
+    }
+
+export interface UiManualFrameCrossing {
+  readonly groupId: number
+  readonly absoluteTimestampMs: number
+  readonly orderedAttendeeDriverIds: readonly number[]
+  readonly callbackRegistrationGenerations: readonly number[]
+}
+
+export interface UiManualParticipantInvocation {
+  readonly groupId: number
+  readonly absoluteTimestampMs: number
+  readonly driverId: number
+  readonly callbackRegistrationGeneration: number
+  readonly invocationIndex: number
+}
+
+export interface UiManualParticipantRevocation {
+  readonly groupId: number
+  readonly absoluteTimestampMs: number
+  readonly driverId: number
+  readonly callbackRegistrationGeneration: number
+}
+
+export interface UiManualFrameCommitRequest {
+  readonly groupId: number
+  readonly absoluteTimestampMs: number
+}
+
+export interface UiLiveDestinationCommitSlot extends ImmutableDestinationCommit {
+  readonly commitSlotId: number
+  readonly acknowledgementSlotId: number
+}
+
+export interface UiLiveSiblingEmission {
+  readonly emissionSequence: number
+  readonly emissionKind: 'FRAME_WRITE' | 'LIFECYCLE' | 'TARGET_BATCH_DEPENDENCY' | 'HOST'
+}
+
+export type UiLiveDestinationEnvelopeEntry =
+  | {
+      readonly kind: 'DESTINATION_COMMIT_ACKNOWLEDGEMENT'
+      readonly acknowledgementSlotId: number
+      readonly drainedThroughAuthoritativeSequence: number
+    }
+  | ({ readonly kind: 'SIBLING_EMISSION' } & UiLiveSiblingEmission)
+
+export interface UiLiveDestinationEnvelopeState {
+  readonly mailboxDrainId: number
+  readonly state: 'OPEN' | 'SEALED'
+  readonly entries: readonly UiLiveDestinationEnvelopeEntry[]
+  readonly sealCount: number
+}
+
+export interface UiLiveDestinationCommitConsumeState {
+  readonly coordinator: UiValueChannelCoordinatorState
+  readonly envelope: UiLiveDestinationEnvelopeState
+}
+
+export interface UiLiveDestinationCommitConsumeRequest {
+  readonly driverId: number
+  readonly callbackRegistrationGeneration: number
+  readonly absoluteTimestampMs: number
+  readonly commit: UiLiveDestinationCommitSlot
+  readonly siblingEmissions: readonly UiLiveSiblingEmission[]
+}
+
+export type UiLiveDestinationCommitRefusalReason = UiDestinationCommitRefusalReason
+
+export type UiLiveDestinationCommitConsumeOutcome =
+  | {
+      readonly kind: 'APPLIED'
+      readonly commitSlotId: number
+      readonly acknowledgement: DestinationCommitAcknowledgement
+    }
+  | {
+      readonly kind: 'DUPLICATE_REACKNOWLEDGED'
+      readonly commitSlotId: number
+      readonly acknowledgement: DestinationCommitAcknowledgement
+    }
+  | {
+      readonly kind: 'REFUSED'
+      readonly commitSlotId: number
+      readonly reason: UiLiveDestinationCommitRefusalReason
+    }
+
+export type UiLiveDestinationCommitEffect =
+  | {
+      readonly kind: 'lookup-live-prepared-destination-record'
+      readonly destinationRecordId: number
+    }
+  | UiDestinationCommitCanonicalValidationEffect
+  | {
+      readonly kind: 'adopt-live-immutable-destination-commit'
+      readonly commitSlotId: number
+    }
+  | {
+      readonly kind: 'apply-live-included-post-fence-ledger-entry-in-place'
+      readonly commitSlotId: number
+      readonly prefixIndex: number
+      readonly destinationSlot: NormalizedRetainedWorkEntry['destinationSlot']
+      readonly entry: NormalizedRetainedWorkEntry
+    }
+  | {
+      readonly kind: 'fill-live-destination-acknowledgement-slot'
+      readonly commitSlotId: number
+      readonly acknowledgementSlotId: number
+    }
+  | {
+      readonly kind: 'stage-live-destination-acknowledgement-in-current-envelope'
+      readonly acknowledgementSlotId: number
+      readonly mailboxDrainId: number
+    }
+  | UiDestinationCommitRefusalReportEffect
+  | ({ readonly kind: 'emit-live-ui-sibling' } & UiLiveSiblingEmission)
+  | {
+      readonly kind: 'seal-live-ui-envelope-once'
+      readonly mailboxDrainId: number
+      readonly entryCount: number
+    }
+
+export interface UiLiveDestinationCommitTransition {
+  readonly state: UiLiveDestinationCommitConsumeState
+  readonly outcome: UiLiveDestinationCommitConsumeOutcome
+  readonly orderedEffects: readonly UiLiveDestinationCommitEffect[]
+}
+
+interface UiSharedManualIdentityTransferGapCommon {
+  readonly groupId: number
+  readonly channelId: number
+  readonly absoluteTimestampMs: number
+  readonly orderedAttendeeDriverIds: readonly [number, number]
+  readonly callbackRegistrationGenerations: readonly [number, number]
+  readonly transferLease: number
+  readonly sourceRecordId: number
+  readonly destinationRecordId: number
+}
+
+export type UiSharedManualIdentityTransferGapRequest =
+  | (UiSharedManualIdentityTransferGapCommon & {
+      readonly direction: 'UI_TO_JS'
+      readonly ownershipAtBegin: 'UI_RELEASE_PENDING_TO_JS'
+      readonly ownershipAtCommit: 'UI_RELEASED_TO_JS'
+    })
+  | (UiSharedManualIdentityTransferGapCommon & {
+      readonly direction: 'JS_TO_UI'
+      readonly ownershipAtBegin: 'JS_RELEASE_PENDING_TO_UI'
+      readonly ownershipAtCommit: 'JS_RELEASED_TO_UI'
+    })
+
+export type UiSharedManualIdentityTransferGapEffect =
+  | {
+      readonly kind: 'begin-shared-manual-transfer-transaction'
+      readonly groupId: number
+      readonly channelId: number
+      readonly absoluteTimestampMs: number
+      readonly orderedAttendeeDriverIds: readonly [number, number]
+      readonly callbackRegistrationGenerations: readonly [number, number]
+    }
+  | {
+      readonly kind: 'invoke-shared-manual-transfer-participant'
+      readonly groupId: number
+      readonly driverId: number
+      readonly callbackRegistrationGeneration: number
+      readonly invocationIndex: 0 | 1
+      readonly absoluteTimestampMs: number
+    }
+  | {
+      readonly kind: 'bridge-shared-identity-transfer-gap'
+      readonly channelId: number
+      readonly direction: 'UI_TO_JS' | 'JS_TO_UI'
+      readonly transferLease: number
+      readonly sourceRecordId: number
+      readonly destinationRecordId: number
+      readonly absoluteTimestampMs: number
+    }
+  | {
+      readonly kind: 'step-shared-manual-transfer-identity-once'
+      readonly channelId: number
+      readonly absoluteTimestampMs: number
+    }
+  | {
+      readonly kind: 'commit-shared-manual-transfer-transaction-once'
+      readonly groupId: number
+      readonly absoluteTimestampMs: number
+    }
+
+export interface UiSharedManualIdentityTransferGapTransition {
+  readonly state: UiValueChannelCoordinatorState
+  readonly observation: UiValueChannelObservation
+  readonly orderedEffects: readonly UiSharedManualIdentityTransferGapEffect[]
+}
+
+export interface ManualFrameGroupStepRequest {
+  readonly groupId: number
+  readonly elapsedMs: number
+  readonly invocationOrder?: readonly number[]
+}
+
+export interface LegacyManualDriverStepRequest {
+  readonly groupId: number
+  readonly driverId: number
+  readonly elapsedMs: number
+}
+
+export type UiValueChannelEffect =
+  | UiColdRelayEffect
+  | UiDestinationCommitCanonicalValidationEffect
+  | UiDestinationCommitRefusalReportEffect
+  | {
+      readonly kind: 'retain-stable-callback-registration'
+      readonly driverId: number
+      readonly callbackIdentityId: number
+      readonly callbackRegistrationGeneration: number
+    }
+  | {
+      readonly kind: 'defer-callback-admission-to-next-timestamp'
+      readonly driverId: number
+      readonly afterTimestampMs: number
+    }
+  | {
+      readonly kind: 'admit-callback-lease'
+      readonly driverId: number
+      readonly callbackLeaseEpoch: number
+      readonly absoluteTimestampMs: number
+    }
+  | {
+      readonly kind: 'publish-actual-callback-invocation-admission'
+      readonly driverId: number
+      readonly callbackRegistrationGeneration: number
+      readonly callbackLeaseEpoch: number
+    }
+  | {
+      readonly kind: 'start-runner-admission-timer'
+      readonly requestedRunnerLeaseEpoch: number
+      readonly candidateDriverId: number
+      readonly callbackRegistrationGeneration: number
+      readonly admissionToken: number
+      readonly absoluteDeadlineMs: number
+    }
+  | { readonly kind: 'cancel-runner-admission-timer'; readonly admissionToken: number }
+  | {
+      readonly kind: 'transfer-runner-lease-after-admission-acknowledgement'
+      readonly fromDriverId: number | null
+      readonly toDriverId: number
+      readonly runnerLeaseEpoch: number
+    }
+  | {
+      readonly kind: 'invalidate-runner-admission-candidate'
+      readonly driverId: number
+      readonly admissionToken: number
+    }
+  | {
+      readonly kind: 'select-next-live-runner-candidate'
+      readonly excludedDriverIds: readonly number[]
+      readonly selectedDriverId: number
+    }
+  | {
+      readonly kind: 'open-frame-transaction'
+      readonly mode: 'LIVE' | 'MANUAL'
+      readonly absoluteTimestampMs: number
+    }
+  | {
+      readonly kind: 'claim-cold-work-relay'
+      readonly relayId: number
+      readonly driverId: number
+    }
+  | {
+      readonly kind: 'peek-relayed-driver-state'
+      readonly relayId: number
+      readonly targetDriverId: number
+    }
+  | {
+      readonly kind: 'step-cold-work-relay'
+      readonly relayId: number
+      readonly targetDriverId: number
+      readonly absoluteTimestampMs: number
+    }
+  | {
+      readonly kind: 'form-cold-work-relay-value-bearing-mailbox-prefix'
+      readonly relayId: number
+      readonly canonicalRecord: UiColdRelayCanonicalRecord
+      readonly sourceEntry: UiColdWorkRelayValueBearingEntry
+      readonly openTurn: UiColdWorkRelayMailboxPrefix
+    }
+  | { readonly kind: 'retain-ongoing-relay-until-target-claim'; readonly relayId: number }
+  | { readonly kind: 'release-claimed-relay'; readonly relayId: number }
+  | {
+      readonly kind: 'step-shared-identity-once'
+      readonly channelId: number
+      readonly absoluteTimestampMs: number
+      readonly deltaMs: number
+    }
+  | { readonly kind: 'record-attendance'; readonly driverId: number }
+  | { readonly kind: 'record-synthetic-revocation-attendance'; readonly driverId: number }
+  | { readonly kind: 'retire-callback-effective-next-timestamp'; readonly driverId: number }
+  | { readonly kind: 'delete-disposed-callback-after-attendance'; readonly driverId: number }
+  | { readonly kind: 'commit-frame-once'; readonly absoluteTimestampMs: number }
+  | {
+      readonly kind: 'advance-manual-group-clock-once'
+      readonly groupId: number
+      readonly absoluteTimestampMs: number
+    }
+  | {
+      readonly kind: 'freeze-manual-attendee-batch'
+      readonly groupId: number
+      readonly orderedAttendeeDriverIds: readonly number[]
+    }
+  | {
+      readonly kind: 'arm-manual-group-for-destination-commit'
+      readonly groupId: number
+      readonly commitSlotId: number
+    }
+  | {
+      readonly kind: 'consume-manual-destination-commit-on-explicit-step'
+      readonly groupId: number
+      readonly commitSlotId: number
+    }
+  | {
+      readonly kind: 'lookup-prepared-destination-record'
+      readonly groupId: number
+      readonly destinationRecordId: number
+    }
+  | {
+      readonly kind: 'adopt-immutable-destination-commit'
+      readonly groupId: number
+      readonly commitSlotId: number
+    }
+  | {
+      readonly kind: 'apply-included-post-fence-ledger-entry-in-place'
+      readonly groupId: number
+      readonly commitSlotId: number
+      readonly prefixIndex: number
+      readonly destinationSlot: NormalizedRetainedWorkEntry['destinationSlot']
+      readonly entry: NormalizedRetainedWorkEntry
+    }
+  | {
+      readonly kind: 'fill-prefilled-destination-acknowledgement-slot'
+      readonly groupId: number
+      readonly commitSlotId: number
+      readonly acknowledgementSlotId: number
+    }
+  | {
+      readonly kind: 'stage-destination-acknowledgement-in-current-envelope'
+      readonly groupId: number
+      readonly acknowledgementSlotId: number
+      readonly mailboxDrainId: number
+    }
+  | {
+      readonly kind: 'delegate-legacy-step-to-private-single-member-group'
+      readonly groupId: number
+      readonly driverId: number
+    }
+  | { readonly kind: 'already-committed-no-op'; readonly absoluteTimestampMs: number }
+
+export type UiManualFrameRefusal =
+  | {
+      readonly kind: 'MISSING_ATTENDEES'
+      readonly missingDriverIds: readonly number[]
+    }
+  | {
+      readonly kind: 'LATE_ATTENDANCE'
+      readonly driverId: number
+      readonly alreadyCommittedTimestampMs: number
+    }
+  | {
+      readonly kind: 'MULTI_MEMBER_GROUP_REQUIRES_GROUP_STEP'
+      readonly groupId: number
+      readonly participantCount: number
+    }
+  | {
+      readonly kind: 'DESTINATION_COMMIT_REFUSED'
+      readonly groupId: number
+      readonly commitSlotId: number
+      readonly authority: UiPreparedDestinationRecordState | null
+      readonly reason: UiDestinationCommitRefusalReason
+    }
+
+export interface UiValueChannelTransition {
+  readonly state: UiValueChannelCoordinatorState
+  readonly observation: UiValueChannelObservation
+  readonly orderedEffects: readonly UiValueChannelEffect[]
+  readonly refusal: UiManualFrameRefusal | null
+}
+
+export type UiPrivateTargetBatchDependencyEventKind =
+  | 'RAW_RESOLVED'
+  | 'VALUE_ACKNOWLEDGED'
+  | 'PERMANENTLY_UNRESOLVED'
+
+/**
+ * UI-owned private controls never borrow a public MotionValue identity outbox. The owning adapter
+ * keeps the primitive sequence needed to prefill one dependency event into the transaction that is
+ * already open for the live or manual frame root.
+ */
+export interface UiPrivateTargetBatchAdapterState {
+  readonly controlId: number
+  readonly batchId: number
+  readonly dependencyId: number
+  readonly nextDependencyEventSequence: number
+  readonly stagedDependencyEventCount: number
+}
+
+export interface UiPrivateTargetBatchDependencyEventRequest {
+  readonly controlId: number
+  readonly batchId: number
+  readonly dependencyId: number
+  readonly kind: UiPrivateTargetBatchDependencyEventKind
+}
+
+export interface UiPrefilledPrivateTargetBatchDependencyEvent {
+  readonly kind: 'TARGET_BATCH_DEPENDENCY_EVENT'
+  readonly batchId: number
+  readonly dependencyId: number
+  readonly dependencyEventKind: UiPrivateTargetBatchDependencyEventKind
+  readonly eventSequence: number
+  readonly ownerControlId: number
+}
+
+export type UiPrivateTargetBatchDependencyEventEffect =
+  | {
+      readonly kind: 'PREFILL_PRIVATE_TARGET_BATCH_DEPENDENCY_EVENT'
+      readonly transactionMode: 'LIVE' | 'MANUAL'
+      readonly event: UiPrefilledPrivateTargetBatchDependencyEvent
+    }
+  | {
+      readonly kind: 'ADVANCE_PRIVATE_TARGET_BATCH_EVENT_SEQUENCE'
+      readonly controlId: number
+      readonly eventSequence: number
+    }
+
+export interface UiPrivateTargetBatchDependencyEventTransition {
+  readonly adapter: UiPrivateTargetBatchAdapterState
+  readonly orderedEffects: readonly UiPrivateTargetBatchDependencyEventEffect[]
+}
+
+export type UiRunnerAdmissionCandidateKind =
+  | 'RUNNER_CANDIDATE'
+  | 'ADMITTED'
+  | 'EXPIRED'
+  | 'DISPOSED'
+
+export interface UiRunnerAdmissionCandidateState {
+  readonly driverId: number
+  readonly callbackRegistrationGeneration: number
+  readonly callbackLeaseEpoch: number
+  readonly requestedAtTimestampMs: number
+  readonly absoluteAdmissionDeadlineMs: number
+  readonly state: UiRunnerAdmissionCandidateKind
+  readonly invocationObserved: boolean
+}
+
+export interface UiRunnerRetainedPassiveSinkState {
+  readonly sinkId: number
+  readonly driverId: number
+  readonly handleId: number
+  readonly bindingGeneration: number
+  readonly key: string
+}
+
+export interface UiRunnerInstalledPreArmControlSlotState {
+  readonly controlId: number
+  readonly executionId: number
+}
+
+export interface UiRunnerRetainedCarrierReferenceState {
+  readonly batchId: number
+  readonly carrierId: number
+  readonly identityId: number
+  readonly authoredIndex: number
+}
+
+export interface UiRunnerRetainedChannelState {
+  readonly channelId: number
+  readonly passiveSinks: readonly UiRunnerRetainedPassiveSinkState[]
+  readonly installedPreArmControlSlot: UiRunnerInstalledPreArmControlSlotState | null
+  readonly physicalExecutions: readonly Extract<
+    NormalizedRetainedWorkEntry,
+    { readonly kind: 'generator-execution' }
+  >[]
+  readonly dueWork: readonly Extract<
+    NormalizedRetainedWorkEntry,
+    { readonly kind: 'update-task' | 'carrier-task' | 'direct-write' }
+  >[]
+  readonly valueCompletions: readonly Extract<
+    NormalizedRetainedWorkEntry,
+    { readonly kind: 'value-completion' }
+  >[]
+  readonly batchDependencyEvents: readonly Extract<
+    NormalizedRetainedWorkEntry,
+    { readonly kind: 'target-batch-dependency-event' }
+  >[]
+  readonly carrierReferences: readonly UiRunnerRetainedCarrierReferenceState[]
+}
+
+export interface UiRunnerRetainedWorkRuntime {
+  reportFinalRunnerTimeoutRefusal(channelIds: readonly number[]): void
+  stopInstalledPreArmSlot(channelId: number, slot: UiRunnerInstalledPreArmControlSlotState): void
+  transferRetainedChannelWork(channel: UiRunnerRetainedChannelState): void
+}
+
+export interface UiRunnerAdmissionState {
+  readonly runnerDriverId: number | null
+  readonly runnerLeaseEpoch: number
+  readonly candidates: readonly UiRunnerAdmissionCandidateState[]
+  readonly retainedChannels: readonly UiRunnerRetainedChannelState[]
+  readonly timeoutRefusalCount: number
+  readonly retainedWorkTransferRequestCount: number
+}
+
+export type UiRunnerAdmissionEvent =
+  | {
+      readonly kind: 'runner-candidate-timeout'
+      readonly driverId: number
+      readonly callbackRegistrationGeneration: number
+      readonly callbackLeaseEpoch: number
+      readonly observedAtTimestampMs: number
+    }
+  | {
+      readonly kind: 'invoke-runner-candidate'
+      readonly driverId: number
+      readonly callbackRegistrationGeneration: number
+      readonly callbackLeaseEpoch: number
+      readonly observedAtTimestampMs: number
+    }
+  | {
+      readonly kind: 'dispose-runner-candidate'
+      readonly driverId: number
+      readonly callbackRegistrationGeneration: number
+      readonly callbackLeaseEpoch: number
+    }
+
+export type UiRunnerAdmissionEffect =
+  | { readonly kind: 'EXPIRE_RUNNER_CANDIDATE'; readonly driverId: number }
+  | { readonly kind: 'DISPOSE_RUNNER_CANDIDATE'; readonly driverId: number }
+  | {
+      readonly kind: 'SELECT_SUCCESSOR_RUNNER_CANDIDATE'
+      readonly driverId: number
+      readonly callbackLeaseEpoch: number
+    }
+  | {
+      readonly kind: 'ADMIT_INVOKED_RUNNER_CANDIDATE'
+      readonly driverId: number
+      readonly callbackLeaseEpoch: number
+    }
+  | { readonly kind: 'IGNORE_STALE_RUNNER_EVENT'; readonly driverId: number }
+  | {
+      readonly kind: 'REPORT_FINAL_RUNNER_TIMEOUT_REFUSAL'
+      readonly channelIds: readonly number[]
+    }
+  | {
+      readonly kind: 'STOP_INSTALLED_PRE_ARM_SLOT_ONLY'
+      readonly channelId: number
+      readonly slot: UiRunnerInstalledPreArmControlSlotState
+    }
+  | {
+      readonly kind: 'TRANSFER_RETAINED_CHANNEL_WORK'
+      readonly channel: UiRunnerRetainedChannelState
+    }
+
+export interface UiRunnerAdmissionTransition {
+  readonly state: UiRunnerAdmissionState
+  readonly orderedEffects: readonly UiRunnerAdmissionEffect[]
+}
+
+export interface UiRecursionExecutionSeed {
+  readonly executionId: number
+  readonly targetValue: number
+  readonly firstSampleValue: number
+  readonly commandSequence: number
+  readonly completionSequence: number
+}
+
+export type UiRecursionExecutionPhase = 'RUNNING' | 'STOPPED' | 'COMPLETED'
+
+export interface UiRecursionExecutionState extends UiRecursionExecutionSeed {
+  readonly updateSequence: number
+  readonly stopCount: number
+  readonly phase: UiRecursionExecutionPhase
+  readonly orphaned: boolean
+}
+
+export interface UiQueuedInstantCompletionRecursionEntry {
+  readonly completionId: number
+  readonly completionSequence: number
+  readonly callbackSuccessor: UiRecursionExecutionSeed
+}
+
+export interface UiGuardedCancelListenerState {
+  readonly listenerId: number
+  readonly hasStartedSuccessor: boolean
+  readonly successor: UiRecursionExecutionSeed
+}
+
+/**
+ * Primitive-only UI-channel state for the pin's synchronous listener-recursion seam. No callback,
+ * host object, MotionValue, generator, or promise crosses this reducer boundary.
+ */
+export interface UiValueChannelRecursionState {
+  readonly channelId: number
+  readonly currentValue: number
+  readonly publicControlSlotExecutionId: number | null
+  readonly executions: readonly UiRecursionExecutionState[]
+  readonly queuedInstantCompletions: readonly UiQueuedInstantCompletionRecursionEntry[]
+  readonly guardedCancelListeners: readonly UiGuardedCancelListenerState[]
+  readonly nextUpdateSequence: number
+}
+
+export type UiValueChannelRecursionEvent =
+  | { readonly kind: 'drain-queued-instant-completions' }
+  | { readonly kind: 'apply-recursive-outer-stop' }
+  | { readonly kind: 'apply-recursive-outer-jump'; readonly value: number }
+  | {
+      readonly kind: 'apply-recursive-interrupting-start'
+      readonly successor: UiRecursionExecutionSeed
+    }
+  | {
+      readonly kind: 'sample-runnable-recursion-executions'
+      readonly absoluteTimestampMs: number
+    }
+  | {
+      readonly kind: 'install-recursion-successor'
+      readonly successor: UiRecursionExecutionSeed
+    }
+  | {
+      readonly kind: 'complete-recursion-execution'
+      readonly executionId: number
+      readonly completionSequence: number
+    }
+
+export type UiValueChannelRecursionEffect =
+  | {
+      readonly kind: 'DELIVER_QUEUED_INSTANT_COMPLETION'
+      readonly completionId: number
+      readonly completionSequence: number
+    }
+  | {
+      readonly kind: 'DELIVER_GUARDED_CANCEL_LISTENER'
+      readonly listenerId: number
+      readonly cancelDeliveryOrdinal: number
+    }
+  | {
+      readonly kind: 'ISSUE_REENTRANT_START_COMMAND'
+      readonly executionId: number
+      readonly commandSequence: number
+      readonly source: 'INSTANT_COMPLETION' | 'GUARDED_CANCEL_LISTENER'
+      readonly sourceId: number
+    }
+  | {
+      readonly kind: 'STOP_EXECUTION_IDEMPOTENT'
+      readonly executionId: number
+      readonly stopOrdinal: number
+      readonly source: 'OUTER_OPERATION' | 'REENTRANT_START'
+    }
+  | {
+      readonly kind: 'INSTALL_RECURSION_EXECUTION'
+      readonly executionId: number
+      readonly commandSequence: number
+      readonly updateSequence: number
+      readonly role:
+        | 'COMPLETION_SUCCESSOR'
+        | 'CANCEL_LISTENER_SUCCESSOR'
+        | 'INTERRUPTING_SUCCESSOR'
+        | 'LATER_LIVE_SUCCESSOR'
+    }
+  | {
+      readonly kind: 'CLEAR_PUBLIC_CONTROL_SLOT_TOKEN_BLIND'
+      readonly source: 'INSTANT_COMPLETION' | 'STOP_CONTINUATION' | 'VALUE_COMPLETION'
+      readonly sourceId: number
+      readonly clearedExecutionId: number | null
+    }
+  | { readonly kind: 'APPLY_OUTER_JUMP'; readonly value: number }
+  | {
+      readonly kind: 'SAMPLE_RECURSION_EXECUTION'
+      readonly executionId: number
+      readonly updateSequence: number
+      readonly value: number
+      readonly absoluteTimestampMs: number
+      readonly orphaned: boolean
+    }
+  | {
+      readonly kind: 'COMPLETE_RECURSION_EXECUTION'
+      readonly executionId: number
+      readonly completionSequence: number
+    }
+
+export interface UiValueChannelRecursionTransition {
+  readonly state: UiValueChannelRecursionState
+  readonly orderedEffects: readonly UiValueChannelRecursionEffect[]
+}
+
+export type UiValueChannelOperation =
+  | UiCoordinatorEvent['kind']
+  | 'ui-begin-manual-frame'
+  | 'ui-invoke-manual-participant'
+  | 'ui-revoke-manual-participant'
+  | 'ui-commit-manual-frame'
+  | 'arm-manual-destination-commit'
+  | 'step-manual-frame-group'
+  | 'consume-live-ui-destination-commit'
+  | 'produce-cold-relay-command-from-canonical-state'
+  | 'validate-ui-destination-commit-with-canonical-authority'
+  | 'observe-cold-relay-canonical-record'
+  | 'step-shared-manual-identity-transfer-gap'
+  | 'fanout-ui-owned-identity-sample'
+  | 'step-legacy-manual-driver'
+  | 'stage-private-target-batch-dependency-event'
+  | UiRunnerAdmissionEvent['kind']
+  | UiValueChannelRecursionEvent['kind']
+
+export const UI_VALUE_CHANNEL_UNIMPLEMENTED =
+  'NATIVE_MOTION_UI_VALUE_CHANNEL_UNIMPLEMENTED' as const
+
+export class UiValueChannelUnimplementedError extends Error {
+  readonly code = UI_VALUE_CHANNEL_UNIMPLEMENTED
+  readonly operation: UiValueChannelOperation
+
+  constructor(operation: UiValueChannelOperation) {
+    super(
+      `native-motion: UI value-channel operation '${operation}' is unimplemented ` +
+        '(REQ-DRIVER-034)',
+    )
+    this.name = 'UiValueChannelUnimplementedError'
+    this.operation = operation
+  }
+}
+
+export function observeUiValueChannel(
+  state: UiValueChannelCoordinatorState,
+): UiValueChannelObservation {
+  let totalIdentityStepCount = 0
+  let totalHostCommitCount = 0
+  for (const identity of state.identities) {
+    totalIdentityStepCount += identity.stepCount
+    totalHostCommitCount += identity.hostCommitCount
+  }
+
+  let unclaimedRelayCount = 0
+  for (const relay of state.relays) {
+    if (relay.claimedAtTimestampMs === null) unclaimedRelayCount += 1
+  }
+
+  const admittedDriverIds: number[] = []
+  for (const callback of state.callbacks) {
+    if (callback.state === 'ADMITTED') admittedDriverIds.push(callback.driverId)
+  }
+
+  const armedManualGroupIds: number[] = []
+  let pendingManualDestinationCommitCount = 0
+  for (const group of state.manualGroups) {
+    if (group.armedForExplicitStep) armedManualGroupIds.push(group.groupId)
+    pendingManualDestinationCommitCount += group.pendingDestinationCommits.length
+  }
+
+  const transaction = state.transaction
+  return {
+    runnerDriverId: state.runnerDriverId,
+    runnerLeaseEpoch: state.runnerLeaseEpoch,
+    callbackCount: state.callbacks.length,
+    callbackIdentityIds: state.callbacks.map((callback) => callback.callbackIdentityId),
+    callbackRegistrationGenerations: state.callbacks.map(
+      (callback) => callback.callbackRegistrationGeneration,
+    ),
+    admittedDriverIds,
+    relayCount: state.relays.length,
+    unclaimedRelayCount,
+    identityCount: state.identities.length,
+    totalIdentityStepCount,
+    totalHostCommitCount,
+    transactionKind: transaction.kind,
+    openTimestampMs: transaction.kind === 'OPEN' ? transaction.absoluteTimestampMs : null,
+    expectedAttendeeCount:
+      transaction.kind === 'OPEN' ? transaction.expectedAttendeeDriverIds.length : 0,
+    visitedAttendeeCount:
+      transaction.kind === 'OPEN' ? transaction.visitedAttendeeDriverIds.length : 0,
+    revokedAttendeeCount:
+      transaction.kind === 'OPEN' ? transaction.revokedAttendeeDriverIds.length : 0,
+    lastCommittedTimestampMs: transaction.lastCommittedTimestampMs,
+    committedFrameCount: transaction.committedFrameCount,
+    manualGroupCount: state.manualGroups.length,
+    armedManualGroupIds,
+    pendingManualDestinationCommitCount,
+  }
+}
+
+export const UI_VALUE_CHANNEL_INVARIANT = 'NATIVE_MOTION_UI_VALUE_CHANNEL_INVARIANT' as const
+
+export type UiValueChannelInvariant =
+  | 'coordinator-event-kind-unrecognized'
+  | 'runner-admission-event-kind-unrecognized'
+  | 'recursion-event-kind-unrecognized'
+  | 'cold-relay-command-kind-unrecognized'
+  | 'cold-relay-source-record-missing'
+  | 'cold-relay-mailbox-record-missing'
+  | 'cold-relay-host-sink-missing'
+  | 'cold-relay-target-callback-missing'
+  | 'cold-relay-canonical-record-unknown'
+  | 'callback-registration-missing'
+  | 'callback-registration-conflict'
+  | 'runner-admission-request-conflict'
+  | 'manual-frame-group-missing'
+  | 'frame-transaction-conflict'
+  | 'frame-attendance-conflict'
+  | 'owned-identity-channel-conflict'
+  | 'private-target-batch-adapter-conflict'
+  | 'private-target-batch-transaction-closed'
+  | 'shared-transfer-identity-missing'
+
+/** Typed fail-closed refusal for malformed, conflicting, or out-of-sequence UI-channel input. */
+export class UiValueChannelInvariantError extends Error {
+  readonly code = UI_VALUE_CHANNEL_INVARIANT
+  readonly invariant: UiValueChannelInvariant
+  readonly operation: UiValueChannelOperation | null
+
+  constructor(invariant: UiValueChannelInvariant, operation?: UiValueChannelOperation) {
+    super(
+      `native-motion: UI value-channel invariant '${invariant}' was violated` +
+        (operation === undefined ? '' : ` by operation '${operation}'`) +
+        ' (REQ-DRIVER-034)',
+    )
+    this.name = 'UiValueChannelInvariantError'
+    this.invariant = invariant
+    this.operation = operation ?? null
+  }
+}
+
+/** Bounded window a runner candidate has to produce its first actual invocation (two frames). */
+const UI_RUNNER_ADMISSION_WINDOW_MS = 32
+
+// ——— Canonical cold-relay record store ———
+// The canonical record is a frozen brand-only handle; its fill state lives in this coordinator-
+// private store so the frozen record can be observed before and after its single command-edge
+// fill without ever being mutated itself.
+
+interface UiColdRelayCanonicalRecordEntry {
+  readonly recordId: number
+  readonly authority: UiColdRelayCommandAuthority
+  fillState: 'EMPTY' | 'FILLED_FROM_LIVE_RECORDS'
+  sourceRecords: UiColdRelaySourceRecords | null
+  deliverySlots: UiColdRelayDeliverySlots | null
+}
+
+const uiColdRelayCanonicalRecordIds = new WeakMap<UiColdRelayCanonicalRecord, number>()
+const uiColdRelayCanonicalRecordEntries = new Map<number, UiColdRelayCanonicalRecordEntry>()
+let nextUiColdRelayCanonicalRecordId = 1
+
+function requireCanonicalRecordEntry(
+  record: UiColdRelayCanonicalRecord,
+  operation: UiValueChannelOperation,
+): UiColdRelayCanonicalRecordEntry {
+  const recordId = uiColdRelayCanonicalRecordIds.get(record)
+  const entry = recordId === undefined ? undefined : uiColdRelayCanonicalRecordEntries.get(recordId)
+  if (recordId === undefined || entry === undefined) {
+    throw new UiValueChannelInvariantError('cold-relay-canonical-record-unknown', operation)
+  }
+  return entry
+}
+
+function allocateCanonicalRecord(
+  authority: UiColdRelayCommandAuthority,
+): UiColdRelayCanonicalRecord {
+  const record = Object.freeze({}) as UiColdRelayCanonicalRecord
+  const recordId = nextUiColdRelayCanonicalRecordId
+  nextUiColdRelayCanonicalRecordId += 1
+  uiColdRelayCanonicalRecordIds.set(record, recordId)
+  uiColdRelayCanonicalRecordEntries.set(recordId, {
+    recordId,
+    authority,
+    fillState: 'EMPTY',
+    sourceRecords: null,
+    deliverySlots: null,
+  })
+  return record
+}
+
+export function observeUiColdRelayCanonicalRecord(
+  record: UiColdRelayCanonicalRecord,
+): UiColdRelayCanonicalRecordObservation {
+  const entry = requireCanonicalRecordEntry(record, 'observe-cold-relay-canonical-record')
+  if (entry.fillState === 'EMPTY') {
+    return Object.freeze({
+      recordId: entry.recordId,
+      authority: entry.authority,
+      fillState: 'EMPTY',
+      sourceRecords: null,
+      deliverySlots: null,
+    }) as UiColdRelayCanonicalRecordObservation
+  }
+  const sourceRecords = entry.sourceRecords
+  const deliverySlots = entry.deliverySlots
+  if (sourceRecords === null || deliverySlots === null) {
+    throw new UiValueChannelInvariantError(
+      'cold-relay-canonical-record-unknown',
+      'observe-cold-relay-canonical-record',
+    )
+  }
+  return Object.freeze({
+    recordId: entry.recordId,
+    authority: entry.authority,
+    fillState: 'FILLED_FROM_LIVE_RECORDS',
+    sourceRecords,
+    deliverySlots,
+  }) as UiColdRelayCanonicalRecordObservation
+}
+
+// ——— Cold-relay command production from canonical coordinator records ———
+
+function requireMailboxRecord(
+  state: UiValueChannelCoordinatorState,
+  mailboxDrainId: number,
+): UiMailboxTurnRecord {
+  const record = state.mailboxTurns.find((candidate) => candidate.mailboxDrainId === mailboxDrainId)
+  if (record === undefined) {
+    throw new UiValueChannelInvariantError(
+      'cold-relay-mailbox-record-missing',
+      'produce-cold-relay-command-from-canonical-state',
+    )
+  }
+  return record
+}
+
+function requireHostSinkRecords(
+  state: UiValueChannelCoordinatorState,
+  hostSinkRecordIds: readonly number[],
+): readonly [UiHostSinkRecord] {
+  const records = hostSinkRecordIds.map((hostSinkRecordId) => {
+    const record = state.hostSinks.find(
+      (candidate) => candidate.hostSinkRecordId === hostSinkRecordId,
+    )
+    if (record === undefined) {
+      throw new UiValueChannelInvariantError(
+        'cold-relay-host-sink-missing',
+        'produce-cold-relay-command-from-canonical-state',
+      )
+    }
+    return record
+  })
+  const first = records[0]
+  if (first === undefined || records.length !== 1) {
+    throw new UiValueChannelInvariantError(
+      'cold-relay-host-sink-missing',
+      'produce-cold-relay-command-from-canonical-state',
+    )
+  }
+  return [first]
+}
+
+/** The relay target is the one registered callback that has not yet been admitted to a frame. */
+function requireColdTargetCallback(
+  state: UiValueChannelCoordinatorState,
+): UiCallbackRegistrationState {
+  const target = state.callbacks.find(
+    (candidate) =>
+      candidate.state === 'REGISTERED_INACTIVE' ||
+      candidate.state === 'ACTIVATION_REQUESTED' ||
+      candidate.state === 'RUNNER_CANDIDATE',
+  )
+  if (target === undefined) {
+    throw new UiValueChannelInvariantError(
+      'cold-relay-target-callback-missing',
+      'produce-cold-relay-command-from-canonical-state',
+    )
+  }
+  return target
+}
+
+function missingColdRelaySourceRecord(): never {
+  throw new UiValueChannelInvariantError(
+    'cold-relay-source-record-missing',
+    'produce-cold-relay-command-from-canonical-state',
+  )
+}
+
+export function produceUiColdRelayCommandFromCanonicalState(
+  state: UiValueChannelCoordinatorState,
+  request: UiColdRelayCommandProductionRequest,
+): UiColdRelayCommandProductionTransition {
+  switch (request.kind) {
+    case 'START_PUBLIC_IDENTITY_EXECUTION': {
+      const primaryRecord = state.generatorExecutions.find(
+        (
+          candidate,
+        ): candidate is Extract<
+          UiGeneratorExecutionRecord,
+          { readonly workClass: 'channel-ordinary-first-sample' }
+        > =>
+          candidate.workClass === 'channel-ordinary-first-sample' &&
+          candidate.owner.kind === 'PUBLIC_IDENTITY' &&
+          candidate.owner.channelId === request.channelId &&
+          candidate.entry.executionId === request.executionId,
+      )
+      if (primaryRecord === undefined) return missingColdRelaySourceRecord()
+      const commandAuthority: UiColdRelayCommandAuthority = {
+        workClass: 'channel-ordinary-first-sample',
+        destinationRecordId: request.destinationRecordId,
+        owner: { kind: 'PUBLIC_IDENTITY', channelId: request.channelId },
+        executionId: request.executionId,
+      }
+      const sourceRecords = Object.freeze({
+        [uiColdRelaySourceRecordsBrand]: true as const,
+        workClass: 'channel-ordinary-first-sample' as const,
+        primaryRecord,
+        callbackRegistrations: [requireColdTargetCallback(state)] as const,
+        mailboxRecord: requireMailboxRecord(state, primaryRecord.mailboxDrainId),
+        hostSinkRecords: requireHostSinkRecords(state, primaryRecord.hostSinkRecordIds),
+      })
+      return {
+        [uiColdRelayProducerReceiptBrand]: true,
+        state,
+        commandAuthority,
+        sourceRecords,
+      }
+    }
+    case 'START_PRIVATE_CONTROL_EXECUTION': {
+      const primaryRecord = state.generatorExecutions.find(
+        (
+          candidate,
+        ): candidate is Extract<
+          UiGeneratorExecutionRecord,
+          { readonly workClass: 'private-ordinary-first-sample' }
+        > =>
+          candidate.workClass === 'private-ordinary-first-sample' &&
+          candidate.owner.kind === 'PRIVATE_CONTROL' &&
+          candidate.owner.controlId === request.controlId &&
+          candidate.entry.executionId === request.executionId,
+      )
+      if (primaryRecord === undefined) return missingColdRelaySourceRecord()
+      const commandAuthority: UiColdRelayCommandAuthority = {
+        workClass: 'private-ordinary-first-sample',
+        destinationRecordId: request.destinationRecordId,
+        owner: { kind: 'PRIVATE_CONTROL', controlId: request.controlId },
+        executionId: request.executionId,
+      }
+      const sourceRecords = Object.freeze({
+        [uiColdRelaySourceRecordsBrand]: true as const,
+        workClass: 'private-ordinary-first-sample' as const,
+        primaryRecord,
+        callbackRegistrations: [] as const,
+        mailboxRecord: requireMailboxRecord(state, primaryRecord.mailboxDrainId),
+        hostSinkRecords: requireHostSinkRecords(state, primaryRecord.hostSinkRecordIds),
+      })
+      return {
+        [uiColdRelayProducerReceiptBrand]: true,
+        state,
+        commandAuthority,
+        sourceRecords,
+      }
+    }
+    case 'QUEUE_INSTANT_TARGET': {
+      const primaryRecord = state.dueWorkTasks.find(
+        (
+          candidate,
+        ): candidate is Extract<UiDueWorkTaskRecord, { readonly workClass: 'instant-target' }> =>
+          candidate.workClass === 'instant-target' &&
+          candidate.entry.taskId === request.taskId &&
+          candidate.entry.taskSequence === request.taskSequence,
+      )
+      if (primaryRecord === undefined) return missingColdRelaySourceRecord()
+      const commandAuthority: UiColdRelayCommandAuthority = {
+        workClass: 'instant-target',
+        destinationRecordId: request.destinationRecordId,
+        taskId: request.taskId,
+        taskSequence: request.taskSequence,
+      }
+      const sourceRecords = Object.freeze({
+        [uiColdRelaySourceRecordsBrand]: true as const,
+        workClass: 'instant-target' as const,
+        primaryRecord,
+        callbackRegistrations: [requireColdTargetCallback(state)] as const,
+        mailboxRecord: requireMailboxRecord(state, primaryRecord.mailboxDrainId),
+        hostSinkRecords: requireHostSinkRecords(state, primaryRecord.hostSinkRecordIds),
+      })
+      return {
+        [uiColdRelayProducerReceiptBrand]: true,
+        state,
+        commandAuthority,
+        sourceRecords,
+      }
+    }
+    case 'QUEUE_EQUAL_TARGET_REASSERTION': {
+      const primaryRecord = state.dueWorkTasks.find(
+        (
+          candidate,
+        ): candidate is Extract<
+          UiDueWorkTaskRecord,
+          { readonly workClass: 'equal-target-reassertion' }
+        > =>
+          candidate.workClass === 'equal-target-reassertion' &&
+          candidate.entry.taskId === request.taskId &&
+          candidate.entry.taskSequence === request.taskSequence,
+      )
+      if (primaryRecord === undefined) return missingColdRelaySourceRecord()
+      const commandAuthority: UiColdRelayCommandAuthority = {
+        workClass: 'equal-target-reassertion',
+        destinationRecordId: request.destinationRecordId,
+        taskId: request.taskId,
+        taskSequence: request.taskSequence,
+      }
+      const sourceRecords = Object.freeze({
+        [uiColdRelaySourceRecordsBrand]: true as const,
+        workClass: 'equal-target-reassertion' as const,
+        primaryRecord,
+        callbackRegistrations: [requireColdTargetCallback(state)] as const,
+        mailboxRecord: requireMailboxRecord(state, primaryRecord.mailboxDrainId),
+        hostSinkRecords: requireHostSinkRecords(state, primaryRecord.hostSinkRecordIds),
+      })
+      return {
+        [uiColdRelayProducerReceiptBrand]: true,
+        state,
+        commandAuthority,
+        sourceRecords,
+      }
+    }
+    case 'QUEUE_IDLE_WRITE': {
+      const primaryRecord = state.dueWorkTasks.find(
+        (
+          candidate,
+        ): candidate is Extract<UiDueWorkTaskRecord, { readonly workClass: 'idle-write' }> =>
+          candidate.workClass === 'idle-write' &&
+          candidate.entry.taskId === request.taskId &&
+          candidate.entry.taskSequence === request.taskSequence,
+      )
+      if (primaryRecord === undefined) return missingColdRelaySourceRecord()
+      const commandAuthority: UiColdRelayCommandAuthority = {
+        workClass: 'idle-write',
+        destinationRecordId: request.destinationRecordId,
+        taskId: request.taskId,
+        taskSequence: request.taskSequence,
+      }
+      const sourceRecords = Object.freeze({
+        [uiColdRelaySourceRecordsBrand]: true as const,
+        workClass: 'idle-write' as const,
+        primaryRecord,
+        callbackRegistrations: [] as const,
+        mailboxRecord: requireMailboxRecord(state, primaryRecord.mailboxDrainId),
+        hostSinkRecords: requireHostSinkRecords(state, primaryRecord.hostSinkRecordIds),
+      })
+      return {
+        [uiColdRelayProducerReceiptBrand]: true,
+        state,
+        commandAuthority,
+        sourceRecords,
+      }
+    }
+    case 'ARM_INSTANT_COMPLETION': {
+      const primaryRecord = state.valueCompletionControllers.find(
+        (candidate) =>
+          candidate.completionControllerId === request.completionControllerId &&
+          candidate.entry.completionSequence === request.completionSequence,
+      )
+      if (primaryRecord === undefined) return missingColdRelaySourceRecord()
+      const commandAuthority: UiColdRelayCommandAuthority = {
+        workClass: 'instant-completion',
+        destinationRecordId: request.destinationRecordId,
+        completionSequence: request.completionSequence,
+        completionControllerId: request.completionControllerId,
+      }
+      const sourceRecords = Object.freeze({
+        [uiColdRelaySourceRecordsBrand]: true as const,
+        workClass: 'instant-completion' as const,
+        primaryRecord,
+        callbackRegistrations: [requireColdTargetCallback(state)] as const,
+        mailboxRecord: requireMailboxRecord(state, primaryRecord.mailboxDrainId),
+        hostSinkRecords: [] as const,
+      })
+      return {
+        [uiColdRelayProducerReceiptBrand]: true,
+        state,
+        commandAuthority,
+        sourceRecords,
+      }
+    }
+    case 'APPLY_DIRECT_WRITE': {
+      const primaryRecord = state.directOperations.find(
+        (candidate) =>
+          candidate.directOperationId === request.directOperationId &&
+          candidate.directOperationEpoch === request.directOperationEpoch,
+      )
+      if (primaryRecord === undefined) return missingColdRelaySourceRecord()
+      const commandAuthority: UiColdRelayCommandAuthority = {
+        workClass: 'direct-write',
+        destinationRecordId: request.destinationRecordId,
+        directOperationId: request.directOperationId,
+        directOperationEpoch: request.directOperationEpoch,
+      }
+      const sourceRecords = Object.freeze({
+        [uiColdRelaySourceRecordsBrand]: true as const,
+        workClass: 'direct-write' as const,
+        primaryRecord,
+        callbackRegistrations: [] as const,
+        mailboxRecord: requireMailboxRecord(state, primaryRecord.mailboxDrainId),
+        hostSinkRecords: requireHostSinkRecords(state, primaryRecord.hostSinkRecordIds),
+      })
+      return {
+        [uiColdRelayProducerReceiptBrand]: true,
+        state,
+        commandAuthority,
+        sourceRecords,
+      }
+    }
+    case 'QUEUE_TRANSITION_END_CARRIER': {
+      const primaryRecord = state.carrierControllers.find(
+        (
+          candidate,
+        ): candidate is Extract<
+          UiCarrierControllerRecord,
+          { readonly workClass: 'transition-end-carrier' }
+        > =>
+          candidate.workClass === 'transition-end-carrier' &&
+          candidate.carrierControllerId === request.carrierControllerId &&
+          candidate.entry.taskId === request.taskId,
+      )
+      if (primaryRecord === undefined) return missingColdRelaySourceRecord()
+      const commandAuthority: UiColdRelayCommandAuthority = {
+        workClass: 'transition-end-carrier',
+        destinationRecordId: request.destinationRecordId,
+        carrierControllerId: request.carrierControllerId,
+        taskId: request.taskId,
+      }
+      const sourceRecords = Object.freeze({
+        [uiColdRelaySourceRecordsBrand]: true as const,
+        workClass: 'transition-end-carrier' as const,
+        primaryRecord,
+        callbackRegistrations: [] as const,
+        mailboxRecord: requireMailboxRecord(state, primaryRecord.mailboxDrainId),
+        hostSinkRecords: requireHostSinkRecords(state, primaryRecord.hostSinkRecordIds),
+      })
+      return {
+        [uiColdRelayProducerReceiptBrand]: true,
+        state,
+        commandAuthority,
+        sourceRecords,
+      }
+    }
+    case 'QUEUE_EXIT_CARRIER': {
+      const primaryRecord = state.carrierControllers.find(
+        (
+          candidate,
+        ): candidate is Extract<
+          UiCarrierControllerRecord,
+          { readonly workClass: 'exit-carrier' }
+        > =>
+          candidate.workClass === 'exit-carrier' &&
+          candidate.carrierControllerId === request.carrierControllerId &&
+          candidate.entry.taskId === request.taskId,
+      )
+      if (primaryRecord === undefined) return missingColdRelaySourceRecord()
+      const commandAuthority: UiColdRelayCommandAuthority = {
+        workClass: 'exit-carrier',
+        destinationRecordId: request.destinationRecordId,
+        carrierControllerId: request.carrierControllerId,
+        taskId: request.taskId,
+      }
+      const sourceRecords = Object.freeze({
+        [uiColdRelaySourceRecordsBrand]: true as const,
+        workClass: 'exit-carrier' as const,
+        primaryRecord,
+        callbackRegistrations: [] as const,
+        mailboxRecord: requireMailboxRecord(state, primaryRecord.mailboxDrainId),
+        hostSinkRecords: requireHostSinkRecords(state, primaryRecord.hostSinkRecordIds),
+      })
+      return {
+        [uiColdRelayProducerReceiptBrand]: true,
+        state,
+        commandAuthority,
+        sourceRecords,
+      }
+    }
+    case 'QUEUE_PACKET_B_CARRIER': {
+      const primaryRecord = state.carrierControllers.find(
+        (
+          candidate,
+        ): candidate is Extract<
+          UiCarrierControllerRecord,
+          { readonly workClass: 'packet-b-carrier' }
+        > =>
+          candidate.workClass === 'packet-b-carrier' &&
+          candidate.carrierControllerId === request.carrierControllerId &&
+          candidate.entry.taskId === request.taskId,
+      )
+      if (primaryRecord === undefined) return missingColdRelaySourceRecord()
+      const commandAuthority: UiColdRelayCommandAuthority = {
+        workClass: 'packet-b-carrier',
+        destinationRecordId: request.destinationRecordId,
+        carrierControllerId: request.carrierControllerId,
+        taskId: request.taskId,
+      }
+      const sourceRecords = Object.freeze({
+        [uiColdRelaySourceRecordsBrand]: true as const,
+        workClass: 'packet-b-carrier' as const,
+        primaryRecord,
+        callbackRegistrations: [] as const,
+        mailboxRecord: requireMailboxRecord(state, primaryRecord.mailboxDrainId),
+        hostSinkRecords: requireHostSinkRecords(state, primaryRecord.hostSinkRecordIds),
+      })
+      return {
+        [uiColdRelayProducerReceiptBrand]: true,
+        state,
+        commandAuthority,
+        sourceRecords,
+      }
+    }
+    default: {
+      const exhaustive: never = request
+      void exhaustive
+      throw new UiValueChannelInvariantError('cold-relay-command-kind-unrecognized')
+    }
+  }
+}
+
+// ——— Shared UI destination COMMIT canonical validator ———
+
+export function validateUiDestinationCommitWithCanonicalAuthority(
+  request: UiDestinationCommitCanonicalValidationRequest,
+): UiDestinationCommitCanonicalValidationOutcome {
+  const { commit, preparedDestinationRecords } = request
+  // The runtime keys prepared records by its own destination record id; a commit naming an
+  // unknown destination id for a known channel still resolves the channel's authority so the
+  // exact mismatched tuple field is diagnosed instead of a bare missing record.
+  const record =
+    preparedDestinationRecords.find(
+      (candidate) => candidate.destinationRecordId === commit.destinationRecordId,
+    ) ?? preparedDestinationRecords.find((candidate) => candidate.channelId === commit.channelId)
+  if (record === undefined) {
+    return { kind: 'REFUSED', authority: null, reason: 'missing-prepared-destination-record' }
+  }
+  const reason = validateUiCommitAgainstPreparedRecord(record, commit)
+  if (reason !== null) {
+    return { kind: 'REFUSED', authority: record, reason }
+  }
+  return { kind: 'VALID', authority: record }
+}
+
+function validateUiCommitAgainstPreparedRecord(
+  record: UiPreparedDestinationRecordState,
+  commit: ImmutableDestinationCommit,
+): UiDestinationCommitCanonicalRefusalReason | null {
+  if (commit.channelId !== record.channelId) return 'wrong-channel'
+  if (commit.sourceRecordId !== record.sourceRecordId) return 'wrong-source-record'
+  if (commit.destinationRecordId !== record.destinationRecordId) return 'wrong-destination-record'
+  // The UI destination root only ever consumes JS→UI commits; a self-consistent UI→JS authority
+  // is as refused here as a tuple mismatch.
+  if (commit.direction !== record.direction || commit.direction !== 'JS_TO_UI') {
+    return 'wrong-direction'
+  }
+  if (commit.transferLease !== record.transferLease) return 'wrong-transfer-lease'
+  if (commit.releaseFenceSequence !== record.releaseFenceSequence) return 'wrong-release-fence'
+  if (
+    commit.includedPostFencePrefix.some(
+      (entry) => entry.authoritativeSequence > commit.sentThroughAuthoritativeSequence,
+    )
+  ) {
+    return 'ahead-of-sent-watermark'
+  }
+  if (commit.sentThroughAuthoritativeSequence < record.appliedThroughAuthoritativeSequence) {
+    return 'sent-watermark-regressed'
+  }
+  const newEntries = commit.includedPostFencePrefix.filter(
+    (entry) => entry.authoritativeSequence > record.appliedThroughAuthoritativeSequence,
+  )
+  for (let index = 0; index < newEntries.length; index += 1) {
+    const entry = newEntries[index]
+    if (entry === undefined) break
+    if (entry.authoritativeSequence !== record.appliedThroughAuthoritativeSequence + index + 1) {
+      return 'prefix-not-contiguous'
+    }
+  }
+  return null
+}
+
+export const uiDestinationCommitCanonicalValidator: UiDestinationCommitCanonicalValidatorCapability =
+  Object.freeze({
+    [uiDestinationCommitCanonicalValidatorCapabilityBrand]: true as const,
+    validate: validateUiDestinationCommitWithCanonicalAuthority,
+  })
+
+// ——— Destination ledger application (in-place at the commit consumption edge) ———
+
+function createUiLedgerSlot(
+  entry: NormalizedRetainedWorkEntry,
+): ValueHandoffDestinationLedgerState['slots'][number] {
+  return {
+    ...entry.destinationSlot,
+    entries: [entry],
+  } as ValueHandoffDestinationLedgerState['slots'][number]
+}
+
+function appendUiLedgerEntry(
+  slot: ValueHandoffDestinationLedgerState['slots'][number],
+  entry: NormalizedRetainedWorkEntry,
+): ValueHandoffDestinationLedgerState['slots'][number] {
+  if (slot.ledger !== entry.destinationSlot.ledger) return slot
+  return {
+    ...slot,
+    entries: [...slot.entries, entry],
+  } as ValueHandoffDestinationLedgerState['slots'][number]
+}
+
+function applyEntriesToUiLedgers(
+  ledgers: ValueHandoffDestinationLedgerState,
+  entries: readonly NormalizedRetainedWorkEntry[],
+): ValueHandoffDestinationLedgerState {
+  let slots = ledgers.slots
+  for (const entry of entries) {
+    const index = slots.findIndex(
+      (slot) =>
+        slot.ledger === entry.destinationSlot.ledger &&
+        slot.slotId === entry.destinationSlot.slotId,
+    )
+    if (index < 0) {
+      slots = [...slots, createUiLedgerSlot(entry)]
+      continue
+    }
+    const slot = slots[index]
+    if (slot === undefined) continue
+    slots = [...slots.slice(0, index), appendUiLedgerEntry(slot, entry), ...slots.slice(index + 1)]
+  }
+  return { slots }
+}
+
+// ——— Coordinator transition helpers ———
+
+function uiTransition(
+  state: UiValueChannelCoordinatorState,
+  orderedEffects: readonly UiValueChannelEffect[],
+  refusal: UiManualFrameRefusal | null = null,
+): UiValueChannelTransition {
+  return { state, observation: observeUiValueChannel(state), orderedEffects, refusal }
+}
+
+function requireCallback(
+  state: UiValueChannelCoordinatorState,
+  driverId: number,
+  operation: UiValueChannelOperation,
+): UiCallbackRegistrationState {
+  const callback = state.callbacks.find((candidate) => candidate.driverId === driverId)
+  if (callback === undefined) {
+    throw new UiValueChannelInvariantError('callback-registration-missing', operation)
+  }
+  return callback
+}
+
+function replaceCallback(
+  state: UiValueChannelCoordinatorState,
+  replacement: UiCallbackRegistrationState,
+): UiValueChannelCoordinatorState {
+  return {
+    ...state,
+    callbacks: state.callbacks.map((candidate) =>
+      candidate.driverId === replacement.driverId ? replacement : candidate,
+    ),
+  }
+}
+
+function requireManualGroup(
+  state: UiValueChannelCoordinatorState,
+  groupId: number,
+  operation: UiValueChannelOperation,
+): ManualFrameGroupState {
+  const group = state.manualGroups.find((candidate) => candidate.groupId === groupId)
+  if (group === undefined) {
+    throw new UiValueChannelInvariantError('manual-frame-group-missing', operation)
+  }
+  return group
+}
+
+function replaceManualGroup(
+  state: UiValueChannelCoordinatorState,
+  replacement: ManualFrameGroupState,
+): UiValueChannelCoordinatorState {
+  return {
+    ...state,
+    manualGroups: state.manualGroups.map((candidate) =>
+      candidate.groupId === replacement.groupId ? replacement : candidate,
+    ),
+  }
+}
+
+// ——— Frame transaction stepping ———
+
+function stepIdentitiesOnce(
+  state: UiValueChannelCoordinatorState,
+  absoluteTimestampMs: number,
+  effects: UiValueChannelEffect[],
+): UiValueChannelCoordinatorState {
+  const steppedChannelIds: number[] = []
+  const identities = state.identities.map((identity) => {
+    steppedChannelIds.push(identity.channelId)
+    const deltaMs =
+      identity.lastAbsoluteTimestampMs === null
+        ? 0
+        : absoluteTimestampMs - identity.lastAbsoluteTimestampMs
+    effects.push({
+      kind: 'step-shared-identity-once',
+      channelId: identity.channelId,
+      absoluteTimestampMs,
+      deltaMs,
+    })
+    return {
+      ...identity,
+      lastAbsoluteTimestampMs: absoluteTimestampMs,
+      stepCount: identity.stepCount + 1,
+    }
+  })
+  const transaction = state.transaction
+  if (transaction.kind !== 'OPEN') {
+    throw new UiValueChannelInvariantError('frame-transaction-conflict', 'invoke-live-callback')
+  }
+  return {
+    ...state,
+    identities,
+    transaction: { ...transaction, steppedChannelIds },
+  }
+}
+
+function recordFrameAttendance(
+  state: UiValueChannelCoordinatorState,
+  driverId: number,
+  effects: UiValueChannelEffect[],
+): UiValueChannelCoordinatorState {
+  const transaction = state.transaction
+  if (transaction.kind !== 'OPEN') {
+    throw new UiValueChannelInvariantError('frame-transaction-conflict', 'invoke-live-callback')
+  }
+  effects.push({ kind: 'record-attendance', driverId })
+  let next: UiValueChannelCoordinatorState = {
+    ...state,
+    transaction: {
+      ...transaction,
+      visitedAttendeeDriverIds: [...transaction.visitedAttendeeDriverIds, driverId],
+    },
+    callbacks: state.callbacks.map((candidate) =>
+      candidate.driverId === driverId
+        ? { ...candidate, lastInvocationTimestampMs: transaction.absoluteTimestampMs }
+        : candidate,
+    ),
+  }
+  if (transaction.steppedChannelIds.length === 0) {
+    next = stepIdentitiesOnce(next, transaction.absoluteTimestampMs, effects)
+  }
+  return next
+}
+
+function commitFrameIfAttendanceComplete(
+  state: UiValueChannelCoordinatorState,
+  effects: UiValueChannelEffect[],
+): UiValueChannelCoordinatorState {
+  const transaction = state.transaction
+  if (transaction.kind !== 'OPEN') return state
+  const complete = transaction.expectedAttendeeDriverIds.every(
+    (driverId) =>
+      transaction.visitedAttendeeDriverIds.includes(driverId) ||
+      transaction.revokedAttendeeDriverIds.includes(driverId),
+  )
+  if (!complete) return state
+  effects.push({
+    kind: 'commit-frame-once',
+    absoluteTimestampMs: transaction.absoluteTimestampMs,
+  })
+  return {
+    ...state,
+    identities: state.identities.map((identity) => ({
+      ...identity,
+      hostCommitCount: identity.hostCommitCount + 1,
+    })),
+    transaction: {
+      kind: 'CLOSED',
+      lastCommittedTimestampMs: transaction.absoluteTimestampMs,
+      committedFrameCount: transaction.committedFrameCount + 1,
+    },
+  }
+}
+
+// ——— Cold-work relay stepping ———
+
+function freezeSlotArrayInPlace<Slot>(slots: readonly Slot[]): readonly Slot[] {
+  return Object.freeze(slots)
+}
+
+function buildDeliverySlots(sourceRecords: UiColdRelaySourceRecords): UiColdRelayDeliverySlots {
+  const envelope = sourceRecords.mailboxRecord.envelope
+  const hostSlots = Object.freeze(
+    sourceRecords.hostSinkRecords.map((record) => record.slot),
+  ) as readonly [UiColdRelayHostCommitResultSlot]
+  switch (sourceRecords.workClass) {
+    case 'channel-ordinary-first-sample':
+    case 'private-ordinary-first-sample': {
+      const primary = sourceRecords.primaryRecord
+      return Object.freeze({
+        workClass: sourceRecords.workClass,
+        envelope,
+        writeSlots: Object.freeze([primary.writeSlot] as const),
+        callbackSlots: freezeSlotArrayInPlace(primary.callbackSlots),
+        carrierSlots: Object.freeze([] as const),
+        hostSlots,
+      }) as UiColdRelayDeliverySlots
+    }
+    case 'instant-target':
+    case 'equal-target-reassertion':
+    case 'idle-write': {
+      const primary = sourceRecords.primaryRecord
+      // The preallocated task callback buffer is compacted in place at this single command-edge
+      // fill: instant/equal deliveries keep only the tokenless transition-on-update slots (the
+      // animation-complete delivery belongs to the value-completion controller), while an idle
+      // direct write delivers no task callbacks at all.
+      const callbackSlots = primary.callbackSlots as Extract<
+        UiColdRelayCallbackResultSlot,
+        { readonly kind: 'TASK_CALLBACK' }
+      >[]
+      let retainedCount = 0
+      if (sourceRecords.workClass !== 'idle-write') {
+        for (const slot of callbackSlots) {
+          if (slot.callback.callbackKind !== 'transition-on-update') continue
+          callbackSlots[retainedCount] = slot
+          retainedCount += 1
+        }
+      }
+      callbackSlots.length = retainedCount
+      return Object.freeze({
+        workClass: sourceRecords.workClass,
+        envelope,
+        writeSlots: Object.freeze([primary.writeSlot] as const),
+        callbackSlots: Object.freeze(callbackSlots),
+        carrierSlots: Object.freeze([] as const),
+        hostSlots,
+      }) as UiColdRelayDeliverySlots
+    }
+    case 'instant-completion': {
+      const primary = sourceRecords.primaryRecord
+      return Object.freeze({
+        workClass: 'instant-completion' as const,
+        envelope,
+        writeSlots: Object.freeze([] as const),
+        callbackSlots: Object.freeze([primary.callbackSlot] as const),
+        carrierSlots: Object.freeze([] as const),
+        hostSlots: Object.freeze([] as const),
+      }) as UiColdRelayDeliverySlots
+    }
+    case 'direct-write': {
+      const primary = sourceRecords.primaryRecord
+      return Object.freeze({
+        workClass: 'direct-write' as const,
+        envelope,
+        writeSlots: Object.freeze([primary.writeSlot] as const),
+        callbackSlots: Object.freeze([] as const),
+        carrierSlots: Object.freeze([] as const),
+        hostSlots,
+      }) as UiColdRelayDeliverySlots
+    }
+    case 'transition-end-carrier':
+    case 'exit-carrier':
+    case 'packet-b-carrier': {
+      const primary = sourceRecords.primaryRecord
+      return Object.freeze({
+        workClass: sourceRecords.workClass,
+        envelope,
+        writeSlots: Object.freeze([] as const),
+        callbackSlots: Object.freeze([] as const),
+        carrierSlots: Object.freeze([primary.carrierSlot] as const),
+        hostSlots,
+      }) as UiColdRelayDeliverySlots
+    }
+    default: {
+      const exhaustive: never = sourceRecords
+      void exhaustive
+      throw new UiValueChannelInvariantError('cold-relay-command-kind-unrecognized')
+    }
+  }
+}
+
+interface UiRelayStepResult {
+  readonly state: UiValueChannelCoordinatorState
+  readonly relay: UiColdWorkRelayState
+}
+
+/** Fill and apply the canonical record exactly once, forming the value-bearing prefix with it. */
+function fillAndApplyCanonicalRelayRecord(
+  state: UiValueChannelCoordinatorState,
+  relay: UiColdWorkRelayState,
+  effects: UiValueChannelEffect[],
+): UiRelayStepResult {
+  const entry = requireCanonicalRecordEntry(relay.canonicalRecord, 'invoke-live-callback')
+  let nextRelay = relay
+  if (entry.fillState === 'EMPTY') {
+    const sourceRecords = relay.commandReceipt.sourceRecords
+    entry.sourceRecords = sourceRecords
+    entry.deliverySlots = buildDeliverySlots(sourceRecords)
+    entry.fillState = 'FILLED_FROM_LIVE_RECORDS'
+    effects.push({
+      kind: 'fill-canonical-cold-relay-record-from-live-records',
+      relayId: relay.relayId,
+      canonicalRecord: relay.canonicalRecord,
+      sourceRecords,
+    })
+    effects.push({
+      kind: 'apply-canonical-cold-relay-record',
+      relayId: relay.relayId,
+      targetDriverId: relay.targetDriverId,
+      canonicalRecord: relay.canonicalRecord,
+    })
+    const primaryRecord = sourceRecords.primaryRecord
+    if (sourceRecords.workClass === 'channel-ordinary-first-sample') {
+      const valueBearingEntry = (
+        primaryRecord as Extract<
+          UiGeneratorExecutionRecord,
+          { readonly workClass: 'channel-ordinary-first-sample' }
+        >
+      ).valueBearingEntry
+      nextRelay = { ...nextRelay, pendingValueBearingEntry: valueBearingEntry }
+      const mailboxDrainId = state.nextMailboxDrainId
+      const valueWriteEntry = Object.freeze({
+        kind: 'VALUE_WRITE' as const,
+        entryId: valueBearingEntry.valueWriteEntryId,
+        index: 0,
+        channelId: valueBearingEntry.channelId,
+        sample: Object.freeze({
+          kind: 'generator-sample' as const,
+          origin: 'ui-frame' as const,
+          channelId: valueBearingEntry.channelId,
+          authoritativeSequence: valueBearingEntry.authoritativeSequence,
+          executionId: valueBearingEntry.executionId,
+          directOperationEpoch: valueBearingEntry.directOperationEpoch,
+          executionLease: valueBearingEntry.executionLease,
+          writeSequence: valueBearingEntry.writeSequence,
+          history: valueBearingEntry.candidateHistory,
+          completion: valueBearingEntry.completion,
+        }),
+      })
+      const transitionCallbackEntry = Object.freeze({
+        kind: 'TRANSITION_CALLBACK' as const,
+        entryId: valueBearingEntry.transitionCallbackEntryId,
+        index: 1,
+        channelId: valueBearingEntry.channelId,
+        callbackId: valueBearingEntry.transitionCallbackId,
+        event: Object.freeze({
+          kind: 'transition-on-update' as const,
+          channelId: valueBearingEntry.channelId,
+          executionId: valueBearingEntry.executionId,
+          directOperationEpoch: valueBearingEntry.directOperationEpoch,
+          executionLease: valueBearingEntry.executionLease,
+          writeSequence: valueBearingEntry.writeSequence,
+          eventSequence: valueBearingEntry.eventSequence,
+          history: valueBearingEntry.candidateHistory,
+        }),
+      })
+      const openTurn = Object.freeze({
+        mailboxOrigin: 'UI' as const,
+        mailboxDrainId,
+        stagedEntries: Object.freeze([valueWriteEntry, transitionCallbackEntry] as const),
+        sealed: false as const,
+      })
+      effects.push({
+        kind: 'form-cold-work-relay-value-bearing-mailbox-prefix',
+        relayId: relay.relayId,
+        canonicalRecord: relay.canonicalRecord,
+        sourceEntry: valueBearingEntry,
+        openTurn,
+      })
+      nextRelay = {
+        ...nextRelay,
+        pendingValueBearingEntry: null,
+        stagedValueBearingPrefix: {
+          mailboxDrainId,
+          valueWriteEntryId: valueBearingEntry.valueWriteEntryId,
+          transitionCallbackEntryId: valueBearingEntry.transitionCallbackEntryId,
+          transitionCallbackId: valueBearingEntry.transitionCallbackId,
+          authoritativeSequence: valueBearingEntry.authoritativeSequence,
+          writeSequence: valueBearingEntry.writeSequence,
+          eventSequence: valueBearingEntry.eventSequence,
+        },
+      }
+    }
+  }
+  return { state, relay: nextRelay }
+}
+
+function retainRelay(
+  state: UiValueChannelCoordinatorState,
+  relay: UiColdWorkRelayState,
+): UiValueChannelCoordinatorState {
+  return {
+    ...state,
+    relays: state.relays.map((candidate) =>
+      candidate.relayId === relay.relayId ? relay : candidate,
+    ),
+  }
+}
+
+/** A relay is claimable by its target while armed, or while an ongoing execution awaits claim. */
+function relayClaimableByTarget(relay: UiColdWorkRelayState): boolean {
+  if (relay.leaseState === 'ARMED') return true
+  return relay.leaseState === 'RELAYED_BY_INCUMBENT' && relay.lifetime === 'ONGOING_EXECUTION'
+}
+
+/** A relay is steppable by an admitted incumbent while armed or while it retains an ongoing one. */
+function relaySteppableByIncumbent(relay: UiColdWorkRelayState): boolean {
+  if (relay.leaseState === 'ARMED') return true
+  return relay.leaseState === 'RELAYED_BY_INCUMBENT' && relay.lifetime === 'ONGOING_EXECUTION'
+}
+
+function claimColdWorkRelay(
+  state: UiValueChannelCoordinatorState,
+  relay: UiColdWorkRelayState,
+  driverId: number,
+  absoluteTimestampMs: number,
+  effects: UiValueChannelEffect[],
+): UiValueChannelCoordinatorState {
+  effects.push({ kind: 'claim-cold-work-relay', relayId: relay.relayId, driverId })
+  let next: UiValueChannelCoordinatorState = state
+  let stepped = relay
+  if (relay.leaseState === 'ARMED') {
+    effects.push({
+      kind: 'step-cold-work-relay',
+      relayId: relay.relayId,
+      targetDriverId: relay.targetDriverId,
+      absoluteTimestampMs,
+    })
+    const result = fillAndApplyCanonicalRelayRecord(next, relay, effects)
+    next = result.state
+    stepped = result.relay
+  }
+  const claimed: UiColdWorkRelayState = {
+    ...stepped,
+    leaseState: relay.lifetime === 'ONGOING_EXECUTION' ? 'RELEASED' : 'CLAIMED_BY_TARGET',
+    claimedAtTimestampMs: absoluteTimestampMs,
+    claimedByDriverId: driverId,
+    lastRelayedStepTimestampMs:
+      relay.leaseState === 'ARMED' ? absoluteTimestampMs : relay.lastRelayedStepTimestampMs,
+  }
+  if (relay.lifetime === 'ONGOING_EXECUTION') {
+    effects.push({ kind: 'release-claimed-relay', relayId: relay.relayId })
+  }
+  return retainRelay(next, claimed)
+}
+
+function stepColdWorkRelayAsIncumbent(
+  state: UiValueChannelCoordinatorState,
+  relay: UiColdWorkRelayState,
+  absoluteTimestampMs: number,
+  effects: UiValueChannelEffect[],
+): UiValueChannelCoordinatorState {
+  effects.push({
+    kind: 'peek-relayed-driver-state',
+    relayId: relay.relayId,
+    targetDriverId: relay.targetDriverId,
+  })
+  effects.push({
+    kind: 'step-cold-work-relay',
+    relayId: relay.relayId,
+    targetDriverId: relay.targetDriverId,
+    absoluteTimestampMs,
+  })
+  const result = fillAndApplyCanonicalRelayRecord(state, relay, effects)
+  if (relay.lifetime === 'ONGOING_EXECUTION') {
+    effects.push({ kind: 'retain-ongoing-relay-until-target-claim', relayId: relay.relayId })
+  }
+  return retainRelay(result.state, {
+    ...result.relay,
+    leaseState: 'RELAYED_BY_INCUMBENT',
+    lastRelayedStepTimestampMs: absoluteTimestampMs,
+  })
+}
+
+// ——— Live callback invocation ———
+
+function invokeLiveCallback(
+  state: UiValueChannelCoordinatorState,
+  event: Extract<UiCoordinatorEvent, { readonly kind: 'invoke-live-callback' }>,
+): UiValueChannelTransition {
+  const operation: UiValueChannelOperation = 'invoke-live-callback'
+  const callback = requireCallback(state, event.driverId, operation)
+  if (
+    callback.callbackRegistrationGeneration !== event.callbackRegistrationGeneration ||
+    callback.callbackLeaseEpoch !== event.callbackLeaseEpoch
+  ) {
+    throw new UiValueChannelInvariantError('callback-registration-conflict', operation)
+  }
+  if (callback.state === 'RETIRING' || callback.state === 'REVOKED') {
+    throw new UiValueChannelInvariantError('callback-registration-conflict', operation)
+  }
+  const absoluteTimestampMs = event.frame.timestamp
+  const effects: UiValueChannelEffect[] = []
+  let next = state
+
+  // A pending runner candidate publishes admission only on its first actual invocation; the
+  // runner lease itself transfers only after the later acknowledgement.
+  const admissionRequest = next.runnerAdmissionRequest
+  if (
+    admissionRequest !== null &&
+    admissionRequest.candidateDriverId === event.driverId &&
+    admissionRequest.callbackRegistrationGeneration === event.callbackRegistrationGeneration &&
+    !admissionRequest.actualInvocationObserved
+  ) {
+    effects.push({
+      kind: 'publish-actual-callback-invocation-admission',
+      driverId: event.driverId,
+      callbackRegistrationGeneration: event.callbackRegistrationGeneration,
+      callbackLeaseEpoch: event.callbackLeaseEpoch,
+    })
+    next = {
+      ...next,
+      runnerAdmissionRequest: { ...admissionRequest, actualInvocationObserved: true },
+    }
+  }
+
+  const transaction = next.transaction
+  if (transaction.kind === 'OPEN') {
+    if (transaction.absoluteTimestampMs !== absoluteTimestampMs) {
+      throw new UiValueChannelInvariantError('frame-transaction-conflict', operation)
+    }
+    if (
+      transaction.visitedAttendeeDriverIds.includes(event.driverId) ||
+      transaction.revokedAttendeeDriverIds.includes(event.driverId)
+    ) {
+      throw new UiValueChannelInvariantError('frame-attendance-conflict', operation)
+    }
+    next = recordFrameAttendance(next, event.driverId, effects)
+    next = commitFrameIfAttendanceComplete(next, effects)
+    return uiTransition(next, effects)
+  }
+
+  const lastCommittedTimestampMs = transaction.lastCommittedTimestampMs
+  if (lastCommittedTimestampMs !== null && absoluteTimestampMs <= lastCommittedTimestampMs) {
+    if (callback.state === 'ADMITTED') {
+      effects.push({ kind: 'already-committed-no-op', absoluteTimestampMs })
+    } else {
+      effects.push({
+        kind: 'defer-callback-admission-to-next-timestamp',
+        driverId: event.driverId,
+        afterTimestampMs: absoluteTimestampMs,
+      })
+    }
+    return uiTransition(next, effects)
+  }
+
+  // A cold target claims its own relay at a timestamp that is not already committed and performs
+  // the relayed command-edge work in this same invocation.
+  for (const relay of next.relays) {
+    if (relay.targetDriverId !== event.driverId || !relayClaimableByTarget(relay)) continue
+    next = claimColdWorkRelay(next, relay, event.driverId, absoluteTimestampMs, effects)
+  }
+
+  let admittedCallback = callback
+  if (callback.state !== 'ADMITTED') {
+    effects.push({
+      kind: 'admit-callback-lease',
+      driverId: event.driverId,
+      callbackLeaseEpoch: event.callbackLeaseEpoch,
+      absoluteTimestampMs,
+    })
+    admittedCallback = {
+      ...callback,
+      state: 'ADMITTED',
+      admittedFromTimestampMs: absoluteTimestampMs,
+      reanimatedCallbackActive: true,
+    }
+    next = replaceCallback(next, admittedCallback)
+  }
+
+  // The attendee batch freezes when the transaction opens: admitted, active callbacks that have
+  // already produced an invocation (plus the invoking driver itself).
+  const expectedAttendeeDriverIds = next.callbacks
+    .filter(
+      (candidate) =>
+        candidate.state === 'ADMITTED' &&
+        candidate.reanimatedCallbackActive &&
+        (candidate.lastInvocationTimestampMs !== null || candidate.driverId === event.driverId),
+    )
+    .map((candidate) => candidate.driverId)
+  next = {
+    ...next,
+    transaction: {
+      kind: 'OPEN',
+      mode: 'LIVE',
+      absoluteTimestampMs,
+      mailboxDrainId: next.nextMailboxDrainId,
+      expectedAttendeeDriverIds,
+      visitedAttendeeDriverIds: [],
+      revokedAttendeeDriverIds: [],
+      steppedChannelIds: [],
+      frozenInvocationOrder: expectedAttendeeDriverIds,
+      lastCommittedTimestampMs,
+      committedFrameCount: transaction.committedFrameCount,
+    },
+  }
+
+  // An admitted incumbent relays every armed/ongoing cold relay targeted at other drivers before
+  // its own attendance and commit, so no pinned next-update task waits an extra frame.
+  for (const relay of next.relays) {
+    if (relay.targetDriverId === event.driverId || !relaySteppableByIncumbent(relay)) continue
+    next = stepColdWorkRelayAsIncumbent(next, relay, absoluteTimestampMs, effects)
+  }
+
+  next = recordFrameAttendance(next, event.driverId, effects)
+  next = commitFrameIfAttendanceComplete(next, effects)
+  return uiTransition(next, effects)
+}
+
+// ——— Coordinator reducer ———
+
+export function advanceUiCoordinator(
+  state: UiValueChannelCoordinatorState,
+  event: UiCoordinatorEvent,
+  activators: UiRetainedFrameCallbackActivatorRegistry,
+): UiValueChannelTransition {
+  switch (event.kind) {
+    case 'arm-cold-work-relay-at-command-edge': {
+      const canonicalRecord = allocateCanonicalRecord(event.commandReceipt.commandAuthority)
+      activators.setActive(event.targetDriverId, event.targetCallbackRegistrationGeneration, true)
+      const relay: UiColdWorkRelayState = {
+        relayId: event.relayId,
+        targetDriverId: event.targetDriverId,
+        commandReceipt: event.commandReceipt,
+        canonicalRecord,
+        commandSequence: event.commandSequence,
+        targetCallbackRegistrationGeneration: event.targetCallbackRegistrationGeneration,
+        relayLeaseEpoch: event.relayLeaseEpoch,
+        leaseState: 'ARMED',
+        lifetime: event.lifetime,
+        armedAtTimestampMs: event.armedAtTimestampMs,
+        lastRelayedStepTimestampMs: null,
+        claimedAtTimestampMs: null,
+        claimedByDriverId: null,
+        pendingValueBearingEntry: null,
+        stagedValueBearingPrefix: null,
+      }
+      return uiTransition({ ...state, relays: [...state.relays, relay] }, [
+        {
+          kind: 'allocate-empty-canonical-cold-relay-record',
+          relayId: event.relayId,
+          canonicalRecord,
+        },
+        {
+          kind: 'arm-cold-relay-lease-at-command-edge',
+          relayId: event.relayId,
+          targetDriverId: event.targetDriverId,
+          targetCallbackRegistrationGeneration: event.targetCallbackRegistrationGeneration,
+          relayLeaseEpoch: event.relayLeaseEpoch,
+          commandReceipt: event.commandReceipt,
+          canonicalRecord,
+        },
+        {
+          kind: 'activate-cold-relay-target-after-command-arm',
+          relayId: event.relayId,
+          targetDriverId: event.targetDriverId,
+          targetCallbackRegistrationGeneration: event.targetCallbackRegistrationGeneration,
+        },
+      ])
+    }
+    case 'refresh-callback-observer': {
+      const callback = requireCallback(state, event.driverId, event.kind)
+      if (callback.callbackRegistrationGeneration !== event.callbackRegistrationGeneration) {
+        throw new UiValueChannelInvariantError('callback-registration-conflict', event.kind)
+      }
+      const refreshed: UiCallbackRegistrationState = {
+        ...callback,
+        observerRevision: event.observerRevision,
+      }
+      return uiTransition(replaceCallback(state, refreshed), [
+        {
+          kind: 'retain-stable-callback-registration',
+          driverId: event.driverId,
+          callbackIdentityId: callback.callbackIdentityId,
+          callbackRegistrationGeneration: event.callbackRegistrationGeneration,
+        },
+      ])
+    }
+    case 'request-callback-activation': {
+      const callback = requireCallback(state, event.driverId, event.kind)
+      if (callback.callbackRegistrationGeneration !== event.callbackRegistrationGeneration) {
+        throw new UiValueChannelInvariantError('callback-registration-conflict', event.kind)
+      }
+      activators.setActive(event.driverId, event.callbackRegistrationGeneration, true)
+      const requested: UiCallbackRegistrationState = {
+        ...callback,
+        state: 'ACTIVATION_REQUESTED',
+        reanimatedCallbackActive: true,
+      }
+      const next: UiValueChannelCoordinatorState = {
+        ...replaceCallback(state, requested),
+        runnerAdmissionRequest: {
+          requestedRunnerLeaseEpoch: event.requestedRunnerLeaseEpoch,
+          candidateDriverId: event.driverId,
+          callbackRegistrationGeneration: event.callbackRegistrationGeneration,
+          admissionToken: event.admissionToken,
+          absoluteDeadlineMs: event.absoluteDeadlineMs,
+          actualInvocationObserved: false,
+        },
+        nextRunnerAdmissionToken: Math.max(
+          state.nextRunnerAdmissionToken,
+          event.admissionToken + 1,
+        ),
+      }
+      return uiTransition(next, [
+        {
+          kind: 'start-runner-admission-timer',
+          requestedRunnerLeaseEpoch: event.requestedRunnerLeaseEpoch,
+          candidateDriverId: event.driverId,
+          callbackRegistrationGeneration: event.callbackRegistrationGeneration,
+          admissionToken: event.admissionToken,
+          absoluteDeadlineMs: event.absoluteDeadlineMs,
+        },
+      ])
+    }
+    case 'invoke-live-callback':
+      return invokeLiveCallback(state, event)
+    case 'acknowledge-callback-admission': {
+      const request = state.runnerAdmissionRequest
+      if (
+        request === null ||
+        request.admissionToken !== event.admissionToken ||
+        request.candidateDriverId !== event.candidateDriverId ||
+        request.callbackRegistrationGeneration !== event.callbackRegistrationGeneration ||
+        request.requestedRunnerLeaseEpoch !== event.requestedRunnerLeaseEpoch ||
+        !request.actualInvocationObserved
+      ) {
+        throw new UiValueChannelInvariantError('runner-admission-request-conflict', event.kind)
+      }
+      const effects: UiValueChannelEffect[] = [
+        { kind: 'cancel-runner-admission-timer', admissionToken: event.admissionToken },
+        {
+          kind: 'transfer-runner-lease-after-admission-acknowledgement',
+          fromDriverId: state.runnerDriverId,
+          toDriverId: event.candidateDriverId,
+          runnerLeaseEpoch: request.requestedRunnerLeaseEpoch,
+        },
+      ]
+      let callbacks = state.callbacks
+      const previousRunner = state.callbacks.find(
+        (candidate) => candidate.driverId === state.runnerDriverId,
+      )
+      if (previousRunner !== undefined && previousRunner.driverId !== event.candidateDriverId) {
+        activators.setActive(
+          previousRunner.driverId,
+          previousRunner.callbackRegistrationGeneration,
+          false,
+        )
+        callbacks = callbacks.map((candidate) =>
+          candidate.driverId === previousRunner.driverId
+            ? { ...candidate, reanimatedCallbackActive: false }
+            : candidate,
+        )
+      }
+      callbacks = callbacks.map((candidate) =>
+        candidate.driverId === event.candidateDriverId
+          ? { ...candidate, state: 'ADMITTED', reanimatedCallbackActive: true }
+          : candidate,
+      )
+      return uiTransition(
+        {
+          ...state,
+          callbacks,
+          runnerDriverId: event.candidateDriverId,
+          runnerLeaseEpoch: request.requestedRunnerLeaseEpoch,
+          runnerAdmissionRequest: null,
+        },
+        effects,
+      )
+    }
+    case 'runner-admission-timeout': {
+      const request = state.runnerAdmissionRequest
+      if (
+        request === null ||
+        request.admissionToken !== event.admissionToken ||
+        request.candidateDriverId !== event.candidateDriverId ||
+        request.callbackRegistrationGeneration !== event.callbackRegistrationGeneration ||
+        request.requestedRunnerLeaseEpoch !== event.requestedRunnerLeaseEpoch
+      ) {
+        throw new UiValueChannelInvariantError('runner-admission-request-conflict', event.kind)
+      }
+      const effects: UiValueChannelEffect[] = [
+        { kind: 'cancel-runner-admission-timer', admissionToken: event.admissionToken },
+        {
+          kind: 'invalidate-runner-admission-candidate',
+          driverId: event.candidateDriverId,
+          admissionToken: event.admissionToken,
+        },
+      ]
+      activators.setActive(event.candidateDriverId, event.callbackRegistrationGeneration, false)
+      const callbacksAfterInvalidation = state.callbacks.map((candidate) =>
+        candidate.driverId === event.candidateDriverId
+          ? { ...candidate, state: 'REGISTERED_INACTIVE' as const, reanimatedCallbackActive: false }
+          : candidate,
+      )
+      const successor = callbacksAfterInvalidation.find(
+        (candidate) =>
+          candidate.driverId !== event.candidateDriverId &&
+          candidate.state === 'REGISTERED_INACTIVE',
+      )
+      if (successor === undefined) {
+        return uiTransition(
+          { ...state, callbacks: callbacksAfterInvalidation, runnerAdmissionRequest: null },
+          effects,
+        )
+      }
+      activators.setActive(successor.driverId, successor.callbackRegistrationGeneration, true)
+      const admissionToken = state.nextRunnerAdmissionToken
+      const absoluteDeadlineMs = event.nowMs + UI_RUNNER_ADMISSION_WINDOW_MS
+      effects.push({
+        kind: 'select-next-live-runner-candidate',
+        excludedDriverIds: [event.candidateDriverId],
+        selectedDriverId: successor.driverId,
+      })
+      effects.push({
+        kind: 'start-runner-admission-timer',
+        requestedRunnerLeaseEpoch: request.requestedRunnerLeaseEpoch,
+        candidateDriverId: successor.driverId,
+        callbackRegistrationGeneration: successor.callbackRegistrationGeneration,
+        admissionToken,
+        absoluteDeadlineMs,
+      })
+      return uiTransition(
+        {
+          ...state,
+          callbacks: callbacksAfterInvalidation.map((candidate) =>
+            candidate.driverId === successor.driverId
+              ? {
+                  ...candidate,
+                  state: 'ACTIVATION_REQUESTED' as const,
+                  reanimatedCallbackActive: true,
+                }
+              : candidate,
+          ),
+          runnerAdmissionRequest: {
+            requestedRunnerLeaseEpoch: request.requestedRunnerLeaseEpoch,
+            candidateDriverId: successor.driverId,
+            callbackRegistrationGeneration: successor.callbackRegistrationGeneration,
+            admissionToken,
+            absoluteDeadlineMs,
+            actualInvocationObserved: false,
+          },
+          nextRunnerAdmissionToken: admissionToken + 1,
+        },
+        effects,
+      )
+    }
+    case 'retire-callback': {
+      const callback = requireCallback(state, event.driverId, event.kind)
+      if (callback.callbackRegistrationGeneration !== event.callbackRegistrationGeneration) {
+        throw new UiValueChannelInvariantError('callback-registration-conflict', event.kind)
+      }
+      const retiring: UiCallbackRegistrationState = { ...callback, state: 'RETIRING' }
+      return uiTransition(replaceCallback(state, retiring), [
+        { kind: 'retire-callback-effective-next-timestamp', driverId: event.driverId },
+      ])
+    }
+    case 'dispose-callback': {
+      const callback = requireCallback(state, event.driverId, event.kind)
+      if (callback.callbackRegistrationGeneration !== event.callbackRegistrationGeneration) {
+        throw new UiValueChannelInvariantError('callback-registration-conflict', event.kind)
+      }
+      const effects: UiValueChannelEffect[] = []
+      let next = state
+      const transaction = state.transaction
+      if (
+        transaction.kind === 'OPEN' &&
+        transaction.expectedAttendeeDriverIds.includes(event.driverId) &&
+        !transaction.visitedAttendeeDriverIds.includes(event.driverId) &&
+        !transaction.revokedAttendeeDriverIds.includes(event.driverId)
+      ) {
+        effects.push({ kind: 'record-synthetic-revocation-attendance', driverId: event.driverId })
+        next = {
+          ...next,
+          transaction: {
+            ...transaction,
+            revokedAttendeeDriverIds: [...transaction.revokedAttendeeDriverIds, event.driverId],
+          },
+        }
+        next = commitFrameIfAttendanceComplete(next, effects)
+      }
+      effects.push({ kind: 'delete-disposed-callback-after-attendance', driverId: event.driverId })
+      next = {
+        ...next,
+        callbacks: next.callbacks.filter((candidate) => candidate.driverId !== event.driverId),
+      }
+      return uiTransition(next, effects)
+    }
+    default: {
+      const exhaustive: never = event
+      void exhaustive
+      throw new UiValueChannelInvariantError('coordinator-event-kind-unrecognized')
+    }
+  }
+}
+
+// ——— Manual frame transaction ———
+
+export function uiBeginManualFrame(
+  state: UiValueChannelCoordinatorState,
+  crossing: UiManualFrameCrossing,
+): UiValueChannelTransition {
+  const transaction = state.transaction
+  if (transaction.kind === 'OPEN') {
+    throw new UiValueChannelInvariantError('frame-transaction-conflict', 'ui-begin-manual-frame')
+  }
+  const lastCommittedTimestampMs = transaction.lastCommittedTimestampMs
+  if (
+    lastCommittedTimestampMs !== null &&
+    crossing.absoluteTimestampMs <= lastCommittedTimestampMs
+  ) {
+    throw new UiValueChannelInvariantError('frame-transaction-conflict', 'ui-begin-manual-frame')
+  }
+  return uiTransition(
+    {
+      ...state,
+      transaction: {
+        kind: 'OPEN',
+        mode: 'MANUAL',
+        absoluteTimestampMs: crossing.absoluteTimestampMs,
+        mailboxDrainId: state.nextMailboxDrainId,
+        expectedAttendeeDriverIds: crossing.orderedAttendeeDriverIds,
+        visitedAttendeeDriverIds: [],
+        revokedAttendeeDriverIds: [],
+        steppedChannelIds: [],
+        frozenInvocationOrder: crossing.orderedAttendeeDriverIds,
+        lastCommittedTimestampMs,
+        committedFrameCount: transaction.committedFrameCount,
+      },
+    },
+    [
+      {
+        kind: 'open-frame-transaction',
+        mode: 'MANUAL',
+        absoluteTimestampMs: crossing.absoluteTimestampMs,
+      },
+    ],
+  )
+}
+
+export function uiInvokeManualParticipant(
+  state: UiValueChannelCoordinatorState,
+  invocation: UiManualParticipantInvocation,
+): UiValueChannelTransition {
+  const transaction = state.transaction
+  if (transaction.kind !== 'OPEN') {
+    if (
+      transaction.lastCommittedTimestampMs !== null &&
+      invocation.absoluteTimestampMs <= transaction.lastCommittedTimestampMs
+    ) {
+      return uiTransition(state, [], {
+        kind: 'LATE_ATTENDANCE',
+        driverId: invocation.driverId,
+        alreadyCommittedTimestampMs: transaction.lastCommittedTimestampMs,
+      })
+    }
+    throw new UiValueChannelInvariantError(
+      'frame-transaction-conflict',
+      'ui-invoke-manual-participant',
+    )
+  }
+  if (
+    transaction.mode !== 'MANUAL' ||
+    transaction.absoluteTimestampMs !== invocation.absoluteTimestampMs
+  ) {
+    throw new UiValueChannelInvariantError(
+      'frame-transaction-conflict',
+      'ui-invoke-manual-participant',
+    )
+  }
+  if (!transaction.expectedAttendeeDriverIds.includes(invocation.driverId)) {
+    throw new UiValueChannelInvariantError(
+      'frame-attendance-conflict',
+      'ui-invoke-manual-participant',
+    )
+  }
+  if (
+    transaction.visitedAttendeeDriverIds.includes(invocation.driverId) ||
+    transaction.revokedAttendeeDriverIds.includes(invocation.driverId)
+  ) {
+    throw new UiValueChannelInvariantError(
+      'frame-attendance-conflict',
+      'ui-invoke-manual-participant',
+    )
+  }
+  const effects: UiValueChannelEffect[] = []
+  let next = recordFrameAttendance(state, invocation.driverId, effects)
+  next = commitFrameIfAttendanceComplete(next, effects)
+  return uiTransition(next, effects)
+}
+
+export function uiRevokeManualParticipant(
+  state: UiValueChannelCoordinatorState,
+  revocation: UiManualParticipantRevocation,
+): UiValueChannelTransition {
+  const transaction = state.transaction
+  if (
+    transaction.kind !== 'OPEN' ||
+    transaction.mode !== 'MANUAL' ||
+    transaction.absoluteTimestampMs !== revocation.absoluteTimestampMs
+  ) {
+    throw new UiValueChannelInvariantError(
+      'frame-transaction-conflict',
+      'ui-revoke-manual-participant',
+    )
+  }
+  if (!transaction.expectedAttendeeDriverIds.includes(revocation.driverId)) {
+    throw new UiValueChannelInvariantError(
+      'frame-attendance-conflict',
+      'ui-revoke-manual-participant',
+    )
+  }
+  if (
+    transaction.visitedAttendeeDriverIds.includes(revocation.driverId) ||
+    transaction.revokedAttendeeDriverIds.includes(revocation.driverId)
+  ) {
+    throw new UiValueChannelInvariantError(
+      'frame-attendance-conflict',
+      'ui-revoke-manual-participant',
+    )
+  }
+  const effects: UiValueChannelEffect[] = [
+    { kind: 'record-synthetic-revocation-attendance', driverId: revocation.driverId },
+  ]
+  let next: UiValueChannelCoordinatorState = {
+    ...state,
+    transaction: {
+      ...transaction,
+      revokedAttendeeDriverIds: [...transaction.revokedAttendeeDriverIds, revocation.driverId],
+    },
+  }
+  next = commitFrameIfAttendanceComplete(next, effects)
+  return uiTransition(next, effects)
+}
+
+export function uiCommitManualFrame(
+  state: UiValueChannelCoordinatorState,
+  request: UiManualFrameCommitRequest,
+): UiValueChannelTransition {
+  const transaction = state.transaction
+  if (transaction.kind !== 'OPEN') {
+    if (transaction.lastCommittedTimestampMs === request.absoluteTimestampMs) {
+      return uiTransition(state, [
+        { kind: 'already-committed-no-op', absoluteTimestampMs: request.absoluteTimestampMs },
+      ])
+    }
+    throw new UiValueChannelInvariantError('frame-transaction-conflict', 'ui-commit-manual-frame')
+  }
+  if (
+    transaction.mode !== 'MANUAL' ||
+    transaction.absoluteTimestampMs !== request.absoluteTimestampMs
+  ) {
+    throw new UiValueChannelInvariantError('frame-transaction-conflict', 'ui-commit-manual-frame')
+  }
+  const missingDriverIds = transaction.expectedAttendeeDriverIds.filter(
+    (driverId) =>
+      !transaction.visitedAttendeeDriverIds.includes(driverId) &&
+      !transaction.revokedAttendeeDriverIds.includes(driverId),
+  )
+  if (missingDriverIds.length > 0) {
+    return uiTransition(state, [], { kind: 'MISSING_ATTENDEES', missingDriverIds })
+  }
+  const effects: UiValueChannelEffect[] = []
+  const next = commitFrameIfAttendanceComplete(state, effects)
+  return uiTransition(next, effects)
+}
+
+export function armManualDestinationCommit(
+  state: UiValueChannelCoordinatorState,
+  groupId: number,
+  commit: UiManualDestinationCommitSlot,
+): UiValueChannelTransition {
+  const group = requireManualGroup(state, groupId, 'arm-manual-destination-commit')
+  return uiTransition(
+    replaceManualGroup(state, {
+      ...group,
+      pendingDestinationCommits: [...group.pendingDestinationCommits, commit],
+      armedForExplicitStep: true,
+    }),
+    [
+      {
+        kind: 'arm-manual-group-for-destination-commit',
+        groupId,
+        commitSlotId: commit.commitSlotId,
+      },
+    ],
+  )
+}
+
+interface UiManualCommitConsumption {
+  readonly state: UiValueChannelCoordinatorState
+  readonly group: ManualFrameGroupState
+}
+
+function consumeManualDestinationCommit(
+  state: UiValueChannelCoordinatorState,
+  group: ManualFrameGroupState,
+  commit: UiManualDestinationCommitSlot,
+  authority: UiPreparedDestinationRecordState,
+  validator: UiDestinationCommitCanonicalValidatorCapability,
+  effects: UiValueChannelEffect[],
+): UiManualCommitConsumption {
+  effects.push({
+    kind: 'lookup-prepared-destination-record',
+    groupId: group.groupId,
+    destinationRecordId: commit.destinationRecordId,
+  })
+  effects.push({
+    kind: 'validate-ui-destination-commit-with-canonical-authority',
+    root: 'MANUAL',
+    groupId: group.groupId,
+    commitSlotId: commit.commitSlotId,
+    authority,
+    validator,
+  })
+  const newEntries = commit.includedPostFencePrefix.filter(
+    (entry) => entry.authoritativeSequence > authority.appliedThroughAuthoritativeSequence,
+  )
+  const appliedThroughAuthoritativeSequence =
+    newEntries.at(-1)?.authoritativeSequence ?? authority.appliedThroughAuthoritativeSequence
+  let next = state
+  if (newEntries.length > 0) {
+    effects.push({
+      kind: 'adopt-immutable-destination-commit',
+      groupId: group.groupId,
+      commitSlotId: commit.commitSlotId,
+    })
+    for (const entry of newEntries) {
+      effects.push({
+        kind: 'apply-included-post-fence-ledger-entry-in-place',
+        groupId: group.groupId,
+        commitSlotId: commit.commitSlotId,
+        prefixIndex: commit.includedPostFencePrefix.indexOf(entry),
+        destinationSlot: entry.destinationSlot,
+        entry,
+      })
+    }
+    next = {
+      ...next,
+      preparedDestinationRecords: next.preparedDestinationRecords.map((candidate) =>
+        candidate === authority
+          ? {
+              ...candidate,
+              adoptedCommitSlotId: commit.commitSlotId,
+              appliedThroughAuthoritativeSequence,
+              ledgers: applyEntriesToUiLedgers(candidate.ledgers, newEntries),
+            }
+          : candidate,
+      ),
+    }
+  }
+  const acknowledgement: DestinationCommitAcknowledgement = {
+    kind: 'DESTINATION_COMMIT_ACKNOWLEDGEMENT',
+    channelId: commit.channelId,
+    sourceRecordId: commit.sourceRecordId,
+    destinationRecordId: commit.destinationRecordId,
+    direction: commit.direction,
+    transferLease: commit.transferLease,
+    releaseFenceSequence: commit.releaseFenceSequence,
+    drainedThroughAuthoritativeSequence: appliedThroughAuthoritativeSequence,
+  }
+  effects.push({
+    kind: 'fill-prefilled-destination-acknowledgement-slot',
+    groupId: group.groupId,
+    commitSlotId: commit.commitSlotId,
+    acknowledgementSlotId: commit.acknowledgementSlotId,
+  })
+  effects.push({
+    kind: 'stage-destination-acknowledgement-in-current-envelope',
+    groupId: group.groupId,
+    acknowledgementSlotId: commit.acknowledgementSlotId,
+    mailboxDrainId: next.nextMailboxDrainId,
+  })
+  next = {
+    ...next,
+    destinationCommitAcknowledgementSlots: next.destinationCommitAcknowledgementSlots.map(
+      (candidate) =>
+        candidate.acknowledgementSlotId === commit.acknowledgementSlotId
+          ? { ...candidate, state: 'STAGED_IN_CURRENT_ENVELOPE', acknowledgement }
+          : candidate,
+    ),
+  }
+  effects.push({
+    kind: 'consume-manual-destination-commit-on-explicit-step',
+    groupId: group.groupId,
+    commitSlotId: commit.commitSlotId,
+  })
+  const pendingDestinationCommits = group.pendingDestinationCommits.filter(
+    (candidate) => candidate.commitSlotId !== commit.commitSlotId,
+  )
+  return {
+    state: next,
+    group: {
+      ...group,
+      pendingDestinationCommits,
+      consumedCommitSlotIds: [...group.consumedCommitSlotIds, commit.commitSlotId],
+      armedForExplicitStep: pendingDestinationCommits.length > 0,
+    },
+  }
+}
+
+export function stepManualFrameGroup(
+  state: UiValueChannelCoordinatorState,
+  request: ManualFrameGroupStepRequest,
+  validator: UiDestinationCommitCanonicalValidatorCapability,
+): UiValueChannelTransition {
+  const group = requireManualGroup(state, request.groupId, 'step-manual-frame-group')
+  if (state.transaction.kind === 'OPEN') {
+    throw new UiValueChannelInvariantError('frame-transaction-conflict', 'step-manual-frame-group')
+  }
+  const pendingCommit = group.pendingDestinationCommits[0]
+  let authority: UiPreparedDestinationRecordState | null = null
+  if (pendingCommit !== undefined) {
+    const outcome = validator.validate({
+      commit: pendingCommit,
+      preparedDestinationRecords: state.preparedDestinationRecords,
+    })
+    if (outcome.kind === 'REFUSED') {
+      return uiTransition(
+        state,
+        [
+          {
+            kind: 'report-ui-destination-commit-refusal',
+            root: 'MANUAL',
+            groupId: request.groupId,
+            commitSlotId: pendingCommit.commitSlotId,
+            authority: outcome.authority,
+            reason: outcome.reason,
+          },
+        ],
+        {
+          kind: 'DESTINATION_COMMIT_REFUSED',
+          groupId: request.groupId,
+          commitSlotId: pendingCommit.commitSlotId,
+          authority: outcome.authority,
+          reason: outcome.reason,
+        },
+      )
+    }
+    authority = outcome.authority
+    const acknowledgementSlot = state.destinationCommitAcknowledgementSlots.find(
+      (candidate) => candidate.acknowledgementSlotId === pendingCommit.acknowledgementSlotId,
+    )
+    if (acknowledgementSlot === undefined) {
+      return uiTransition(
+        state,
+        [
+          {
+            kind: 'report-ui-destination-commit-refusal',
+            root: 'MANUAL',
+            groupId: request.groupId,
+            commitSlotId: pendingCommit.commitSlotId,
+            authority,
+            reason: 'missing-acknowledgement-slot',
+          },
+        ],
+        {
+          kind: 'DESTINATION_COMMIT_REFUSED',
+          groupId: request.groupId,
+          commitSlotId: pendingCommit.commitSlotId,
+          authority,
+          reason: 'missing-acknowledgement-slot',
+        },
+      )
+    }
+  }
+
+  const absoluteTimestampMs = group.currentAbsoluteTimestampMs + request.elapsedMs
+  const orderedAttendeeDriverIds = request.invocationOrder ?? group.participantDriverIds
+  const effects: UiValueChannelEffect[] = [
+    { kind: 'advance-manual-group-clock-once', groupId: request.groupId, absoluteTimestampMs },
+    {
+      kind: 'freeze-manual-attendee-batch',
+      groupId: request.groupId,
+      orderedAttendeeDriverIds,
+    },
+  ]
+  let next = state
+  let steppedGroup = group
+  if (pendingCommit !== undefined && authority !== null) {
+    const consumption = consumeManualDestinationCommit(
+      next,
+      steppedGroup,
+      pendingCommit,
+      authority,
+      validator,
+      effects,
+    )
+    next = consumption.state
+    steppedGroup = consumption.group
+  }
+  const identities = next.identities.map((identity) => {
+    const deltaMs =
+      identity.lastAbsoluteTimestampMs === null
+        ? 0
+        : absoluteTimestampMs - identity.lastAbsoluteTimestampMs
+    effects.push({
+      kind: 'step-shared-identity-once',
+      channelId: identity.channelId,
+      absoluteTimestampMs,
+      deltaMs,
+    })
+    return {
+      ...identity,
+      lastAbsoluteTimestampMs: absoluteTimestampMs,
+      stepCount: identity.stepCount + 1,
+      hostCommitCount: identity.hostCommitCount + 1,
+    }
+  })
+  effects.push({ kind: 'commit-frame-once', absoluteTimestampMs })
+  const transaction = next.transaction
+  if (transaction.kind !== 'CLOSED') {
+    throw new UiValueChannelInvariantError('frame-transaction-conflict', 'step-manual-frame-group')
+  }
+  next = {
+    ...next,
+    identities,
+    transaction: {
+      kind: 'CLOSED',
+      lastCommittedTimestampMs: absoluteTimestampMs,
+      committedFrameCount: transaction.committedFrameCount + 1,
+    },
+  }
+  next = replaceManualGroup(next, {
+    ...steppedGroup,
+    currentAbsoluteTimestampMs: absoluteTimestampMs,
+    explicitStepCount: steppedGroup.explicitStepCount + 1,
+  })
+  return uiTransition(next, effects)
+}
+
+// ——— Live UI destination COMMIT consumption ———
+
+function refuseLiveUiDestinationCommit(
+  state: UiLiveDestinationCommitConsumeState,
+  commitSlotId: number,
+  authority: UiPreparedDestinationRecordState | null,
+  reason: UiLiveDestinationCommitRefusalReason,
+): UiLiveDestinationCommitTransition {
+  return {
+    state,
+    outcome: { kind: 'REFUSED', commitSlotId, reason },
+    orderedEffects: [
+      {
+        kind: 'report-ui-destination-commit-refusal',
+        root: 'LIVE',
+        commitSlotId,
+        authority,
+        reason,
+      },
+    ],
+  }
+}
+
+export function consumeLiveUiDestinationCommit(
+  state: UiLiveDestinationCommitConsumeState,
+  request: UiLiveDestinationCommitConsumeRequest,
+  validator: UiDestinationCommitCanonicalValidatorCapability,
+): UiLiveDestinationCommitTransition {
+  const envelope = state.envelope
+  const commit = request.commit
+  if (envelope.state !== 'OPEN') {
+    return refuseLiveUiDestinationCommit(state, commit.commitSlotId, null, 'envelope-not-open')
+  }
+  const outcome = validator.validate({
+    commit,
+    preparedDestinationRecords: state.coordinator.preparedDestinationRecords,
+  })
+  if (outcome.kind === 'REFUSED') {
+    return refuseLiveUiDestinationCommit(
+      state,
+      commit.commitSlotId,
+      outcome.authority,
+      outcome.reason,
+    )
+  }
+  const authority = outcome.authority
+  const acknowledgementSlot = state.coordinator.destinationCommitAcknowledgementSlots.find(
+    (candidate) => candidate.acknowledgementSlotId === commit.acknowledgementSlotId,
+  )
+  if (acknowledgementSlot === undefined) {
+    return refuseLiveUiDestinationCommit(
+      state,
+      commit.commitSlotId,
+      authority,
+      'missing-acknowledgement-slot',
+    )
+  }
+
+  const effects: UiLiveDestinationCommitEffect[] = [
+    {
+      kind: 'lookup-live-prepared-destination-record',
+      destinationRecordId: commit.destinationRecordId,
+    },
+    {
+      kind: 'validate-ui-destination-commit-with-canonical-authority',
+      root: 'LIVE',
+      commitSlotId: commit.commitSlotId,
+      authority,
+      validator,
+    },
+  ]
+  const newEntries = commit.includedPostFencePrefix.filter(
+    (entry) => entry.authoritativeSequence > authority.appliedThroughAuthoritativeSequence,
+  )
+  const appliedThroughAuthoritativeSequence =
+    newEntries.at(-1)?.authoritativeSequence ?? authority.appliedThroughAuthoritativeSequence
+  const duplicate = newEntries.length === 0
+  let preparedDestinationRecords = state.coordinator.preparedDestinationRecords
+  if (!duplicate) {
+    effects.push({
+      kind: 'adopt-live-immutable-destination-commit',
+      commitSlotId: commit.commitSlotId,
+    })
+    for (const entry of newEntries) {
+      effects.push({
+        kind: 'apply-live-included-post-fence-ledger-entry-in-place',
+        commitSlotId: commit.commitSlotId,
+        prefixIndex: commit.includedPostFencePrefix.indexOf(entry),
+        destinationSlot: entry.destinationSlot,
+        entry,
+      })
+    }
+    preparedDestinationRecords = preparedDestinationRecords.map((candidate) =>
+      candidate === authority
+        ? {
+            ...candidate,
+            adoptedCommitSlotId: commit.commitSlotId,
+            appliedThroughAuthoritativeSequence,
+            ledgers: applyEntriesToUiLedgers(candidate.ledgers, newEntries),
+          }
+        : candidate,
+    )
+  }
+  const acknowledgement: DestinationCommitAcknowledgement = {
+    kind: 'DESTINATION_COMMIT_ACKNOWLEDGEMENT',
+    channelId: commit.channelId,
+    sourceRecordId: commit.sourceRecordId,
+    destinationRecordId: commit.destinationRecordId,
+    direction: commit.direction,
+    transferLease: commit.transferLease,
+    releaseFenceSequence: commit.releaseFenceSequence,
+    drainedThroughAuthoritativeSequence: appliedThroughAuthoritativeSequence,
+  }
+  effects.push({
+    kind: 'fill-live-destination-acknowledgement-slot',
+    commitSlotId: commit.commitSlotId,
+    acknowledgementSlotId: commit.acknowledgementSlotId,
+  })
+  effects.push({
+    kind: 'stage-live-destination-acknowledgement-in-current-envelope',
+    acknowledgementSlotId: commit.acknowledgementSlotId,
+    mailboxDrainId: envelope.mailboxDrainId,
+  })
+  const entries: UiLiveDestinationEnvelopeEntry[] = [
+    {
+      kind: 'DESTINATION_COMMIT_ACKNOWLEDGEMENT',
+      acknowledgementSlotId: commit.acknowledgementSlotId,
+      drainedThroughAuthoritativeSequence: appliedThroughAuthoritativeSequence,
+    },
+  ]
+  for (const sibling of request.siblingEmissions) {
+    effects.push({
+      kind: 'emit-live-ui-sibling',
+      emissionSequence: sibling.emissionSequence,
+      emissionKind: sibling.emissionKind,
+    })
+    entries.push({
+      kind: 'SIBLING_EMISSION',
+      emissionSequence: sibling.emissionSequence,
+      emissionKind: sibling.emissionKind,
+    })
+  }
+  effects.push({
+    kind: 'seal-live-ui-envelope-once',
+    mailboxDrainId: envelope.mailboxDrainId,
+    entryCount: entries.length,
+  })
+  const sealedEnvelope: UiLiveDestinationEnvelopeState = {
+    ...envelope,
+    state: 'SEALED',
+    entries,
+    sealCount: envelope.sealCount + 1,
+  }
+  return {
+    state: {
+      coordinator: {
+        ...state.coordinator,
+        preparedDestinationRecords,
+        destinationCommitAcknowledgementSlots:
+          state.coordinator.destinationCommitAcknowledgementSlots.map((candidate) =>
+            candidate.acknowledgementSlotId === commit.acknowledgementSlotId
+              ? { ...candidate, state: 'STAGED_IN_CURRENT_ENVELOPE', acknowledgement }
+              : candidate,
+          ),
+      },
+      envelope: sealedEnvelope,
+    },
+    outcome: duplicate
+      ? { kind: 'DUPLICATE_REACKNOWLEDGED', commitSlotId: commit.commitSlotId, acknowledgement }
+      : { kind: 'APPLIED', commitSlotId: commit.commitSlotId, acknowledgement },
+    orderedEffects: effects,
+  }
+}
+
+// ——— Shared manual identity transfer gap ———
+
+export function stepSharedManualIdentityTransferGap(
+  state: UiValueChannelCoordinatorState,
+  request: UiSharedManualIdentityTransferGapRequest,
+): UiSharedManualIdentityTransferGapTransition {
+  const identity = state.identities.find((candidate) => candidate.channelId === request.channelId)
+  if (identity === undefined) {
+    throw new UiValueChannelInvariantError(
+      'shared-transfer-identity-missing',
+      'step-shared-manual-identity-transfer-gap',
+    )
+  }
+  const firstDriverId = request.orderedAttendeeDriverIds[0]
+  const secondDriverId = request.orderedAttendeeDriverIds[1]
+  const firstGeneration = request.callbackRegistrationGenerations[0]
+  const secondGeneration = request.callbackRegistrationGenerations[1]
+  const orderedEffects: UiSharedManualIdentityTransferGapEffect[] = [
+    {
+      kind: 'begin-shared-manual-transfer-transaction',
+      groupId: request.groupId,
+      channelId: request.channelId,
+      absoluteTimestampMs: request.absoluteTimestampMs,
+      orderedAttendeeDriverIds: request.orderedAttendeeDriverIds,
+      callbackRegistrationGenerations: request.callbackRegistrationGenerations,
+    },
+    {
+      kind: 'invoke-shared-manual-transfer-participant',
+      groupId: request.groupId,
+      driverId: firstDriverId,
+      callbackRegistrationGeneration: firstGeneration,
+      invocationIndex: 0,
+      absoluteTimestampMs: request.absoluteTimestampMs,
+    },
+    {
+      kind: 'bridge-shared-identity-transfer-gap',
+      channelId: request.channelId,
+      direction: request.direction,
+      transferLease: request.transferLease,
+      sourceRecordId: request.sourceRecordId,
+      destinationRecordId: request.destinationRecordId,
+      absoluteTimestampMs: request.absoluteTimestampMs,
+    },
+    {
+      kind: 'invoke-shared-manual-transfer-participant',
+      groupId: request.groupId,
+      driverId: secondDriverId,
+      callbackRegistrationGeneration: secondGeneration,
+      invocationIndex: 1,
+      absoluteTimestampMs: request.absoluteTimestampMs,
+    },
+    {
+      kind: 'step-shared-manual-transfer-identity-once',
+      channelId: request.channelId,
+      absoluteTimestampMs: request.absoluteTimestampMs,
+    },
+    {
+      kind: 'commit-shared-manual-transfer-transaction-once',
+      groupId: request.groupId,
+      absoluteTimestampMs: request.absoluteTimestampMs,
+    },
+  ]
+  const transaction = state.transaction
+  const next: UiValueChannelCoordinatorState = {
+    ...state,
+    identities: state.identities.map((candidate) =>
+      candidate.channelId === request.channelId
+        ? {
+            ...candidate,
+            lastAbsoluteTimestampMs: request.absoluteTimestampMs,
+            stepCount: candidate.stepCount + 1,
+            hostCommitCount: candidate.hostCommitCount + 1,
+          }
+        : candidate,
+    ),
+    transaction: {
+      kind: 'CLOSED',
+      lastCommittedTimestampMs: request.absoluteTimestampMs,
+      committedFrameCount: transaction.committedFrameCount + 1,
+    },
+  }
+  return { state: next, observation: observeUiValueChannel(next), orderedEffects }
+}
+
+// ——— UI-owned identity sink fanout ———
+
+export function fanoutUiOwnedIdentitySample(
+  state: UiOwnedIdentitySampleFanoutState,
+  request: UiOwnedIdentitySampleFanoutRequest,
+): UiOwnedIdentitySampleFanoutTransition {
+  if (request.channelId !== state.channelId) {
+    throw new UiValueChannelInvariantError(
+      'owned-identity-channel-conflict',
+      'fanout-ui-owned-identity-sample',
+    )
+  }
+  const orderedEffects: UiOwnedIdentitySampleFanoutEffect[] = [
+    {
+      kind: 'adopt-ui-owned-identity-sample',
+      channelId: request.channelId,
+      executionId: request.executionId,
+      value: request.value,
+      writeSequence: request.writeSequence,
+      absoluteTimestampMs: request.absoluteTimestampMs,
+    },
+  ]
+  const sinks = state.sinks.map((sink) => {
+    orderedEffects.push({
+      kind: 'fanout-ui-owned-identity-sample-to-sink',
+      sinkId: sink.sinkId,
+      driverId: sink.driverId,
+      handle: sink.handle,
+      key: sink.key,
+      bindingGeneration: sink.bindingGeneration,
+      value: request.value,
+      writeSequence: request.writeSequence,
+    })
+    return {
+      ...sink,
+      lastCommittedValue: request.value,
+      lastCommittedWriteSequence: request.writeSequence,
+      commitCount: sink.commitCount + 1,
+    }
+  })
+  orderedEffects.push({
+    kind: 'commit-ui-owned-identity-sinks-once',
+    channelId: request.channelId,
+    sinkIds: sinks.map((sink) => sink.sinkId),
+    absoluteTimestampMs: request.absoluteTimestampMs,
+  })
+  const next: UiOwnedIdentitySampleFanoutState = {
+    ...state,
+    lastAcceptedAbsoluteTimestampMs: request.absoluteTimestampMs,
+    sinks,
+    uiSinkCommitCount: state.uiSinkCommitCount + 1,
+  }
+  return {
+    state: next,
+    observation: {
+      channelId: next.channelId,
+      sinkCount: next.sinks.length,
+      committedSinkCount: next.sinks.length,
+      committedSinkIds: next.sinks.map((sink) => sink.sinkId),
+      uiSinkCommitCount: next.uiSinkCommitCount,
+      jsToUiWriteLaneInvocationCount: next.jsToUiWriteLaneInvocationCount,
+    },
+    orderedEffects,
+  }
+}
+
+// ——— Legacy manual driver.step compatibility ———
+
+export function stepLegacyManualDriver(
+  state: UiValueChannelCoordinatorState,
+  request: LegacyManualDriverStepRequest,
+): UiValueChannelTransition {
+  const group = requireManualGroup(state, request.groupId, 'step-legacy-manual-driver')
+  if (
+    group.participantDriverIds.length !== 1 ||
+    group.participantDriverIds[0] !== request.driverId
+  ) {
+    return uiTransition(state, [], {
+      kind: 'MULTI_MEMBER_GROUP_REQUIRES_GROUP_STEP',
+      groupId: request.groupId,
+      participantCount: group.participantDriverIds.length,
+    })
+  }
+  const absoluteTimestampMs = group.currentAbsoluteTimestampMs + request.elapsedMs
+  const effects: UiValueChannelEffect[] = [
+    {
+      kind: 'delegate-legacy-step-to-private-single-member-group',
+      groupId: request.groupId,
+      driverId: request.driverId,
+    },
+    { kind: 'advance-manual-group-clock-once', groupId: request.groupId, absoluteTimestampMs },
+    {
+      kind: 'freeze-manual-attendee-batch',
+      groupId: request.groupId,
+      orderedAttendeeDriverIds: [request.driverId],
+    },
+  ]
+  const identities = state.identities.map((identity) => {
+    const deltaMs =
+      identity.lastAbsoluteTimestampMs === null
+        ? 0
+        : absoluteTimestampMs - identity.lastAbsoluteTimestampMs
+    effects.push({
+      kind: 'step-shared-identity-once',
+      channelId: identity.channelId,
+      absoluteTimestampMs,
+      deltaMs,
+    })
+    return {
+      ...identity,
+      lastAbsoluteTimestampMs: absoluteTimestampMs,
+      stepCount: identity.stepCount + 1,
+      hostCommitCount: identity.hostCommitCount + 1,
+    }
+  })
+  effects.push({ kind: 'commit-frame-once', absoluteTimestampMs })
+  const transaction = state.transaction
+  if (transaction.kind !== 'CLOSED') {
+    throw new UiValueChannelInvariantError(
+      'frame-transaction-conflict',
+      'step-legacy-manual-driver',
+    )
+  }
+  const next = replaceManualGroup(
+    {
+      ...state,
+      identities,
+      transaction: {
+        kind: 'CLOSED',
+        lastCommittedTimestampMs: absoluteTimestampMs,
+        committedFrameCount: transaction.committedFrameCount + 1,
+      },
+    },
+    {
+      ...group,
+      currentAbsoluteTimestampMs: absoluteTimestampMs,
+      explicitStepCount: group.explicitStepCount + 1,
+    },
+  )
+  return uiTransition(next, effects)
+}
+
+// ——— UI-owned private target-batch dependency events ———
+
+export function stageUiPrivateTargetBatchDependencyEvent(
+  coordinator: UiValueChannelCoordinatorState,
+  adapter: UiPrivateTargetBatchAdapterState,
+  request: UiPrivateTargetBatchDependencyEventRequest,
+): UiPrivateTargetBatchDependencyEventTransition {
+  if (
+    request.controlId !== adapter.controlId ||
+    request.batchId !== adapter.batchId ||
+    request.dependencyId !== adapter.dependencyId
+  ) {
+    throw new UiValueChannelInvariantError(
+      'private-target-batch-adapter-conflict',
+      'stage-private-target-batch-dependency-event',
+    )
+  }
+  const transaction = coordinator.transaction
+  if (transaction.kind !== 'OPEN') {
+    throw new UiValueChannelInvariantError(
+      'private-target-batch-transaction-closed',
+      'stage-private-target-batch-dependency-event',
+    )
+  }
+  const eventSequence = adapter.nextDependencyEventSequence
+  return {
+    adapter: {
+      ...adapter,
+      nextDependencyEventSequence: eventSequence + 1,
+      stagedDependencyEventCount: adapter.stagedDependencyEventCount + 1,
+    },
+    orderedEffects: [
+      {
+        kind: 'PREFILL_PRIVATE_TARGET_BATCH_DEPENDENCY_EVENT',
+        transactionMode: transaction.mode,
+        event: {
+          kind: 'TARGET_BATCH_DEPENDENCY_EVENT',
+          batchId: adapter.batchId,
+          dependencyId: adapter.dependencyId,
+          dependencyEventKind: request.kind,
+          eventSequence,
+          ownerControlId: adapter.controlId,
+        },
+      },
+      {
+        kind: 'ADVANCE_PRIVATE_TARGET_BATCH_EVENT_SEQUENCE',
+        controlId: adapter.controlId,
+        eventSequence,
+      },
+    ],
+  }
+}
+
+// ——— Runner admission timeout and reselection ———
+
+function staleRunnerEvent(
+  state: UiRunnerAdmissionState,
+  driverId: number,
+): UiRunnerAdmissionTransition {
+  return { state, orderedEffects: [{ kind: 'IGNORE_STALE_RUNNER_EVENT', driverId }] }
+}
+
+function requireCurrentRunnerCandidate(
+  state: UiRunnerAdmissionState,
+  event: UiRunnerAdmissionEvent,
+): UiRunnerAdmissionCandidateState | null {
+  const candidate = state.candidates.find(
+    (registration) => registration.driverId === event.driverId,
+  )
+  if (
+    candidate === undefined ||
+    candidate.state !== 'RUNNER_CANDIDATE' ||
+    candidate.callbackRegistrationGeneration !== event.callbackRegistrationGeneration ||
+    candidate.callbackLeaseEpoch !== event.callbackLeaseEpoch
+  ) {
+    return null
+  }
+  return candidate
+}
+
+function transferRetainedChannels(
+  state: UiRunnerAdmissionState,
+  effects: UiRunnerAdmissionEffect[],
+  retainedWorkRuntime: UiRunnerRetainedWorkRuntime,
+): UiRunnerAdmissionState {
+  let retainedWorkTransferRequestCount = state.retainedWorkTransferRequestCount
+  for (const channel of state.retainedChannels) {
+    retainedWorkRuntime.transferRetainedChannelWork(channel)
+    effects.push({ kind: 'TRANSFER_RETAINED_CHANNEL_WORK', channel })
+    retainedWorkTransferRequestCount += 1
+  }
+  return { ...state, retainedWorkTransferRequestCount }
+}
+
+export function advanceUiRunnerAdmission(
+  state: UiRunnerAdmissionState,
+  event: UiRunnerAdmissionEvent,
+  activators: UiRetainedFrameCallbackActivatorRegistry,
+  retainedWorkRuntime: UiRunnerRetainedWorkRuntime,
+): UiRunnerAdmissionTransition {
+  switch (event.kind) {
+    case 'runner-candidate-timeout': {
+      const candidate = requireCurrentRunnerCandidate(state, event)
+      if (candidate === null) return staleRunnerEvent(state, event.driverId)
+      const effects: UiRunnerAdmissionEffect[] = [
+        { kind: 'EXPIRE_RUNNER_CANDIDATE', driverId: event.driverId },
+      ]
+      activators.setActive(event.driverId, event.callbackRegistrationGeneration, false)
+      const candidates = state.candidates.map((registration) =>
+        registration.driverId === event.driverId
+          ? { ...registration, state: 'EXPIRED' as const }
+          : registration,
+      )
+      const successor = candidates.find(
+        (registration) =>
+          registration.driverId !== event.driverId && registration.state === 'RUNNER_CANDIDATE',
+      )
+      if (successor !== undefined) {
+        activators.setActive(successor.driverId, successor.callbackRegistrationGeneration, true)
+        effects.push({
+          kind: 'SELECT_SUCCESSOR_RUNNER_CANDIDATE',
+          driverId: successor.driverId,
+          callbackLeaseEpoch: successor.callbackLeaseEpoch,
+        })
+        return {
+          state: {
+            ...state,
+            candidates,
+            runnerDriverId: successor.driverId,
+            runnerLeaseEpoch: successor.callbackLeaseEpoch,
+          },
+          orderedEffects: effects,
+        }
+      }
+      const channelIds = state.retainedChannels.map((channel) => channel.channelId)
+      retainedWorkRuntime.reportFinalRunnerTimeoutRefusal(channelIds)
+      effects.push({ kind: 'REPORT_FINAL_RUNNER_TIMEOUT_REFUSAL', channelIds })
+      for (const channel of state.retainedChannels) {
+        if (channel.installedPreArmControlSlot !== null) {
+          retainedWorkRuntime.stopInstalledPreArmSlot(
+            channel.channelId,
+            channel.installedPreArmControlSlot,
+          )
+          effects.push({
+            kind: 'STOP_INSTALLED_PRE_ARM_SLOT_ONLY',
+            channelId: channel.channelId,
+            slot: channel.installedPreArmControlSlot,
+          })
+        }
+      }
+      const transferred = transferRetainedChannels(
+        {
+          ...state,
+          candidates,
+          runnerDriverId: null,
+          runnerLeaseEpoch: 0,
+          timeoutRefusalCount: state.timeoutRefusalCount + 1,
+        },
+        effects,
+        retainedWorkRuntime,
+      )
+      return { state: transferred, orderedEffects: effects }
+    }
+    case 'invoke-runner-candidate': {
+      const candidate = requireCurrentRunnerCandidate(state, event)
+      if (candidate === null) return staleRunnerEvent(state, event.driverId)
+      const effects: UiRunnerAdmissionEffect[] = [
+        {
+          kind: 'ADMIT_INVOKED_RUNNER_CANDIDATE',
+          driverId: event.driverId,
+          callbackLeaseEpoch: candidate.callbackLeaseEpoch,
+        },
+      ]
+      const admitted: UiRunnerAdmissionState = {
+        ...state,
+        candidates: state.candidates.map((registration) =>
+          registration.driverId === event.driverId
+            ? { ...registration, state: 'ADMITTED' as const, invocationObserved: true }
+            : registration,
+        ),
+        runnerDriverId: event.driverId,
+        runnerLeaseEpoch: candidate.callbackLeaseEpoch,
+      }
+      const transferred = transferRetainedChannels(admitted, effects, retainedWorkRuntime)
+      return { state: transferred, orderedEffects: effects }
+    }
+    case 'dispose-runner-candidate': {
+      const candidate = requireCurrentRunnerCandidate(state, event)
+      if (candidate === null) return staleRunnerEvent(state, event.driverId)
+      const effects: UiRunnerAdmissionEffect[] = [
+        { kind: 'DISPOSE_RUNNER_CANDIDATE', driverId: event.driverId },
+      ]
+      activators.setActive(event.driverId, event.callbackRegistrationGeneration, false)
+      const candidates = state.candidates.map((registration) =>
+        registration.driverId === event.driverId
+          ? { ...registration, state: 'DISPOSED' as const }
+          : registration,
+      )
+      const successor = candidates.find(
+        (registration) =>
+          registration.driverId !== event.driverId && registration.state === 'RUNNER_CANDIDATE',
+      )
+      if (successor !== undefined) {
+        activators.setActive(successor.driverId, successor.callbackRegistrationGeneration, true)
+        effects.push({
+          kind: 'SELECT_SUCCESSOR_RUNNER_CANDIDATE',
+          driverId: successor.driverId,
+          callbackLeaseEpoch: successor.callbackLeaseEpoch,
+        })
+        return {
+          state: {
+            ...state,
+            candidates,
+            runnerDriverId: successor.driverId,
+            runnerLeaseEpoch: successor.callbackLeaseEpoch,
+          },
+          orderedEffects: effects,
+        }
+      }
+      return {
+        state: { ...state, candidates, runnerDriverId: null, runnerLeaseEpoch: 0 },
+        orderedEffects: effects,
+      }
+    }
+    default: {
+      const exhaustive: never = event
+      void exhaustive
+      throw new UiValueChannelInvariantError('runner-admission-event-kind-unrecognized')
+    }
+  }
+}
+
+// ——— Primitive listener-recursion reducer ———
+
+/** Mutable working copy of one execution record; returned to the immutable state at the end. */
+interface UiRecursionWorkingExecution {
+  executionId: number
+  targetValue: number
+  firstSampleValue: number
+  commandSequence: number
+  completionSequence: number
+  updateSequence: number
+  stopCount: number
+  phase: UiRecursionExecutionPhase
+  orphaned: boolean
+}
+
+interface UiRecursionWorkingCancelListener {
+  listenerId: number
+  hasStartedSuccessor: boolean
+  successor: UiRecursionExecutionSeed
+}
+
+interface UiRecursionWorkingState {
+  channelId: number
+  currentValue: number
+  publicControlSlotExecutionId: number | null
+  executions: UiRecursionWorkingExecution[]
+  queuedInstantCompletions: readonly UiQueuedInstantCompletionRecursionEntry[]
+  guardedCancelListeners: UiRecursionWorkingCancelListener[]
+  nextUpdateSequence: number
+  cancelDeliveryOrdinal: number
+}
+
+function installRecursionSuccessor(
+  working: UiRecursionWorkingState,
+  successor: UiRecursionExecutionSeed,
+  role: Extract<
+    UiValueChannelRecursionEffect,
+    { readonly kind: 'INSTALL_RECURSION_EXECUTION' }
+  >['role'],
+  effects: UiValueChannelRecursionEffect[],
+): void {
+  if (working.publicControlSlotExecutionId !== null) {
+    stopRecursionControl(working, working.publicControlSlotExecutionId, 'REENTRANT_START', effects)
+  }
+  const updateSequence = working.nextUpdateSequence
+  working.nextUpdateSequence += 1
+  effects.push({
+    kind: 'INSTALL_RECURSION_EXECUTION',
+    executionId: successor.executionId,
+    commandSequence: successor.commandSequence,
+    updateSequence,
+    role,
+  })
+  working.executions.push({
+    ...successor,
+    updateSequence,
+    stopCount: 0,
+    phase: 'RUNNING',
+    orphaned: false,
+  })
+  working.publicControlSlotExecutionId = successor.executionId
+}
+
+function clearRecursionPublicSlotTokenBlind(
+  working: UiRecursionWorkingState,
+  source: 'INSTANT_COMPLETION' | 'STOP_CONTINUATION' | 'VALUE_COMPLETION',
+  sourceId: number,
+  effects: UiValueChannelRecursionEffect[],
+): void {
+  const clearedExecutionId = working.publicControlSlotExecutionId
+  effects.push({
+    kind: 'CLEAR_PUBLIC_CONTROL_SLOT_TOKEN_BLIND',
+    source,
+    sourceId,
+    clearedExecutionId,
+  })
+  if (clearedExecutionId !== null) {
+    const cleared = working.executions.find(
+      (candidate) => candidate.executionId === clearedExecutionId,
+    )
+    if (cleared !== undefined) cleared.orphaned = true
+  }
+  working.publicControlSlotExecutionId = null
+}
+
+function stopRecursionControl(
+  working: UiRecursionWorkingState,
+  controlExecutionId: number,
+  source: 'OUTER_OPERATION' | 'REENTRANT_START',
+  effects: UiValueChannelRecursionEffect[],
+): void {
+  const control = working.executions.find(
+    (candidate) => candidate.executionId === controlExecutionId,
+  )
+  if (control !== undefined) {
+    control.stopCount += 1
+    control.phase = 'STOPPED'
+    effects.push({
+      kind: 'STOP_EXECUTION_IDEMPOTENT',
+      executionId: controlExecutionId,
+      stopOrdinal: control.stopCount,
+      source,
+    })
+  }
+  for (const listener of working.guardedCancelListeners) {
+    if (listener.hasStartedSuccessor) continue
+    listener.hasStartedSuccessor = true
+    working.cancelDeliveryOrdinal += 1
+    effects.push({
+      kind: 'DELIVER_GUARDED_CANCEL_LISTENER',
+      listenerId: listener.listenerId,
+      cancelDeliveryOrdinal: working.cancelDeliveryOrdinal,
+    })
+    effects.push({
+      kind: 'ISSUE_REENTRANT_START_COMMAND',
+      executionId: listener.successor.executionId,
+      commandSequence: listener.successor.commandSequence,
+      source: 'GUARDED_CANCEL_LISTENER',
+      sourceId: listener.listenerId,
+    })
+    installRecursionSuccessor(working, listener.successor, 'CANCEL_LISTENER_SUCCESSOR', effects)
+  }
+  clearRecursionPublicSlotTokenBlind(working, 'STOP_CONTINUATION', controlExecutionId, effects)
+}
+
+export function advanceUiValueChannelRecursion(
+  state: UiValueChannelRecursionState,
+  event: UiValueChannelRecursionEvent,
+): UiValueChannelRecursionTransition {
+  const working: UiRecursionWorkingState = {
+    channelId: state.channelId,
+    currentValue: state.currentValue,
+    publicControlSlotExecutionId: state.publicControlSlotExecutionId,
+    executions: state.executions.map((execution) => ({ ...execution })),
+    queuedInstantCompletions: state.queuedInstantCompletions,
+    guardedCancelListeners: state.guardedCancelListeners.map((listener) => ({ ...listener })),
+    nextUpdateSequence: state.nextUpdateSequence,
+    cancelDeliveryOrdinal: 0,
+  }
+  const effects: UiValueChannelRecursionEffect[] = []
+  switch (event.kind) {
+    case 'drain-queued-instant-completions': {
+      for (const queued of working.queuedInstantCompletions) {
+        effects.push({
+          kind: 'DELIVER_QUEUED_INSTANT_COMPLETION',
+          completionId: queued.completionId,
+          completionSequence: queued.completionSequence,
+        })
+        effects.push({
+          kind: 'ISSUE_REENTRANT_START_COMMAND',
+          executionId: queued.callbackSuccessor.executionId,
+          commandSequence: queued.callbackSuccessor.commandSequence,
+          source: 'INSTANT_COMPLETION',
+          sourceId: queued.completionId,
+        })
+        installRecursionSuccessor(
+          working,
+          queued.callbackSuccessor,
+          'COMPLETION_SUCCESSOR',
+          effects,
+        )
+        clearRecursionPublicSlotTokenBlind(
+          working,
+          'INSTANT_COMPLETION',
+          queued.completionId,
+          effects,
+        )
+      }
+      working.queuedInstantCompletions = []
+      break
+    }
+    case 'apply-recursive-outer-stop': {
+      if (working.publicControlSlotExecutionId !== null) {
+        stopRecursionControl(
+          working,
+          working.publicControlSlotExecutionId,
+          'OUTER_OPERATION',
+          effects,
+        )
+      }
+      break
+    }
+    case 'apply-recursive-outer-jump': {
+      if (working.publicControlSlotExecutionId !== null) {
+        stopRecursionControl(
+          working,
+          working.publicControlSlotExecutionId,
+          'OUTER_OPERATION',
+          effects,
+        )
+      }
+      effects.push({ kind: 'APPLY_OUTER_JUMP', value: event.value })
+      working.currentValue = event.value
+      break
+    }
+    case 'apply-recursive-interrupting-start': {
+      if (working.publicControlSlotExecutionId !== null) {
+        stopRecursionControl(
+          working,
+          working.publicControlSlotExecutionId,
+          'OUTER_OPERATION',
+          effects,
+        )
+      }
+      installRecursionSuccessor(working, event.successor, 'INTERRUPTING_SUCCESSOR', effects)
+      break
+    }
+    case 'install-recursion-successor': {
+      installRecursionSuccessor(working, event.successor, 'LATER_LIVE_SUCCESSOR', effects)
+      break
+    }
+    case 'sample-runnable-recursion-executions': {
+      for (const execution of working.executions) {
+        if (execution.phase !== 'RUNNING') continue
+        effects.push({
+          kind: 'SAMPLE_RECURSION_EXECUTION',
+          executionId: execution.executionId,
+          updateSequence: execution.updateSequence,
+          value: execution.firstSampleValue,
+          absoluteTimestampMs: event.absoluteTimestampMs,
+          orphaned: execution.orphaned,
+        })
+        working.currentValue = execution.firstSampleValue
+      }
+      break
+    }
+    case 'complete-recursion-execution': {
+      const execution = working.executions.find(
+        (candidate) => candidate.executionId === event.executionId,
+      )
+      if (execution === undefined) {
+        throw new UiValueChannelInvariantError(
+          'recursion-event-kind-unrecognized',
+          'complete-recursion-execution',
+        )
+      }
+      execution.phase = 'COMPLETED'
+      effects.push({
+        kind: 'COMPLETE_RECURSION_EXECUTION',
+        executionId: event.executionId,
+        completionSequence: event.completionSequence,
+      })
+      clearRecursionPublicSlotTokenBlind(working, 'VALUE_COMPLETION', event.executionId, effects)
+      break
+    }
+    default: {
+      const exhaustive: never = event
+      void exhaustive
+      throw new UiValueChannelInvariantError('recursion-event-kind-unrecognized')
+    }
+  }
+  return {
+    state: {
+      channelId: working.channelId,
+      currentValue: working.currentValue,
+      publicControlSlotExecutionId: working.publicControlSlotExecutionId,
+      executions: working.executions,
+      queuedInstantCompletions: working.queuedInstantCompletions,
+      guardedCancelListeners: working.guardedCancelListeners,
+      nextUpdateSequence: working.nextUpdateSequence,
+    },
+    orderedEffects: effects,
+  }
+}