Propagation of changes to observables can now be deferred until the end of a code block.

observable/src/commonMain/kotlin/world/phantasmal/observable/Change.kt

@@ -0,0 +1,10 @@
+package world.phantasmal.observable
+
+/**
+ * Defer propagation of changes to observables until the end of a code block. All changes to
+ * observables in a single change set won't be propagated to their dependencies until the change set
+ * is completed.
+ */
+fun change(block: () -> Unit) {
+    ChangeManager.inChangeSet(block)
+}

observable/src/commonMain/kotlin/world/phantasmal/observable/ChangeManager.kt

@@ -0,0 +1,45 @@
+package world.phantasmal.observable
+
+object ChangeManager {
+    private var currentChangeSet: ChangeSet? = null
+
+    fun inChangeSet(block: () -> Unit) {
+        val existingChangeSet = currentChangeSet
+        val changeSet = existingChangeSet ?: ChangeSet().also {
+            currentChangeSet = it
+        }
+
+        try {
+            block()
+        } finally {
+            if (existingChangeSet == null) {
+                currentChangeSet = null
+                changeSet.complete()
+            }
+        }
+    }
+
+    fun changed(dependency: Dependency) {
+        val changeSet = currentChangeSet
+
+        if (changeSet == null) {
+            dependency.emitDependencyChanged()
+        } else {
+            changeSet.changed(dependency)
+        }
+    }
+}
+
+private class ChangeSet {
+    private val changedDependencies: MutableList<Dependency> = mutableListOf()
+
+    fun changed(dependency: Dependency) {
+        changedDependencies.add(dependency)
+    }
+
+    fun complete() {
+        for (dependency in changedDependencies) {
+            dependency.emitDependencyChanged()
+        }
+    }
+}

observable/src/commonMain/kotlin/world/phantasmal/observable/Dependency.kt

@@ -11,4 +11,9 @@ interface Dependency {
      * This method is not meant to be called from typical application code.
      */
     fun removeDependent(dependent: Dependent)
+
+    /**
+     * This method is not meant to be called from typical application code.
+     */
+    fun emitDependencyChanged()
 }

observable/src/commonMain/kotlin/world/phantasmal/observable/Observer.kt

@@ -1,6 +1,11 @@
 package world.phantasmal.observable
 
-open class ChangeEvent<out T>(val value: T) {
+open class ChangeEvent<out T>(
+    /**
+     * The observable's new value
+     */
+    val value: T,
+) {
     operator fun component1() = value
 }
 

observable/src/commonMain/kotlin/world/phantasmal/observable/SimpleEmitter.kt

@@ -3,16 +3,30 @@ package world.phantasmal.observable
 import world.phantasmal.core.disposable.Disposable
 
 class SimpleEmitter<T> : AbstractDependency(), Emitter<T> {
+    private var event: ChangeEvent<T>? = null
+
     override fun emit(event: ChangeEvent<T>) {
         for (dependent in dependents) {
             dependent.dependencyMightChange()
         }
 
-        for (dependent in dependents) {
+        this.event = event
-            dependent.dependencyChanged(this, event)
+
-        }
+        ChangeManager.changed(this)
     }
 
     override fun observe(observer: Observer<T>): Disposable =
         CallbackObserver(this, observer)
+
+    override fun emitDependencyChanged() {
+        if (event != null) {
+            try {
+                for (dependent in dependents) {
+                    dependent.dependencyChanged(this, event)
+                }
+            } finally {
+                event = null
+            }
+        }
+    }
 }

observable/src/commonMain/kotlin/world/phantasmal/observable/cell/AbstractCell.kt

@@ -32,11 +32,13 @@ abstract class AbstractCell<T> : AbstractDependency(), Cell<T> {
         }
     }
 
-    protected fun emitChanged(event: ChangeEvent<T>?) {
+    protected fun emitDependencyChanged(event: ChangeEvent<*>?) {
-        mightChangeEmitted = false
+        if (mightChangeEmitted) {
+            mightChangeEmitted = false
 
-        for (dependent in dependents) {
+            for (dependent in dependents) {
-            dependent.dependencyChanged(this, event)
+                dependent.dependencyChanged(this, event)
+            }
         }
     }
 }

observable/src/commonMain/kotlin/world/phantasmal/observable/cell/AbstractDependentCell.kt

@@ -24,10 +24,16 @@ abstract class AbstractDependentCell<T> : AbstractCell<T>(), Dependent {
 
                 dependenciesChanged()
             } else {
-                emitChanged(null)
+                emitDependencyChanged(null)
             }
         }
     }
 
-    abstract fun dependenciesChanged()
+    override fun emitDependencyChanged() {
+        // Nothing to do because dependent cells emit dependencyChanged immediately. They don't
+        // defer this operation because they only change when there is no transaction or the current
+        // transaction is being committed.
+    }
+
+    protected abstract fun dependenciesChanged()
 }

observable/src/commonMain/kotlin/world/phantasmal/observable/cell/DelegatingCell.kt

@@ -1,6 +1,7 @@
 package world.phantasmal.observable.cell
 
 import world.phantasmal.observable.ChangeEvent
