Set a single inline style property on the element, then flush.

setStyleProperty domRef "transform" "translateX(20px)"

Set several inline style properties, then flush once.

Set the element's transform from a list of typed TransformFns (from Miso.CSS), then flush — a typed alternative to writing the transform string by hand.

setStylePropertyTransform ref [ CSS.translateX (CSS.px 20) ]

Set an attribute on the element, then flush.

Read an attribute's current value from the element.

Commit pending element-tree mutations to the screen. The set* helpers above already flush; call this directly only when batching lower-level calls.

First element child of a node (Lynx __FirstElement). Lets a main-thread handler reach a different element than the event target by walking the tree — e.g. from a scroll handler's list ref to a sibling scrollbar thumb.

Next element sibling of a node (Lynx __NextElement).

Parent element of a node (Lynx __GetParent).

Drive step once per animation frame until it returns False, then release the underlying callback. step receives the frame timestamp in milliseconds.

This is the vsync-coalesced loop primitive for main-thread, scroll-linked animation: read the latest gesture state, imperatively paint at most once per frame (via setStyleProperty / setStylePropertyTransform), and stop by returning False when the gesture ends.

startFollow ref = eachFrame $ \_ts -> do
  d <- readDrag
  if not (active d) then pure False else do
    setStylePropertyTransform ref [ CSS.translateX (CSS.px (offset d)) ]
    pure True

Lynx's lynx.SystemInfo: device pixel geometry and platform metadata. The field names match the Lynx SystemInfo object, so it decodes directly. Fields that Lynx omits on some realms are Maybe — notably runtimeType, which is unavailable in the lepus (main-thread) runtime.

Read Lynx's lynx.SystemInfo, decoded into SystemInfo. This global is main-thread-only: present on the MTS realm and absent on the BTS realm, so this returns Just on the main thread and Nothing on the background thread. The undefined guard makes the background-thread read a safe Nothing rather than a throw; a decode failure (e.g. a required field missing) is also Nothing.

A thin wrapper over IORef for state that lives only on the main thread and must never reach the background thread's shared model (which the BTS solely owns — see Miso.Runtime). Use it for transient, main-thread-local gesture/animation state: the current drag offset, a fling velocity, whether a follow loop is active, etc.

Reads and writes are ordinary IORef operations, safe here because the MTS is single-threaded; no atomics are needed.

Create a top-level MainThreadRef with an initial value.

This uses unsafePerformIO to allocate the underlying IORef as a CAF, so the ref is shared across all uses of the binding. __You must give every top-level MainThreadRef binding a {-# NOINLINE #-} pragma__ — otherwise GHC may inline the CAF and allocate a fresh, independent IORef at each use site, silently splitting your state into multiple copies.

dragRef :: MainThreadRef Double
dragRef = mainThreadRef 0
{-# NOINLINE dragRef #-}

Read the current value of a MainThreadRef.

Overwrite the value of a MainThreadRef.

Strictly modify the value of a MainThreadRef.

Strictly modify a MainThreadRef with a State a () computation, letting you drive the update with the Miso.Lens operators (.=, %=, +=, …).

modifyMainThreadRef_ dragRef $ do
  offset .= newX
  active .= True