Turned most cell convenience methods into extension methods to avoid circular dependencies between different cell implementations. Added simple implementation of ListCell<E>.sortedWith and ListCell<E>.filtered with predicate cell.

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

@@ -19,33 +19,4 @@ interface Cell<out T> : Observable<T> {
      * @param callNow Call [observer] immediately with the current [value].
      */
     fun observe(callNow: Boolean = false, observer: Observer<T>): Disposable
-
-    /**
-     * Map a transformation function over this cell.
-     *
-     * @param transform called whenever this cell changes
-     */
-    fun <R> map(transform: (T) -> R): Cell<R> =
-        DependentCell(this) { transform(value) }
-
-    fun <R> mapToList(transform: (T) -> List<R>): ListCell<R> =
-        DependentListCell(this) { transform(value) }
-
-    /**
-     * Map a transformation function that returns a cell over this cell. The resulting cell will
-     * change when this cell changes and when the cell returned by [transform] changes.
-     *
-     * @param transform called whenever this cell changes
-     */
-    fun <R> flatMap(transform: (T) -> Cell<R>): Cell<R> =
-        FlatteningDependentCell(this) { transform(value) }
-
-    fun <R> flatMapNull(transform: (T) -> Cell<R>?): Cell<R?> =
-        FlatteningDependentCell(this) { transform(value) ?: nullCell() }
-
-    fun isNull(): Cell<Boolean> =
-        map { it == null }
-
-    fun isNotNull(): Cell<Boolean> =
-        map { it != null }
 }

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

@@ -36,6 +36,16 @@ fun <T> mutableCell(value: T): MutableCell<T> = SimpleCell(value)
 fun <T> mutableCell(getter: () -> T, setter: (T) -> Unit): MutableCell<T> =
     DelegatingCell(getter, setter)
 