+import world.phantasmal.observable.ChangeManager
 
 class DelegatingCell<T>(
     private val getter: () -> T,
@@ -16,7 +17,11 @@ class DelegatingCell<T>(
 
                 setter(value)
 
-                emitChanged(ChangeEvent(value))
+                ChangeManager.changed(this)
             }
         }
+
+    override fun emitDependencyChanged() {
+        emitDependencyChanged(ChangeEvent(value))
+    }
 }

observable/src/commonMain/kotlin/world/phantasmal/observable/cell/DependentCell.kt

@@ -50,9 +50,9 @@ class DependentCell<T>(
 
         if (newValue != _value) {
             _value = newValue
-            emitChanged(ChangeEvent(newValue))
+            emitDependencyChanged(ChangeEvent(newValue))
         } else {
-            emitChanged(null)
+            emitDependencyChanged(null)
         }
     }
 }

observable/src/commonMain/kotlin/world/phantasmal/observable/cell/FlatteningDependentCell.kt

@@ -82,9 +82,9 @@ class FlatteningDependentCell<T>(
 
         if (newValue != _value) {
             _value = newValue
-            emitChanged(ChangeEvent(newValue))
+            emitDependencyChanged(ChangeEvent(newValue))
         } else {
-            emitChanged(null)
+            emitDependencyChanged(null)
         }
     }
 }

observable/src/commonMain/kotlin/world/phantasmal/observable/cell/SimpleCell.kt

@@ -1,6 +1,7 @@
 package world.phantasmal.observable.cell
 
 import world.phantasmal.observable.ChangeEvent
+import world.phantasmal.observable.ChangeManager
 
 class SimpleCell<T>(value: T) : AbstractCell<T>(), MutableCell<T> {
     override var value: T = value
@@ -10,7 +11,11 @@ class SimpleCell<T>(value: T) : AbstractCell<T>(), MutableCell<T> {
 
                 field = value
 
-                emitChanged(ChangeEvent(value))
+                ChangeManager.changed(this)
             }
         }
+
+    override fun emitDependencyChanged() {
+        emitDependencyChanged(ChangeEvent(value))
+    }
 }

observable/src/commonMain/kotlin/world/phantasmal/observable/cell/StaticCell.kt

@@ -16,4 +16,8 @@ class StaticCell<T>(override val value: T) : AbstractDependency(), Cell<T> {
     }
 
     override fun observe(observer: Observer<T>): Disposable = nopDisposable()
+
+    override fun emitDependencyChanged() {
+        error("StaticCell can't change.")
+    }
 }

observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/AbstractDependentListCell.kt

@@ -57,7 +57,7 @@ abstract class AbstractDependentListCell<E> :
 
         computeElements()
 
-        emitChanged(
+        emitDependencyChanged(
             ListChangeEvent(elements, listOf(ListChange.Structural(0, oldElements, elements)))
         )
     }

observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/FilteredListCell.kt

@@ -179,15 +179,21 @@ class FilteredListCell<E>(
             }
 
             if (filteredChanges.isEmpty()) {
-                emitChanged(null)
+                emitDependencyChanged(null)
             } else {
-                emitChanged(ListChangeEvent(elements, filteredChanges))
+                emitDependencyChanged(ListChangeEvent(elements, filteredChanges))
             }
         } else {
-            emitChanged(null)
+            emitDependencyChanged(null)
         }
     }
 
+    override fun emitDependencyChanged() {
+        // Nothing to do because FilteredListCell emits dependencyChanged immediately. We don't
+        // defer this operation because FilteredListCell only changes when there is no transaction
+        // or the current transaction is being committed.
+    }
+
     private fun recompute() {
         val newElements = mutableListOf<E>()
         indexMap.clear()

observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/SimpleListCell.kt

@@ -5,6 +5,7 @@ import world.phantasmal.core.unsafe.unsafeAssertNotNull
 import world.phantasmal.observable.ChangeEvent
 import world.phantasmal.observable.Dependency
 import world.phantasmal.observable.Dependent
+import world.phantasmal.observable.ChangeManager
 
 typealias DependenciesExtractor<E> = (element: E) -> Array<Dependency>
 
@@ -27,7 +28,7 @@ class SimpleListCell<E>(
      */
     private val elementDependents = mutableListOf<ElementDependent>()
     private var changingElements = 0
-    private var elementListChanges = mutableListOf<ListChange.Element<E>>()
+    private var changes = mutableListOf<ListChange<E>>()
 
     override var value: List<E>
         get() = elements
@@ -50,12 +51,8 @@ class SimpleListCell<E>(
             elementDependents[index] = ElementDependent(index, element)
         }
 
-        emitChanged(
+        changes.add(ListChange.Structural(index, listOf(removed), listOf(element)))
-            ListChangeEvent(
+        ChangeManager.changed(this)
-                elements,
-                listOf(ListChange.Structural(index, listOf(removed), listOf(element))),
-            ),
-        )
 
         return removed
     }
@@ -180,6 +177,14 @@ class SimpleListCell<E>(
         }
     }
 