+/**
+ * Map a transformation function over this cell.
+ *
+ * @param transform called whenever this cell changes
+ */
+fun <T, R> Cell<T>.map(
+    transform: (T) -> R,
+): Cell<R> =
+    DependentCell(this) { transform(value) }
+
 /**
  * Map a transformation function over 2 cells.
  *
@@ -61,6 +71,20 @@ fun <T1, T2, T3, R> map(
 ): Cell<R> =
     DependentCell(c1, c2, c3) { transform(c1.value, c2.value, c3.value) }
 
+fun <T> Cell<Cell<T>>.flatten(): Cell<T> =
+    FlatteningDependentCell(this) { this.value }
+
+/**
+ * Map a transformation function that returns a cell over this cell. The resulting cell will
+ * change when this cell changes and when the cell returned by [transform] changes.
+ *
+ * @param transform called whenever this cell changes
+ */
+fun <T, R> Cell<T>.flatMap(
+    transform: (T) -> Cell<R>,
+): Cell<R> =
+    FlatteningDependentCell(this) { transform(value) }
+
 /**
  * Map a transformation function that returns a cell over 2 cells. The resulting cell will change
  * when either cell changes and also when the cell returned by [transform] changes.
@@ -74,5 +98,74 @@ fun <T1, T2, R> flatMap(
 ): Cell<R> =
     FlatteningDependentCell(c1, c2) { transform(c1.value, c2.value) }
 
+fun <T, R> Cell<T>.flatMapNull(transform: (T) -> Cell<R>?): Cell<R?> =
+    FlatteningDependentCell(this) { transform(value) ?: nullCell() }
+
+fun Cell<*>.isNull(): Cell<Boolean> =
+    map { it == null }
+
+fun Cell<*>.isNotNull(): Cell<Boolean> =
+    map { it != null }
+
+infix fun <T> Cell<T>.eq(value: T): Cell<Boolean> =
+    map { it == value }
+
+infix fun <T> Cell<T>.eq(other: Cell<T>): Cell<Boolean> =
+    map(this, other) { a, b -> a == b }
+
+infix fun <T> Cell<T>.ne(value: T): Cell<Boolean> =
+    map { it != value }
+
+infix fun <T> Cell<T>.ne(other: Cell<T>): Cell<Boolean> =
+    map(this, other) { a, b -> a != b }
+
+fun <T> Cell<T?>.orElse(defaultValue: () -> T): Cell<T> =
+    map { it ?: defaultValue() }
+
+infix fun <T : Comparable<T>> Cell<T>.gt(value: T): Cell<Boolean> =
+    map { it > value }
+
+infix fun <T : Comparable<T>> Cell<T>.gt(other: Cell<T>): Cell<Boolean> =
+    map(this, other) { a, b -> a > b }
+
+infix fun <T : Comparable<T>> Cell<T>.lt(value: T): Cell<Boolean> =
+    map { it < value }
+
+infix fun <T : Comparable<T>> Cell<T>.lt(other: Cell<T>): Cell<Boolean> =
+    map(this, other) { a, b -> a < b }
+
 fun and(vararg cells: Cell<Boolean>): Cell<Boolean> =
     DependentCell(*cells) { cells.all { it.value } }
+
+infix fun Cell<Boolean>.and(other: Cell<Boolean>): Cell<Boolean> =
+    map(this, other) { a, b -> a && b }
+
+infix fun Cell<Boolean>.and(other: Boolean): Cell<Boolean> =
+    if (other) this else falseCell()
+
+infix fun Cell<Boolean>.or(other: Cell<Boolean>): Cell<Boolean> =
+    map(this, other) { a, b -> a || b }
+
+infix fun Cell<Boolean>.xor(other: Cell<Boolean>): Cell<Boolean> =
+    // Use != because of https://youtrack.jetbrains.com/issue/KT-31277.
+    map(this, other) { a, b -> a != b }
+
+operator fun Cell<Boolean>.not(): Cell<Boolean> = map { !it }
+
+operator fun Cell<Int>.plus(value: Int): Cell<Int> =
+    map { it + value }
+
+operator fun Cell<Int>.minus(value: Int): Cell<Int> =
+    map { it - value }
+
+fun Cell<String>.isEmpty(): Cell<Boolean> =
+    map { it.isEmpty() }
+
+fun Cell<String>.isNotEmpty(): Cell<Boolean> =
+    map { it.isNotEmpty() }
+
+fun Cell<String>.isBlank(): Cell<Boolean> =
+    map { it.isBlank() }
+
+fun Cell<String>.isNotBlank(): Cell<Boolean> =
+    map { it.isNotBlank() }

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

@@ -1,64 +0,0 @@
-package world.phantasmal.observable.cell
-
-infix fun <T> Cell<T>.eq(value: T): Cell<Boolean> =
-    map { it == value }
-
-infix fun <T> Cell<T>.eq(other: Cell<T>): Cell<Boolean> =
-    map(this, other) { a, b -> a == b }
-
-infix fun <T> Cell<T>.ne(value: T): Cell<Boolean> =
-    map { it != value }
-
-infix fun <T> Cell<T>.ne(other: Cell<T>): Cell<Boolean> =
-    map(this, other) { a, b -> a != b }
-
-fun <T> Cell<T?>.orElse(defaultValue: () -> T): Cell<T> =
-    map { it ?: defaultValue() }
-
-infix fun <T : Comparable<T>> Cell<T>.gt(value: T): Cell<Boolean> =
-    map { it > value }
-
-infix fun <T : Comparable<T>> Cell<T>.gt(other: Cell<T>): Cell<Boolean> =
-    map(this, other) { a, b -> a > b }
-
-infix fun <T : Comparable<T>> Cell<T>.lt(value: T): Cell<Boolean> =
-    map { it < value }
-
-infix fun <T : Comparable<T>> Cell<T>.lt(other: Cell<T>): Cell<Boolean> =
-    map(this, other) { a, b -> a < b }
-
-infix fun Cell<Boolean>.and(other: Cell<Boolean>): Cell<Boolean> =
-    map(this, other) { a, b -> a && b }
-
-infix fun Cell<Boolean>.and(other: Boolean): Cell<Boolean> =
-    if (other) this else falseCell()
-
-infix fun Cell<Boolean>.or(other: Cell<Boolean>): Cell<Boolean> =
-    map(this, other) { a, b -> a || b }
-
-infix fun Cell<Boolean>.xor(other: Cell<Boolean>): Cell<Boolean> =
-    // Use != because of https://youtrack.jetbrains.com/issue/KT-31277.
-    map(this, other) { a, b -> a != b }
-
-operator fun Cell<Boolean>.not(): Cell<Boolean> = map { !it }
-
-operator fun Cell<Int>.plus(value: Int): Cell<Int> =
-    map { it + value }
-
-operator fun Cell<Int>.minus(value: Int): Cell<Int> =
-    map { it - value }
-
-fun Cell<String>.isEmpty(): Cell<Boolean> =
-    map { it.isEmpty() }
-
-fun Cell<String>.isNotEmpty(): Cell<Boolean> =
-    map { it.isNotEmpty() }
-
-fun Cell<String>.isBlank(): Cell<Boolean> =
-    map { it.isBlank() }
-
-fun Cell<String>.isNotBlank(): Cell<Boolean> =
-    map { it.isNotBlank() }
-
-fun <T> Cell<Cell<T>>.flatten(): Cell<T> =
-    FlatteningDependentCell(this) { this.value }

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

@@ -35,7 +35,7 @@ abstract class AbstractListCell<E> : AbstractCell<List<E>>(), ListCell<E> {
     @Suppress("LeakingThis")
     final override val size: Cell<Int> = DependentCell(this) { value.size }
 
-    final override val empty: Cell<Boolean> = size.map { it == 0 }
+    final override val empty: Cell<Boolean> = DependentCell(size) { size.value == 0 }
 
     final override val notEmpty: Cell<Boolean> = !empty
 

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

@@ -2,15 +2,15 @@ package world.phantasmal.observable.cell.list
 
 import world.phantasmal.core.disposable.Disposable
 import world.phantasmal.core.disposable.nopDisposable
-import world.phantasmal.core.unsafe.unsafeAssertNotNull
 import world.phantasmal.observable.AbstractDependency
 import world.phantasmal.observable.ChangeEvent
 import world.phantasmal.observable.Observer
-import world.phantasmal.observable.cell.*
+import world.phantasmal.observable.cell.Cell
+import world.phantasmal.observable.cell.cell
+import world.phantasmal.observable.cell.falseCell
+import world.phantasmal.observable.cell.trueCell
 
 class ImmutableListCell<E>(private val elements: List<E>) : AbstractDependency(), ListCell<E> {
-    private var firstOrNull: Cell<E?>? = null
-
     override val size: Cell<Int> = cell(elements.size)
     override val empty: Cell<Boolean> = if (elements.isEmpty()) trueCell() else falseCell()
     override val notEmpty: Cell<Boolean> = if (elements.isNotEmpty()) trueCell() else falseCell()
@@ -38,14 +38,6 @@ class ImmutableListCell<E>(private val elements: List<E>) : AbstractDependency()
         return nopDisposable()
     }
 
-    override fun firstOrNull(): Cell<E?> {
-        if (firstOrNull == null) {
-            firstOrNull = ImmutableCell(elements.firstOrNull())
-        }
-
-        return unsafeAssertNotNull(firstOrNull)
-    }
-
     override fun emitDependencyChanged() {
         error("ImmutableListCell can't change.")
     }

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

@@ -2,13 +2,8 @@ package world.phantasmal.observable.cell.list
 
 import world.phantasmal.core.disposable.Disposable
 import world.phantasmal.observable.cell.Cell
-import world.phantasmal.observable.cell.DependentCell
 
 interface ListCell<out E> : Cell<List<E>> {
-    /**
-     * Do not keep long-lived references to a [ListCell]'s [value], it may or may not be mutated
-     * when the [ListCell] is mutated.
-     */
     override val value: List<E>
 
     val size: Cell<Int>