+    override fun emitDependencyChanged() {
+        try {
+            emitDependencyChanged(ListChangeEvent(elements, changes))
+        } finally {
+            changes = mutableListOf()
+        }
+    }
+
     private fun checkIndex(index: Int, maxIndex: Int) {
         if (index !in 0..maxIndex) {
             throw IndexOutOfBoundsException(
@@ -206,12 +211,8 @@ class SimpleListCell<E>(
             }
         }
 
-        emitChanged(
+        changes.add(ListChange.Structural(index, removed, inserted))
-            ListChangeEvent(
+        ChangeManager.changed(this)
-                elements,
-                listOf(ListChange.Structural(index, removed, inserted)),
-            ),
-        )
     }
 
     private inner class ElementDependent(
@@ -249,19 +250,11 @@ class SimpleListCell<E>(
             if (--changingDependencies == 0) {
                 if (dependenciesActuallyChanged) {
                     dependenciesActuallyChanged = false
-                    elementListChanges.add(ListChange.Element(index, element))
+                    changes.add(ListChange.Element(index, element))
                 }
 
                 if (--changingElements == 0) {
-                    try {
+                    ChangeManager.changed(this@SimpleListCell)
-                        if (elementListChanges.isNotEmpty()) {
-                            emitChanged(ListChangeEvent(value, elementListChanges))
-                        } else {
-                            emitChanged(null)
-                        }
-                    } finally {
-                        elementListChanges = mutableListOf()
-                    }
                 }
             }
         }

observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/StaticListCell.kt

@@ -45,4 +45,8 @@ class StaticListCell<E>(private val elements: List<E>) : AbstractDependency(), L
 
         return unsafeAssertNotNull(firstOrNull)
     }
+
+    override fun emitDependencyChanged() {
+        error("StaticListCell can't change.")
+    }
 }

observable/src/commonTest/kotlin/world/phantasmal/observable/cell/CellWithDependenciesTests.kt

@@ -36,6 +36,11 @@ interface CellWithDependenciesTests : CellTests {
             val publicDependents: List<Dependent> = dependents
 
             override val value: Int = 5
+
+            override fun emitDependencyChanged() {
+                // Not going to change.
+                throw NotImplementedError()
+            }
         }
 
         val cell = p.createWithDependencies(dependency)

observable/src/commonTest/kotlin/world/phantasmal/observable/cell/ChangeTests.kt

@@ -0,0 +1,37 @@
+package world.phantasmal.observable.cell
+
+import world.phantasmal.observable.change
+import world.phantasmal.observable.test.ObservableTestSuite
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFails
+
+class ChangeTests : ObservableTestSuite {
+    @Test
+    fun exceptions_during_a_change_set_are_allowed() = test {
+        val dependency = mutableCell(7)
+        val dependent = dependency.map { 2 * it }
+
+        var dependentObservedValue: Int? = null
+        disposer.add(dependent.observe { dependentObservedValue = it.value })
+
+        assertFails {
+            change {
+                dependency.value = 11
+                throw Exception()
+            }
+        }
+
+        // The change to dependency is still propagated because it happened before the exception.
+        assertEquals(22, dependentObservedValue)
+        assertEquals(22, dependent.value)
+
+        // The machinery behind change is still in a valid state.
+        change {
+            dependency.value = 13
+        }
+
+        assertEquals(26, dependentObservedValue)
+        assertEquals(26, dependent.value)
+    }
+}

observable/src/commonTest/kotlin/world/phantasmal/observable/cell/MutableCellTests.kt

@@ -1,5 +1,9 @@
 package world.phantasmal.observable.cell
 
+import world.phantasmal.observable.ChangeEvent
+import world.phantasmal.observable.Dependency
+import world.phantasmal.observable.Dependent
+import world.phantasmal.observable.change
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNull
@@ -25,12 +29,121 @@ interface MutableCellTests<T : Any> : CellTests {
         assertEquals(newValue, observedValue)
     }
 