@@ -21,24 +16,5 @@ interface ListCell<out E> : Cell<List<E>> {
 
     fun observeList(callNow: Boolean = false, observer: ListObserver<E>): Disposable
 
-    // TODO: Optimize this.
-    fun <R> listMap(transform: (E) -> R): ListCell<R> =
-        DependentListCell(this) { value.map(transform) }
-
-    fun <R> fold(initialValue: R, operation: (R, E) -> R): Cell<R> =
-        DependentCell(this) { value.fold(initialValue, operation) }
-
-    fun all(predicate: (E) -> Boolean): Cell<Boolean> =
-        DependentCell(this) { value.all(predicate) }
-
-    fun sumOf(selector: (E) -> Int): Cell<Int> =
-        DependentCell(this) { value.sumOf(selector) }
-
-    fun filtered(predicate: (E) -> Boolean): ListCell<E> =
-        FilteredListCell(this, predicate)
-
-    fun firstOrNull(): Cell<E?> =
-        DependentCell(this) { value.firstOrNull() }
-
     operator fun contains(element: @UnsafeVariance E): Boolean = element in value
 }

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

@@ -1,6 +1,7 @@
 package world.phantasmal.observable.cell.list
 
 import world.phantasmal.observable.cell.Cell
+import world.phantasmal.observable.cell.DependentCell
 
 private val EMPTY_LIST_CELL = ImmutableListCell<Nothing>(emptyList())
 