+    /**
+     * Modifying mutable cells in a change set doesn't result in calls to
+     * [Dependent.dependencyChanged] of their dependents until the change set is completed.
+     */
+    @Test
+    fun cell_changes_in_change_set_dont_immediately_produce_dependencyChanged_calls() = test {
+        val dependencies = (1..5).map { createProvider() }
+
+        var dependencyMightChangeCount = 0
+        var dependencyChangedCount = 0
+
+        val dependent = object : Dependent {
+            override fun dependencyMightChange() {
+                dependencyMightChangeCount++
+            }
+
+            override fun dependencyChanged(dependency: Dependency, event: ChangeEvent<*>?) {
+                dependencyChangedCount++
+            }
+        }
+
+        for (dependency in dependencies) {
+            dependency.observable.addDependent(dependent)
+        }
+
+        change {
+            for (dependency in dependencies) {
+                dependency.observable.value = dependency.createValue()
+            }
+
+            // Calls to dependencyMightChange happen immediately.
+            assertEquals(dependencies.size, dependencyMightChangeCount)
+            // Calls to dependencyChanged happen later.
+            assertEquals(0, dependencyChangedCount)
+        }
+
+        assertEquals(dependencies.size, dependencyMightChangeCount)
+        assertEquals(dependencies.size, dependencyChangedCount)
+    }
+
+    /**
+     * Modifying a mutable cell multiple times in one change set results in a single call to
+     * [Dependent.dependencyMightChange] and [Dependent.dependencyChanged].
+     */
+    @Test
+    fun multiple_changes_to_one_cell_in_change_set() = test {
+        val dependency = createProvider()
+
+        var dependencyMightChangeCount = 0
+        var dependencyChangedCount = 0
+
+        val dependent = object : Dependent {
+            override fun dependencyMightChange() {
+                dependencyMightChangeCount++
+            }
+
+            override fun dependencyChanged(dependency: Dependency, event: ChangeEvent<*>?) {
+                dependencyChangedCount++
+            }
+        }
+
+        dependency.observable.addDependent(dependent)
+
+        // Change the dependency multiple times in a transaction.
+        change {
+            repeat(5) {
+                dependency.observable.value = dependency.createValue()
+            }
+
+            // Calls to dependencyMightChange happen immediately.
+            assertEquals(1, dependencyMightChangeCount)
+            // Calls to dependencyChanged happen later.
+            assertEquals(0, dependencyChangedCount)
+        }
+
+        assertEquals(1, dependencyMightChangeCount)
+        assertEquals(1, dependencyChangedCount)
+    }
+
+    /**
+     * Modifying two mutable cells in a change set results in a single recomputation of their
+     * dependent.
+     */
+    @Test
+    fun modifying_two_cells_together_results_in_one_recomputation() = test {
+        val dependency1 = createProvider()
+        val dependency2 = createProvider()
+
+        var computeCount = 0
+
+        val dependent = DependentCell(dependency1.observable, dependency2.observable) {
+            computeCount++
+            Unit
+        }
+
+        // Observe dependent to ensure it gets recomputed when its dependencies change.
+        disposer.add(dependent.observe {})
+
+        // DependentCell's compute function is called once when we start observing.
+        assertEquals(1, computeCount)
+
+        change {
+            dependency1.observable.value = dependency1.createValue()
+            dependency2.observable.value = dependency2.createValue()
+        }
+
+        assertEquals(2, computeCount)
+    }
+
     interface Provider<T : Any> : CellTests.Provider {
         override val observable: MutableCell<T>
 
         /**
          * Returns a value that can be assigned to [observable] and that's different from
-         * [observable]'s current value.
+         * [observable]'s current and all previous values.
          */
         fun createValue(): T
     }

web/src/main/kotlin/world/phantasmal/web/questEditor/actions/CreateEntityAction.kt

@@ -1,5 +1,6 @@
 package world.phantasmal.web.questEditor.actions
 
+import world.phantasmal.observable.change
 import world.phantasmal.web.core.actions.Action
 import world.phantasmal.web.questEditor.models.QuestEntityModel
 import world.phantasmal.web.questEditor.models.QuestModel
@@ -12,8 +13,10 @@ class CreateEntityAction(
     override val description: String = "Add ${entity.type.name}"
 
     override fun execute() {
-        quest.addEntity(entity)
+        change {
-        setSelectedEntity(entity)
+            quest.addEntity(entity)
+            setSelectedEntity(entity)
+        }
     }
 
     override fun undo() {

web/src/main/kotlin/world/phantasmal/web/questEditor/actions/CreateEventAction.kt

@@ -1,5 +1,6 @@
 package world.phantasmal.web.questEditor.actions
 
+import world.phantasmal.observable.change
 import world.phantasmal.web.core.actions.Action
 import world.phantasmal.web.questEditor.models.QuestEventModel
 import world.phantasmal.web.questEditor.models.QuestModel
@@ -13,12 +14,16 @@ class CreateEventAction(
     override val description: String = "Add event ${event.id.value}"
 
     override fun execute() {
-        quest.addEvent(index, event)
+        change {
-        setSelectedEvent(event)
+            quest.addEvent(index, event)
+            setSelectedEvent(event)
+        }
     }
 
     override fun undo() {
-        setSelectedEvent(null)
+        change {
-        quest.removeEvent(event)
+            setSelectedEvent(null)
+            quest.removeEvent(event)
+        }
     }
 }

web/src/main/kotlin/world/phantasmal/web/questEditor/actions/CreateEventActionAction.kt

@@ -1,5 +1,6 @@
 package world.phantasmal.web.questEditor.actions
 
+import world.phantasmal.observable.change
 import world.phantasmal.web.core.actions.Action
 import world.phantasmal.web.questEditor.models.QuestEventActionModel
 import world.phantasmal.web.questEditor.models.QuestEventModel
@@ -16,12 +17,16 @@ class CreateEventActionAction(
         "Add ${action.shortName} action to event ${event.id.value}"
 
     override fun execute() {
-        event.addAction(action)
+        change {
-        setSelectedEvent(event)
+            event.addAction(action)
+            setSelectedEvent(event)
+        }
     }
 
     override fun undo() {
-        event.removeAction(action)
+        change {
-        setSelectedEvent(event)
+            event.removeAction(action)
+            setSelectedEvent(event)
+        }
     }
 }

web/src/main/kotlin/world/phantasmal/web/questEditor/actions/DeleteEntityAction.kt

@@ -1,5 +1,6 @@
 package world.phantasmal.web.questEditor.actions
 
+import world.phantasmal.observable.change
 import world.phantasmal.web.core.actions.Action
 import world.phantasmal.web.questEditor.models.QuestEntityModel
 import world.phantasmal.web.questEditor.models.QuestModel
@@ -8,7 +9,7 @@ class DeleteEntityAction(
     private val setSelectedEntity: (QuestEntityModel<*, *>) -> Unit,
     private val quest: QuestModel,
     private val entity: QuestEntityModel<*, *>,
-) :Action{
+) : Action {
     override val description: String = "Delete ${entity.type.name}"
 
     override fun execute() {
@@ -16,7 +17,9 @@ class DeleteEntityAction(
     }
 
     override fun undo() {
-        quest.addEntity(entity)
+        change {
-        setSelectedEntity(entity)
+            quest.addEntity(entity)
+            setSelectedEntity(entity)
+        }
     }
 }

web/src/main/kotlin/world/phantasmal/web/questEditor/actions/DeleteEventAction.kt

@@ -1,5 +1,6 @@
 package world.phantasmal.web.questEditor.actions
 
+import world.phantasmal.observable.change
 import world.phantasmal.web.core.actions.Action
 import world.phantasmal.web.questEditor.models.QuestEventModel
 import world.phantasmal.web.questEditor.models.QuestModel
@@ -13,12 +14,16 @@ class DeleteEventAction(
     override val description: String = "Delete event ${event.id.value}"
 
     override fun execute() {
-        setSelectedEvent(null)
+        change {
-        quest.removeEvent(event)
+            setSelectedEvent(null)
+            quest.removeEvent(event)
+        }
     }
 
     override fun undo() {
-        quest.addEvent(index, event)
+        change {
-        setSelectedEvent(event)
+            quest.addEvent(index, event)
+            setSelectedEvent(event)
+        }
     }
 }

web/src/main/kotlin/world/phantasmal/web/questEditor/actions/DeleteEventActionAction.kt

@@ -1,5 +1,6 @@
 package world.phantasmal.web.questEditor.actions
 
+import world.phantasmal.observable.change
 import world.phantasmal.web.core.actions.Action
 import world.phantasmal.web.questEditor.models.QuestEventActionModel
 import world.phantasmal.web.questEditor.models.QuestEventModel
@@ -17,12 +18,16 @@ class DeleteEventActionAction(
         "Remove ${action.shortName} action from event ${event.id.value}"
 
     override fun execute() {
-        setSelectedEvent(event)
+        change {
-        event.removeAction(action)
+            setSelectedEvent(event)
+            event.removeAction(action)
+        }
     }
 
     override fun undo() {
-        setSelectedEvent(event)
+        change {
-        event.addAction(index, action)
+            setSelectedEvent(event)
+            event.addAction(index, action)
+        }
     }
 }

web/src/main/kotlin/world/phantasmal/web/questEditor/actions/EditEntityPropAction.kt

@@ -1,5 +1,6 @@
 package world.phantasmal.web.questEditor.actions
 
+import world.phantasmal.observable.change
 import world.phantasmal.web.core.actions.Action
 import world.phantasmal.web.questEditor.models.QuestEntityModel
 import world.phantasmal.web.questEditor.models.QuestEntityPropModel
@@ -14,12 +15,16 @@ class EditEntityPropAction(
     override val description: String = "Edit ${entity.type.simpleName} ${prop.name}"
 
     override fun execute() {
-        setSelectedEntity(entity)
+        change {
-        prop.setValue(newValue)
+            setSelectedEntity(entity)
+            prop.setValue(newValue)
+        }
     }
 
     override fun undo() {
-        setSelectedEntity(entity)
+        change {
-        prop.setValue(oldValue)
+            setSelectedEntity(entity)
+            prop.setValue(oldValue)
+        }
     }
 }

web/src/main/kotlin/world/phantasmal/web/questEditor/actions/EditEventPropertyAction.kt

@@ -1,5 +1,6 @@
 package world.phantasmal.web.questEditor.actions
 
+import world.phantasmal.observable.change
 import world.phantasmal.web.core.actions.Action
 import world.phantasmal.web.questEditor.models.QuestEventModel
 
@@ -12,12 +13,16 @@ class EditEventPropertyAction<T>(
     private val oldValue: T,
 ) : Action {
     override fun execute() {
-        setSelectedEvent(event)
+        change {
-        setter(newValue)
+            setSelectedEvent(event)
+            setter(newValue)
+        }
     }
 
     override fun undo() {
-        setSelectedEvent(event)
+        change {
-        setter(oldValue)
+            setSelectedEvent(event)
+            setter(oldValue)
+        }
     }
 }

web/src/main/kotlin/world/phantasmal/web/questEditor/actions/RotateEntityAction.kt

@@ -1,5 +1,6 @@
 package world.phantasmal.web.questEditor.actions
 
+import world.phantasmal.observable.change
 import world.phantasmal.web.core.actions.Action
 import world.phantasmal.web.externals.three.Euler
 import world.phantasmal.web.questEditor.models.QuestEntityModel
@@ -14,22 +15,26 @@ class RotateEntityAction(
     override val description: String = "Rotate ${entity.type.simpleName}"
 
     override fun execute() {
-        setSelectedEntity(entity)
+        change {
+            setSelectedEntity(entity)
 
-        if (world) {
+            if (world) {
-            entity.setWorldRotation(newRotation)
+                entity.setWorldRotation(newRotation)
-        } else {
+            } else {
-            entity.setRotation(newRotation)
+                entity.setRotation(newRotation)
+            }
         }
     }
 
     override fun undo() {
-        setSelectedEntity(entity)
+        change {
+            setSelectedEntity(entity)
 
-        if (world) {
+            if (world) {
-            entity.setWorldRotation(oldRotation)
+                entity.setWorldRotation(oldRotation)
-        } else {
+            } else {
-            entity.setRotation(oldRotation)
+                entity.setRotation(oldRotation)
+            }
         }
     }
 }

web/src/main/kotlin/world/phantasmal/web/questEditor/actions/TranslateEntityAction.kt

@@ -1,5 +1,6 @@
 package world.phantasmal.web.questEditor.actions
 
+import world.phantasmal.observable.change
 import world.phantasmal.web.core.actions.Action
 import world.phantasmal.web.externals.three.Vector3
 import world.phantasmal.web.questEditor.models.QuestEntityModel
@@ -16,18 +17,22 @@ class TranslateEntityAction(
     override val description: String = "Move ${entity.type.simpleName}"
 
     override fun execute() {
-        setSelectedEntity(entity)
+        change {
+            setSelectedEntity(entity)
 
-        newSection?.let(setEntitySection)
+            newSection?.let(setEntitySection)
 
-        entity.setPosition(newPosition)
+            entity.setPosition(newPosition)
+        }
     }
 
     override fun undo() {
-        setSelectedEntity(entity)
+        change {
+            setSelectedEntity(entity)
 
-        oldSection?.let(setEntitySection)
+            oldSection?.let(setEntitySection)
 
-        entity.setPosition(oldPosition)
+            entity.setPosition(oldPosition)
+        }
     }
 }

web/src/main/kotlin/world/phantasmal/web/questEditor/models/QuestEntityModel.kt

@@ -7,6 +7,7 @@ import world.phantasmal.observable.cell.Cell
 import world.phantasmal.observable.cell.list.ListCell
 import world.phantasmal.observable.cell.list.listCell
 import world.phantasmal.observable.cell.mutableCell
+import world.phantasmal.observable.change
 import world.phantasmal.web.core.minus
 import world.phantasmal.web.core.rendering.conversion.vec3ToEuler
 import world.phantasmal.web.core.rendering.conversion.vec3ToThree
@@ -60,11 +61,13 @@ abstract class QuestEntityModel<Type : EntityType, Entity : QuestEntity<Type>>(
     })
 
     open fun setSectionId(sectionId: Int) {
-        entity.sectionId = sectionId.toShort()
+        change {
-        _sectionId.value = sectionId
+            entity.sectionId = sectionId.toShort()
+            _sectionId.value = sectionId
 
-        if (sectionId != _section.value?.id) {
+            if (sectionId != _section.value?.id) {
-            _section.value = null
+                _section.value = null
+            }
         }
     }
 
@@ -81,87 +84,97 @@ abstract class QuestEntityModel<Type : EntityType, Entity : QuestEntity<Type>>(
             "Quest entities can't be moved across areas."
         }
 
-        entity.sectionId = section.id.toShort()
+        change {
-        _sectionId.value = section.id
+            entity.sectionId = section.id.toShort()
+            _sectionId.value = section.id
 
-        _section.value = section
+            _section.value = section
 
-        if (keepRelativeTransform) {
+            if (keepRelativeTransform) {
-            // Update world position and rotation by calling setPosition and setRotation with the
+                // Update world position and rotation by calling setPosition and setRotation with the
-            // current position and rotation.
+                // current position and rotation.
-            setPosition(position.value)
+                setPosition(position.value)
-            setRotation(rotation.value)
+                setRotation(rotation.value)
-        } else {
+            } else {
-            // Update relative position and rotation by calling setWorldPosition and
+                // Update relative position and rotation by calling setWorldPosition and
-            // setWorldRotation with the current world position and rotation.
+                // setWorldRotation with the current world position and rotation.
-            setWorldPosition(worldPosition.value)
+                setWorldPosition(worldPosition.value)
-            setWorldRotation(worldRotation.value)
+                setWorldRotation(worldRotation.value)
+            }
+
+            setSectionInitialized()
         }
-
-        setSectionInitialized()
     }
 
     fun setPosition(pos: Vector3) {
-        entity.setPosition(pos.x.toFloat(), pos.y.toFloat(), pos.z.toFloat())
+        change {
+            entity.setPosition(pos.x.toFloat(), pos.y.toFloat(), pos.z.toFloat())
 
-        _position.value = pos
+            _position.value = pos
 
-        val section = section.value
+            val section = section.value
 
-        _worldPosition.value =
+            _worldPosition.value =
-            if (section == null) pos
+                if (section == null) pos
-            else pos.clone().applyEuler(section.rotation).add(section.position)
+                else pos.clone().applyEuler(section.rotation).add(section.position)
+        }
     }
 
     fun setWorldPosition(pos: Vector3) {
-        val section = section.value
+        change {
+            val section = section.value
 
-        val relPos =
+            val relPos =
-            if (section == null) pos
+                if (section == null) pos
-            else (pos - section.position).applyEuler(section.inverseRotation)
+                else (pos - section.position).applyEuler(section.inverseRotation)
 
-        entity.setPosition(relPos.x.toFloat(), relPos.y.toFloat(), relPos.z.toFloat())
+            entity.setPosition(relPos.x.toFloat(), relPos.y.toFloat(), relPos.z.toFloat())
 
-        _worldPosition.value = pos
+            _worldPosition.value = pos
-        _position.value = relPos
+            _position.value = relPos
+        }
     }
 
     fun setRotation(rot: Euler) {
-        floorModEuler(rot)
+        change {
+            floorModEuler(rot)
 
-        entity.setRotation(rot.x.toFloat(), rot.y.toFloat(), rot.z.toFloat())
+            entity.setRotation(rot.x.toFloat(), rot.y.toFloat(), rot.z.toFloat())
-        _rotation.value = rot
+            _rotation.value = rot
 
-        val section = section.value
+            val section = section.value
 
-        if (section == null) {
+            if (section == null) {
-            _worldRotation.value = rot
+                _worldRotation.value = rot
-        } else {
+            } else {
-            q1.setFromEuler(rot)
+                q1.setFromEuler(rot)
-            q2.setFromEuler(section.rotation)
+                q2.setFromEuler(section.rotation)
-            q1 *= q2
+                q1 *= q2
-            _worldRotation.value = floorModEuler(q1.toEuler())
+                _worldRotation.value = floorModEuler(q1.toEuler())
+            }
         }
     }
 
     fun setWorldRotation(rot: Euler) {
-        floorModEuler(rot)
+        change {
+            floorModEuler(rot)
 
-        val section = section.value
+            val section = section.value
 
-        val relRot = if (section == null) {
+            val relRot = if (section == null) {
-            rot
+                rot
-        } else {
+            } else {
-            q1.setFromEuler(rot)
+                q1.setFromEuler(rot)
-            q2.setFromEuler(section.rotation)
+                q2.setFromEuler(section.rotation)
-            q2.invert()
+                q2.invert()
-            q1 *= q2
+                q1 *= q2
-            floorModEuler(q1.toEuler())
+                floorModEuler(q1.toEuler())
+            }
+
+            entity.setRotation(relRot.x.toFloat(), relRot.y.toFloat(), relRot.z.toFloat())
+            _worldRotation.value = rot
+            _rotation.value = relRot
         }
-
-        entity.setRotation(relRot.x.toFloat(), relRot.y.toFloat(), relRot.z.toFloat())
-        _worldRotation.value = rot
-        _rotation.value = relRot
     }
 
     companion object {

web/src/main/kotlin/world/phantasmal/web/viewer/controllers/ViewerToolbarController.kt

@@ -15,6 +15,7 @@ import world.phantasmal.lib.fileFormats.parseAreaCollisionGeometry
 import world.phantasmal.lib.fileFormats.parseAreaRenderGeometry
 import world.phantasmal.observable.cell.Cell
 import world.phantasmal.observable.cell.mutableCell
+import world.phantasmal.observable.change
 import world.phantasmal.web.core.files.cursor
 import world.phantasmal.web.viewer.stores.NinjaGeometry
 import world.phantasmal.web.viewer.stores.ViewerStore
@@ -75,11 +76,11 @@ class ViewerToolbarController(private val store: ViewerStore) : Controller() {
         val result = PwResult.build<Unit>(logger)
         var success = false
 
-        try {
+        var ninjaGeometry: NinjaGeometry? = null
-            var ninjaGeometry: NinjaGeometry? = null
+        var textures: List<XvrTexture>? = null
-            var textures: List<XvrTexture>? = null
+        var ninjaMotion: NjMotion? = null
-            var ninjaMotion: NjMotion? = null
 
+        try {
             for (file in files) {
                 val extension = file.extension()?.toLowerCase()
 
@@ -92,7 +93,8 @@ class ViewerToolbarController(private val store: ViewerStore) : Controller() {
                         fileResult = njResult
 
                         if (njResult is Success) {
-                            ninjaGeometry = njResult.value.firstOrNull()?.let(NinjaGeometry::Object)
+                            ninjaGeometry =
+                                njResult.value.firstOrNull()?.let(NinjaGeometry::Object)
                         }
                     }
 
@@ -101,7 +103,8 @@ class ViewerToolbarController(private val store: ViewerStore) : Controller() {
                         fileResult = xjResult
 
                         if (xjResult is Success) {
-                            ninjaGeometry = xjResult.value.firstOrNull()?.let(NinjaGeometry::Object)
+                            ninjaGeometry =
+                                xjResult.value.firstOrNull()?.let(NinjaGeometry::Object)
                         }
                     }
 
@@ -157,15 +160,17 @@ class ViewerToolbarController(private val store: ViewerStore) : Controller() {
                     success = true
                 }
             }
-
-            ninjaGeometry?.let(store::setCurrentNinjaGeometry)
-            textures?.let(store::setCurrentTextures)
-            ninjaMotion?.let(store::setCurrentNinjaMotion)
         } catch (e: Exception) {
             result.addProblem(Severity.Error, "Couldn't parse files.", cause = e)
         }
 
-        setResult(if (success) result.success(Unit) else result.failure())
+        change {
+            ninjaGeometry?.let(store::setCurrentNinjaGeometry)
+            textures?.let(store::setCurrentTextures)
+            ninjaMotion?.let(store::setCurrentNinjaMotion)
+
+            setResult(if (success) result.success(Unit) else result.failure())
+        }
     }
 
     fun dismissResultDialog() {

web/src/main/kotlin/world/phantasmal/web/viewer/stores/ViewerStore.kt

@@ -14,6 +14,7 @@ import world.phantasmal.observable.cell.and
 import world.phantasmal.observable.cell.list.ListCell
 import world.phantasmal.observable.cell.list.mutableListCell
 import world.phantasmal.observable.cell.mutableCell
+import world.phantasmal.observable.change
 import world.phantasmal.web.core.PwToolType
 import world.phantasmal.web.core.rendering.conversion.PSO_FRAME_RATE
 import world.phantasmal.web.core.stores.UiStore
@@ -163,14 +164,16 @@ class ViewerStore(
     }
 
     fun setCurrentNinjaGeometry(geometry: NinjaGeometry?) {
-        if (_currentCharacterClass.value != null) {
+        change {
-            _currentCharacterClass.value = null
+            if (_currentCharacterClass.value != null) {
-            _currentTextures.clear()
+                _currentCharacterClass.value = null
-        }
+                _currentTextures.clear()
+            }
 
-        _currentAnimation.value = null
+            _currentAnimation.value = null
-        _currentNinjaMotion.value = null
+            _currentNinjaMotion.value = null
-        _currentNinjaGeometry.value = geometry
+            _currentNinjaGeometry.value = geometry
+        }
     }
 
     fun setCurrentTextures(textures: List<XvrTexture>) {
@@ -200,8 +203,10 @@ class ViewerStore(
     }
 
     fun setCurrentNinjaMotion(njm: NjMotion) {
-        _currentNinjaMotion.value = njm
+        change {
-        _animationPlaying.value = true
+            _currentNinjaMotion.value = njm
+            _animationPlaying.value = true
+        }
     }
 
     suspend fun setCurrentAnimation(animation: AnimationModel?) {
@@ -244,34 +249,41 @@ class ViewerStore(
         val char = currentCharacterClass.value
             ?: return
 
-        val sectionId = currentSectionId.value
-        val body = currentBody.value
-
         try {
+            val sectionId = currentSectionId.value
+            val body = currentBody.value
             val ninjaObject = characterClassAssetLoader.loadNinjaObject(char)
             val textures = characterClassAssetLoader.loadXvrTextures(char, sectionId, body)
 
-            if (clearAnimation) {
+            change {
-                _currentAnimation.value = null
+                if (clearAnimation) {
-                _currentNinjaMotion.value = null
+                    _currentAnimation.value = null
-            }
+                    _currentNinjaMotion.value = null
+                }
 
-            _currentNinjaGeometry.value = NinjaGeometry.Object(ninjaObject)
+                _currentNinjaGeometry.value = NinjaGeometry.Object(ninjaObject)
-            _currentTextures.replaceAll(textures)
+                _currentTextures.replaceAll(textures)
+            }
         } catch (e: Exception) {
             logger.error(e) { "Couldn't load Ninja model for $char." }
 
-            _currentAnimation.value = null
+            change {
-            _currentNinjaMotion.value = null
+                _currentAnimation.value = null
-            _currentNinjaGeometry.value = null
+                _currentNinjaMotion.value = null
-            _currentTextures.clear()
+                _currentNinjaGeometry.value = null
+                _currentTextures.clear()
+            }
         }
     }
 
     private suspend fun loadAnimation(animation: AnimationModel) {
         try {
-            _currentNinjaMotion.value = animationAssetLoader.loadAnimation(animation.filePath)
+            val ninjaMotion = animationAssetLoader.loadAnimation(animation.filePath)
-            _animationPlaying.value = true
+
+            change {
+                _currentNinjaMotion.value = ninjaMotion
+                _animationPlaying.value = true
+            }
         } catch (e: Exception) {
             logger.error(e) {
                 "Couldn't load Ninja motion for ${animation.name} (path: ${animation.filePath})."

webui/src/main/kotlin/world/phantasmal/webui/dom/HTMLElementSizeCell.kt

@@ -63,6 +63,10 @@ class HTMLElementSizeCell(element: HTMLElement? = null) : AbstractCell<Size>() {
         }
     }
 
+    override fun emitDependencyChanged() {
+        error("HTMLElementSizeCell emits dependencyChanged immediately.")
+    }
+
     private fun getSize(): Size =
         element
             ?.let { Size(it.offsetWidth.toDouble(), it.offsetHeight.toDouble()) }
@@ -78,7 +82,7 @@ class HTMLElementSizeCell(element: HTMLElement? = null) : AbstractCell<Size>() {
         if (newValue != _value) {
             emitMightChange()
             _value = newValue
-            emitChanged(ChangeEvent(newValue))
+            emitDependencyChanged(ChangeEvent(newValue))
         }
     }
 }