@@ -17,6 +18,42 @@ fun <E> mutableListCell(
 ): MutableListCell<E> =
     SimpleListCell(mutableListOf(*elements), extractDependencies)
 
+fun <E, R> ListCell<E>.listMap(transform: (E) -> R): ListCell<R> =
+    DependentListCell(this) { value.map(transform) }
+
+fun <E, R> ListCell<E>.fold(initialValue: R, operation: (R, E) -> R): Cell<R> =
+    DependentCell(this) { value.fold(initialValue, operation) }
+
+fun <E> ListCell<E>.all(predicate: (E) -> Boolean): Cell<Boolean> =
+    DependentCell(this) { value.all(predicate) }
+
+fun <E> ListCell<E>.sumOf(selector: (E) -> Int): Cell<Int> =
+    DependentCell(this) { value.sumOf(selector) }
+
+fun <E> ListCell<E>.filtered(predicate: (E) -> Boolean): ListCell<E> =
+    FilteredListCell(this, predicate)
+
+fun <E> ListCell<E>.filtered(predicate: Cell<(E) -> Boolean>): ListCell<E> =
+    DependentListCell(this, predicate) { value.filter(predicate.value) }
+
+fun <E> ListCell<E>.sortedWith(comparator: Cell<Comparator<E>>): ListCell<E> =
+    DependentListCell(this, comparator) { value.sortedWith(comparator.value) }
+
+fun <E> ListCell<E>.firstOrNull(): Cell<E?> =
+    DependentCell(this) { value.firstOrNull() }
+
+fun <T, R> Cell<T>.mapToList(
+    transform: (T) -> List<R>,
+): ListCell<R> =
+    DependentListCell(this) { transform(value) }
+
+fun <T1, T2, R> mapToList(
+    c1: Cell<T1>,
+    c2: Cell<T2>,
+    transform: (T1, T2) -> List<R>,
+): ListCell<R> =
+    DependentListCell(c1, c2) { transform(c1.value, c2.value) }
+
 fun <T, R> Cell<T>.flatMapToList(
     transform: (T) -> ListCell<R>,
 ): ListCell<R> =

web/src/main/kotlin/world/phantasmal/web/core/undo/UndoManager.kt

@@ -1,6 +1,7 @@
 package world.phantasmal.web.core.undo
 
 import world.phantasmal.observable.cell.*
+import world.phantasmal.observable.cell.list.fold
 import world.phantasmal.observable.cell.list.mutableListCell
 import world.phantasmal.web.core.actions.Action
 

web/src/main/kotlin/world/phantasmal/web/huntOptimizer/controllers/MethodsForEpisodeController.kt

@@ -1,8 +1,10 @@
 package world.phantasmal.web.huntOptimizer.controllers
 
 import world.phantasmal.observable.cell.list.ListCell
+import world.phantasmal.observable.cell.list.filtered
 import world.phantasmal.observable.cell.list.listCell
-import world.phantasmal.observable.cell.list.mutableListCell
+import world.phantasmal.observable.cell.list.sortedWith
+import world.phantasmal.observable.cell.mutableCell
 import world.phantasmal.psolib.Episode
 import world.phantasmal.psolib.fileFormats.quest.NpcType
 import world.phantasmal.web.huntOptimizer.models.HuntMethodModel
@@ -18,47 +20,16 @@ class MethodsForEpisodeController(
     private val huntMethodStore: HuntMethodStore,
     episode: Episode,
 ) : TableController<HuntMethodModel>() {
-    private val methods = mutableListCell<HuntMethodModel>()
     private val enemies: List<NpcType> = NpcType.VALUES.filter { it.enemy && it.episode == episode }
 
-    private var sortColumns: List<SortColumn<HuntMethodModel>> = emptyList()
-
-    private val comparator: Comparator<HuntMethodModel> =
-        Comparator { a, b ->
-            for (sortColumn in sortColumns) {
-                val cmp = when (sortColumn.column.key) {
-                    METHOD_COL_KEY ->
-                        a.name.asDynamic().localeCompare(b.name).unsafeCast<Int>()
-
-                    TIME_COL_KEY -> a.time.value.compareTo(b.time.value)
-
-                    else -> {
-                        val type = NpcType.valueOf(sortColumn.column.key)
-                        (a.enemyCounts[type] ?: 0) - (b.enemyCounts[type] ?: 0)
-                    }
-                }
-
-                if (cmp != 0) {
-                    return@Comparator if (sortColumn.direction == SortDirection.Asc) cmp else -cmp
-                }
-            }
-
-            0
-        }
+    private val comparator = mutableCell(Comparator<HuntMethodModel> { _, _ -> 0 })
 
     override val fixedColumns = 2
 
     override val values: ListCell<HuntMethodModel> by lazy {
-        // TODO: Use ListCell.sortedWith when this is available.
-        observe(huntMethodStore.methods) { allMethods ->
-            methods.value = allMethods
-                .asSequence()
-                .filter { it.episode == episode }
-                .sortedWith(comparator)
-                .toList()
-        }
-
-        methods
+        huntMethodStore.methods
+            .filtered { it.episode == episode }
+            .sortedWith(comparator)
     }
 
     override val loadingStatus: LoadingStatusCell = huntMethodStore.methodsStatus
@@ -97,8 +68,27 @@ class MethodsForEpisodeController(
     )
 
     override fun sort(sortColumns: List<SortColumn<HuntMethodModel>>) {
-        this.sortColumns = sortColumns
-        methods.sortWith(comparator)
+        comparator.value = Comparator { a, b ->
+            for (sortColumn in sortColumns) {
+                val cmp = when (sortColumn.column.key) {
+                    METHOD_COL_KEY ->
+                        a.name.asDynamic().localeCompare(b.name).unsafeCast<Int>()
+
+                    TIME_COL_KEY -> a.time.value.compareTo(b.time.value)
+
+                    else -> {
+                        val type = NpcType.valueOf(sortColumn.column.key)
+                        (a.enemyCounts[type] ?: 0) - (b.enemyCounts[type] ?: 0)
+                    }
+                }
+
+                if (cmp != 0) {
+                    return@Comparator if (sortColumn.direction == SortDirection.Asc) cmp else -cmp
+                }
+            }
+
+            0
+        }
     }
 
     suspend fun setMethodTime(method: HuntMethodModel, time: Duration) {

web/src/main/kotlin/world/phantasmal/web/huntOptimizer/controllers/OptimizationResultController.kt

@@ -2,6 +2,7 @@ package world.phantasmal.web.huntOptimizer.controllers
 
 import world.phantasmal.observable.cell.cell
 import world.phantasmal.observable.cell.list.ListCell
+import world.phantasmal.observable.cell.list.mapToList
 import world.phantasmal.web.huntOptimizer.models.OptimalMethodModel
 import world.phantasmal.web.huntOptimizer.stores.HuntOptimizerStore
 import world.phantasmal.webui.controllers.Column

web/src/main/kotlin/world/phantasmal/web/huntOptimizer/controllers/WantedItemsController.kt

@@ -3,6 +3,7 @@ package world.phantasmal.web.huntOptimizer.controllers
 import world.phantasmal.observable.cell.Cell
 import world.phantasmal.observable.cell.MutableCell
 import world.phantasmal.observable.cell.list.ListCell
+import world.phantasmal.observable.cell.list.filtered
 import world.phantasmal.observable.cell.mutableCell
 import world.phantasmal.web.huntOptimizer.models.WantedItemModel
 import world.phantasmal.web.huntOptimizer.stores.HuntOptimizerStore
@@ -14,10 +15,8 @@ class WantedItemsController(
 ) : Controller() {
     private val selectableItemsFilter: MutableCell<(ItemType) -> Boolean> = mutableCell { true }
 
-    // TODO: Use ListCell.filtered with a Cell when this is supported.
-    val selectableItems: Cell<List<ItemType>> = selectableItemsFilter.flatMap { filter ->
-        huntOptimizerStore.huntableItems.filtered(filter)
-    }
+    val selectableItems: Cell<List<ItemType>> =
+        huntOptimizerStore.huntableItems.filtered(selectableItemsFilter)
 
     val wantedItems: ListCell<WantedItemModel> = huntOptimizerStore.wantedItems
 

web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/AsmEditorController.kt

@@ -1,10 +1,7 @@
 package world.phantasmal.web.questEditor.controllers
 
 import world.phantasmal.observable.Observable
-import world.phantasmal.observable.cell.Cell
-import world.phantasmal.observable.cell.not
-import world.phantasmal.observable.cell.or
-import world.phantasmal.observable.cell.orElse
+import world.phantasmal.observable.cell.*
 import world.phantasmal.web.externals.monacoEditor.ITextModel
 import world.phantasmal.web.externals.monacoEditor.createModel
 import world.phantasmal.web.questEditor.stores.AsmStore

web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/EntityInfoController.kt

@@ -2,13 +2,12 @@ package world.phantasmal.web.questEditor.controllers
 
 import world.phantasmal.core.math.degToRad
 import world.phantasmal.core.math.radToDeg
-import world.phantasmal.psolib.fileFormats.quest.EntityPropType
-import world.phantasmal.observable.cell.Cell
-import world.phantasmal.observable.cell.cell
+import world.phantasmal.observable.cell.*
 import world.phantasmal.observable.cell.list.ListCell
 import world.phantasmal.observable.cell.list.emptyListCell
 import world.phantasmal.observable.cell.list.flatMapToList
-import world.phantasmal.observable.cell.zeroIntCell
+import world.phantasmal.observable.cell.list.listMap
+import world.phantasmal.psolib.fileFormats.quest.EntityPropType
 import world.phantasmal.web.core.euler
 import world.phantasmal.web.externals.three.Euler
 import world.phantasmal.web.externals.three.Vector3

web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/EventsController.kt

@@ -1,8 +1,6 @@
 package world.phantasmal.web.questEditor.controllers
 
-import world.phantasmal.observable.cell.Cell
-import world.phantasmal.observable.cell.and
-import world.phantasmal.observable.cell.eq
+import world.phantasmal.observable.cell.*
 import world.phantasmal.observable.cell.list.ListCell
 import world.phantasmal.observable.cell.list.listCell
 import world.phantasmal.web.questEditor.actions.*

web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/NpcCountsController.kt

@@ -2,7 +2,10 @@ package world.phantasmal.web.questEditor.controllers
 
 import world.phantasmal.psolib.fileFormats.quest.NpcType
 import world.phantasmal.observable.cell.Cell
+import world.phantasmal.observable.cell.flatMap
+import world.phantasmal.observable.cell.isNull
 import world.phantasmal.observable.cell.list.emptyListCell
+import world.phantasmal.observable.cell.map
 import world.phantasmal.web.questEditor.models.QuestNpcModel
 import world.phantasmal.web.questEditor.stores.QuestEditorStore
 import world.phantasmal.webui.controllers.Controller

web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/QuestInfoController.kt

@@ -1,8 +1,6 @@
 package world.phantasmal.web.questEditor.controllers
 
-import world.phantasmal.observable.cell.Cell
-import world.phantasmal.observable.cell.cell
-import world.phantasmal.observable.cell.emptyStringCell
+import world.phantasmal.observable.cell.*
 import world.phantasmal.web.questEditor.actions.EditPropertyAction
 import world.phantasmal.web.questEditor.stores.QuestEditorStore
 import world.phantasmal.webui.controllers.Controller

web/src/main/kotlin/world/phantasmal/web/questEditor/rendering/QuestEditorMeshManager.kt

@@ -1,6 +1,8 @@
 package world.phantasmal.web.questEditor.rendering
 
+import world.phantasmal.observable.cell.flatMapNull
 import world.phantasmal.observable.cell.list.emptyListCell
+import world.phantasmal.observable.cell.list.filtered
 import world.phantasmal.web.questEditor.loading.AreaAssetLoader
 import world.phantasmal.web.questEditor.loading.EntityAssetLoader
 import world.phantasmal.web.questEditor.stores.QuestEditorStore

web/src/main/kotlin/world/phantasmal/web/questEditor/rendering/input/state/StateContext.kt

@@ -3,6 +3,7 @@ package world.phantasmal.web.questEditor.rendering.input.state
 import mu.KotlinLogging
 import world.phantasmal.core.asJsArray
 import world.phantasmal.observable.cell.Cell
+import world.phantasmal.observable.cell.flatMapNull
 import world.phantasmal.psolib.fileFormats.ninja.XjObject
 import world.phantasmal.web.core.dot
 import world.phantasmal.web.core.minusAssign

web/src/main/kotlin/world/phantasmal/web/questEditor/stores/QuestEditorStore.kt

@@ -6,6 +6,7 @@ import world.phantasmal.psolib.Episode
 import world.phantasmal.observable.cell.*
 import world.phantasmal.observable.cell.list.ListCell
 import world.phantasmal.observable.cell.list.emptyListCell
+import world.phantasmal.observable.cell.list.filtered
 import world.phantasmal.observable.cell.list.flatMapToList
 import world.phantasmal.web.core.PwToolType
 import world.phantasmal.web.core.actions.Action

web/src/main/kotlin/world/phantasmal/web/questEditor/undo/TextModelUndo.kt

@@ -4,10 +4,7 @@ import world.phantasmal.core.disposable.Disposable
 import world.phantasmal.core.disposable.TrackedDisposable
 import world.phantasmal.observable.ChangeEvent
 import world.phantasmal.observable.Observable
-import world.phantasmal.observable.cell.Cell
-import world.phantasmal.observable.cell.MutableCell
-import world.phantasmal.observable.cell.eq
-import world.phantasmal.observable.cell.mutableCell
+import world.phantasmal.observable.cell.*
 import world.phantasmal.observable.emitter
 import world.phantasmal.web.core.actions.Action
 import world.phantasmal.web.core.undo.Undo

web/src/main/kotlin/world/phantasmal/web/questEditor/widgets/EventWidget.kt

@@ -1,6 +1,7 @@
 package world.phantasmal.web.questEditor.widgets
 
 import org.w3c.dom.*
+import world.phantasmal.observable.cell.map
 import world.phantasmal.web.questEditor.controllers.EventsController
 import world.phantasmal.web.questEditor.models.QuestEventModel
 import world.phantasmal.webui.dom.*

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

@@ -1,6 +1,8 @@
 package world.phantasmal.web.viewer.controllers
 
 import world.phantasmal.observable.cell.Cell
+import world.phantasmal.observable.cell.isNotNull
+import world.phantasmal.observable.cell.map
 import world.phantasmal.observable.cell.plus
 import world.phantasmal.web.shared.dto.SectionId
 import world.phantasmal.web.viewer.stores.ViewerStore

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

@@ -14,6 +14,8 @@ import world.phantasmal.psolib.fileFormats.parseAfs
 import world.phantasmal.psolib.fileFormats.parseAreaCollisionGeometry
 import world.phantasmal.psolib.fileFormats.parseAreaRenderGeometry
 import world.phantasmal.observable.cell.Cell
+import world.phantasmal.observable.cell.isNotNull
+import world.phantasmal.observable.cell.map
 import world.phantasmal.observable.cell.mutableCell
 import world.phantasmal.observable.change
 import world.phantasmal.web.core.files.cursor

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

@@ -13,6 +13,7 @@ import world.phantasmal.observable.cell.Cell
 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.map
 import world.phantasmal.observable.cell.mutableCell
 import world.phantasmal.observable.change
 import world.phantasmal.web.core.PwToolType

webui/src/main/kotlin/world/phantasmal/webui/widgets/ResultDialog.kt

@@ -3,9 +3,7 @@ package world.phantasmal.webui.widgets
 import org.w3c.dom.Node
 import world.phantasmal.core.Failure
 import world.phantasmal.core.PwResult
-import world.phantasmal.observable.cell.Cell
-import world.phantasmal.observable.cell.emptyStringCell
-import world.phantasmal.observable.cell.trueCell
+import world.phantasmal.observable.cell.*
 import world.phantasmal.webui.dom.div
 import world.phantasmal.webui.dom.li
 import world.phantasmal.webui.dom.ul