diff --git a/decompose/api/android/decompose.api b/decompose/api/android/decompose.api
index bbb26bb14..b03747386 100644
--- a/decompose/api/android/decompose.api
+++ b/decompose/api/android/decompose.api
@@ -364,15 +364,13 @@ public final class com/arkivanov/decompose/value/ObserveLifecycleMode : java/lan
 public abstract class com/arkivanov/decompose/value/Value {
 	public fun <init> ()V
 	public abstract fun getValue ()Ljava/lang/Object;
-	public final fun observe (Lkotlin/jvm/functions/Function1;)Lcom/arkivanov/decompose/Cancellation;
-	public abstract fun subscribe (Lkotlin/jvm/functions/Function1;)V
-	public abstract fun unsubscribe (Lkotlin/jvm/functions/Function1;)V
+	public abstract fun subscribe (Lkotlin/jvm/functions/Function1;)Lcom/arkivanov/decompose/Cancellation;
 }
 
 public final class com/arkivanov/decompose/value/ValueExtKt {
 	public static final fun getValue (Lcom/arkivanov/decompose/value/Value;Ljava/lang/Object;Lkotlin/reflect/KProperty;)Ljava/lang/Object;
-	public static final fun observe (Lcom/arkivanov/decompose/value/Value;Lcom/arkivanov/essenty/lifecycle/Lifecycle;Lcom/arkivanov/decompose/value/ObserveLifecycleMode;Lkotlin/jvm/functions/Function1;)V
-	public static synthetic fun observe$default (Lcom/arkivanov/decompose/value/Value;Lcom/arkivanov/essenty/lifecycle/Lifecycle;Lcom/arkivanov/decompose/value/ObserveLifecycleMode;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V
+	public static final fun subscribe (Lcom/arkivanov/decompose/value/Value;Lcom/arkivanov/essenty/lifecycle/Lifecycle;Lcom/arkivanov/decompose/value/ObserveLifecycleMode;Lkotlin/jvm/functions/Function1;)V
+	public static synthetic fun subscribe$default (Lcom/arkivanov/decompose/value/Value;Lcom/arkivanov/essenty/lifecycle/Lifecycle;Lcom/arkivanov/decompose/value/ObserveLifecycleMode;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V
 }
 
 public final class com/arkivanov/decompose/value/operator/MapKt {
diff --git a/decompose/api/jvm/decompose.api b/decompose/api/jvm/decompose.api
index 97a65ab17..5d1632ca5 100644
--- a/decompose/api/jvm/decompose.api
+++ b/decompose/api/jvm/decompose.api
@@ -350,15 +350,13 @@ public final class com/arkivanov/decompose/value/ObserveLifecycleMode : java/lan
 public abstract class com/arkivanov/decompose/value/Value {
 	public fun <init> ()V
 	public abstract fun getValue ()Ljava/lang/Object;
-	public final fun observe (Lkotlin/jvm/functions/Function1;)Lcom/arkivanov/decompose/Cancellation;
-	public abstract fun subscribe (Lkotlin/jvm/functions/Function1;)V
-	public abstract fun unsubscribe (Lkotlin/jvm/functions/Function1;)V
+	public abstract fun subscribe (Lkotlin/jvm/functions/Function1;)Lcom/arkivanov/decompose/Cancellation;
 }
 
 public final class com/arkivanov/decompose/value/ValueExtKt {
 	public static final fun getValue (Lcom/arkivanov/decompose/value/Value;Ljava/lang/Object;Lkotlin/reflect/KProperty;)Ljava/lang/Object;
-	public static final fun observe (Lcom/arkivanov/decompose/value/Value;Lcom/arkivanov/essenty/lifecycle/Lifecycle;Lcom/arkivanov/decompose/value/ObserveLifecycleMode;Lkotlin/jvm/functions/Function1;)V
-	public static synthetic fun observe$default (Lcom/arkivanov/decompose/value/Value;Lcom/arkivanov/essenty/lifecycle/Lifecycle;Lcom/arkivanov/decompose/value/ObserveLifecycleMode;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V
+	public static final fun subscribe (Lcom/arkivanov/decompose/value/Value;Lcom/arkivanov/essenty/lifecycle/Lifecycle;Lcom/arkivanov/decompose/value/ObserveLifecycleMode;Lkotlin/jvm/functions/Function1;)V
+	public static synthetic fun subscribe$default (Lcom/arkivanov/decompose/value/Value;Lcom/arkivanov/essenty/lifecycle/Lifecycle;Lcom/arkivanov/decompose/value/ObserveLifecycleMode;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V
 }
 
 public final class com/arkivanov/decompose/value/operator/MapKt {
diff --git a/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/MutableValueBuilder.kt b/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/MutableValueBuilder.kt
index 622db28b5..36d146394 100644
--- a/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/MutableValueBuilder.kt
+++ b/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/MutableValueBuilder.kt
@@ -1,12 +1,12 @@
 package com.arkivanov.decompose.value
 
+import com.arkivanov.decompose.Cancellation
 import com.arkivanov.decompose.Lock
 import com.arkivanov.decompose.synchronized
 
 /**
  * Returns a new instance of [MutableValue] initialized with the provided [initialValue].
  */
-@Suppress("FunctionName") // Factory function
 fun <T : Any> MutableValue(initialValue: T): MutableValue<T> = MutableValueImpl(initialValue)
 
 private class MutableValueImpl<T : Any>(initialValue: T) : MutableValue<T>() {
@@ -70,13 +70,13 @@ private class MutableValueImpl<T : Any>(initialValue: T) : MutableValue<T>() {
         }
     }
 
-    @Deprecated(
-        "Calling this method from Swift leaks the observer, " +
-            "because Kotlin wraps the function passed from Swift every time the method is called. " +
-            "Please use the new `observe` method which returns `Disposable`.",
-        level = DeprecationLevel.WARNING,
-    )
-    override fun subscribe(observer: (T) -> Unit) {
+    override fun subscribe(observer: (T) -> Unit): Cancellation {
+        subscribeObserver(observer)
+
+        return Cancellation { unsubscribeObserver(observer) }
+    }
+
+    private fun subscribeObserver(observer: (T) -> Unit) {
         lock.synchronized {
             if (observer in observers) {
                 return
@@ -103,13 +103,7 @@ private class MutableValueImpl<T : Any>(initialValue: T) : MutableValue<T>() {
         }
     }
 
-    @Deprecated(
-        "Calling this method from Swift doesn't have any effect, " +
-            "because Kotlin wraps the function passed from Swift every time the method is called. " +
-            "Please use the new `observe` method which returns `Disposable`.",
-        level = DeprecationLevel.WARNING,
-    )
-    override fun unsubscribe(observer: (T) -> Unit) {
+    private fun unsubscribeObserver(observer: (T) -> Unit) {
         lock.synchronized { observers -= observer }
     }
 }
diff --git a/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/Value.kt b/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/Value.kt
index 4bc1e9331..a4f665a60 100644
--- a/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/Value.kt
+++ b/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/Value.kt
@@ -14,39 +14,10 @@ abstract class Value<out T : Any> {
      */
     abstract val value: T
 
-    /**
-     * Subscribes the provided [observer] for value updates. The current value is emitted synchronously on subscription.
-     */
-    @Deprecated(
-        message = "Calling this method from Swift leaks the observer, " +
-            "because Kotlin wraps the function passed from Swift every time the method is called. " +
-            "Please use the new `observe` method which returns `Disposable`.",
-        level = DeprecationLevel.WARNING,
-    )
-    abstract fun subscribe(observer: (T) -> Unit)
-
-    /**
-     * Unsubscribes the provided [observer] from value updates.
-     */
-    @Deprecated(
-        message = "Calling this method from Swift doesn't have any effect, " +
-            "because Kotlin wraps the function passed from Swift every time the method is called. " +
-            "Please use the new `observe` method which returns `Disposable`.",
-        level = DeprecationLevel.WARNING,
-    )
-    abstract fun unsubscribe(observer: (T) -> Unit)
-
     /**
      * Subscribes the provided [observer] for value updates. The current value is emitted synchronously on subscription.
      *
-     * Note: most likely this method will be renamed to `subscribe` in the next major release, once deprecated methods are removed.
-     *
      * @return [Cancellation] token to cancel the subscription.
      */
-    @Suppress("DEPRECATION")
-    fun observe(observer: (T) -> Unit): Cancellation {
-        subscribe(observer)
-
-        return Cancellation { unsubscribe(observer) }
-    }
+    abstract fun subscribe(observer: (T) -> Unit): Cancellation
 }
diff --git a/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/ValueExt.kt b/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/ValueExt.kt
index 9542f9773..df0437e65 100644
--- a/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/ValueExt.kt
+++ b/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/ValueExt.kt
@@ -7,7 +7,7 @@ import kotlin.reflect.KProperty
 
 operator fun <T : Any> Value<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value
 
-fun <T : Any> Value<T>.observe(
+fun <T : Any> Value<T>.subscribe(
     lifecycle: Lifecycle,
     mode: ObserveLifecycleMode = ObserveLifecycleMode.START_STOP,
     observer: (T) -> Unit,
@@ -17,19 +17,19 @@ fun <T : Any> Value<T>.observe(
     when (mode) {
         ObserveLifecycleMode.CREATE_DESTROY ->
             lifecycle.subscribe(
-                onCreate = { cancellation = observe(observer) },
+                onCreate = { cancellation = subscribe(observer) },
                 onDestroy = { cancellation?.cancel() },
             )
 
         ObserveLifecycleMode.START_STOP ->
             lifecycle.subscribe(
-                onStart = { cancellation = observe(observer) },
+                onStart = { cancellation = subscribe(observer) },
                 onStop = { cancellation?.cancel() },
             )
 
         ObserveLifecycleMode.RESUME_PAUSE ->
             lifecycle.subscribe(
-                onResume = { cancellation = observe(observer) },
+                onResume = { cancellation = subscribe(observer) },
                 onPause = { cancellation?.cancel() },
             )
     }.let {}
diff --git a/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/operator/Map.kt b/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/operator/Map.kt
index 40a761003..94b2d7da0 100644
--- a/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/operator/Map.kt
+++ b/decompose/src/commonMain/kotlin/com/arkivanov/decompose/value/operator/Map.kt
@@ -1,5 +1,6 @@
 package com.arkivanov.decompose.value.operator
 
+import com.arkivanov.decompose.Cancellation
 import com.arkivanov.decompose.Lock
 import com.arkivanov.decompose.synchronized
 import com.arkivanov.decompose.value.Value
@@ -14,7 +15,6 @@ private class MappedValue<T : Any, out R : Any>(
     private val lock = Lock()
     private var lastUpstreamValue: T = upstream.value
     private var lastMappedValue: R = mapper(lastUpstreamValue)
-    private var observers = HashMap<(R) -> Unit, (T) -> Unit>()
 
     override val value: R get() = mapCached(upstream.value)
 
@@ -28,37 +28,6 @@ private class MappedValue<T : Any, out R : Any>(
             lastMappedValue
         }
 
-    @Deprecated(
-        "Calling this method from Swift leaks the observer, " +
-            "because Kotlin wraps the function passed from Swift every time the method is called. " +
-            "Please use the new `observe` method which returns `Disposable`.",
-        level = DeprecationLevel.WARNING,
-    )
-    override fun subscribe(observer: (R) -> Unit) {
-        val upstreamObserver: (T) -> Unit = { value -> observer(mapCached(value)) }
-
-        lock.synchronized {
-            if (observer in observers) {
-                return
-            }
-
-            observers[observer] = upstreamObserver
-        }
-
-        @Suppress("DEPRECATION")
-        upstream.subscribe(upstreamObserver)
-    }
-
-    @Deprecated(
-        "Calling this method from Swift doesn't have any effect, " +
-            "because Kotlin wraps the function passed from Swift every time the method is called. " +
-            "Please use the new `observe` method which returns `Disposable`.",
-        level = DeprecationLevel.WARNING,
-    )
-    override fun unsubscribe(observer: (R) -> Unit) {
-        val upstreamObserver = lock.synchronized { observers.remove(observer) } ?: return
-
-        @Suppress("DEPRECATION")
-        upstream.unsubscribe(upstreamObserver)
-    }
+    override fun subscribe(observer: (R) -> Unit): Cancellation =
+        upstream.subscribe { observer(mapCached(it)) }
 }
diff --git a/decompose/src/commonTest/kotlin/com/arkivanov/decompose/value/MutableValueTest.kt b/decompose/src/commonTest/kotlin/com/arkivanov/decompose/value/MutableValueTest.kt
index da8dfc1a5..41d54c11e 100644
--- a/decompose/src/commonTest/kotlin/com/arkivanov/decompose/value/MutableValueTest.kt
+++ b/decompose/src/commonTest/kotlin/com/arkivanov/decompose/value/MutableValueTest.kt
@@ -27,7 +27,7 @@ class MutableValueTest {
     fun WHEN_subscribe_THEN_current_value_emitted() {
         val values = ArrayList<Int>()
 
-        value.observe { values += it }
+        value.subscribe { values += it }
 
         assertContentEquals(listOf(0), values)
     }
@@ -37,7 +37,7 @@ class MutableValueTest {
         val values = List(10) { ArrayList<Int>() }
 
         repeat(10) { index ->
-            value.observe { values[index] += it }
+            value.subscribe { values[index] += it }
         }
 
         value.value = 1
@@ -50,7 +50,7 @@ class MutableValueTest {
     @Test
     fun GIVEN_unsubscribed_WHEN_value_changed_THEN_not_emitted() {
         val values = ArrayList<Int>()
-        val cancellation = value.observe { values += it }
+        val cancellation = value.subscribe { values += it }
         cancellation.cancel()
         values.clear()
 
@@ -62,8 +62,8 @@ class MutableValueTest {
     @Test
     fun GIVEN_multiple_subscribes_and_one_unsubscribed_WHEN_value_changed_THEN_value_emitted_to_subscribed() {
         val values = ArrayList<Int>()
-        val cancellation = value.observe {}
-        value.observe { values += it }
+        val cancellation = value.subscribe {}
+        value.subscribe { values += it }
         cancellation.cancel()
         values.clear()
 
@@ -75,8 +75,8 @@ class MutableValueTest {
     @Test
     fun GIVEN_multiple_subscribes_and_one_unsubscribed_WHEN_value_changed_THEN_value_not_emitted_to_unsubscribed() {
         val values = ArrayList<Int>()
-        val cancellation = value.observe { values += it }
-        value.observe {}
+        val cancellation = value.subscribe { values += it }
+        value.subscribe {}
         cancellation.cancel()
         values.clear()
 
diff --git a/decompose/src/commonTest/kotlin/com/arkivanov/decompose/value/operator/ValueMapTest.kt b/decompose/src/commonTest/kotlin/com/arkivanov/decompose/value/operator/ValueMapTest.kt
index fbda96e89..d54834ac5 100644
--- a/decompose/src/commonTest/kotlin/com/arkivanov/decompose/value/operator/ValueMapTest.kt
+++ b/decompose/src/commonTest/kotlin/com/arkivanov/decompose/value/operator/ValueMapTest.kt
@@ -25,7 +25,7 @@ class ValueMapTest {
 
     @Test
     fun GIVEN_subscribed_WHEN_upstream_changed_THEN_value_mapped() {
-        mapped.observe {}
+        mapped.subscribe {}
         upstream.value = "abcd"
 
         val value = mapped.value
@@ -37,7 +37,7 @@ class ValueMapTest {
     fun WHEN_subscribe_THEN_current_value_emitted() {
         val values = ArrayList<Int>()
 
-        mapped.observe { values += it }
+        mapped.subscribe { values += it }
 
         assertContentEquals(listOf(3), values)
     }
@@ -47,7 +47,7 @@ class ValueMapTest {
         val values = List(10) { ArrayList<Int>() }
 
         repeat(10) { index ->
-            mapped.observe { values[index] += it }
+            mapped.subscribe { values[index] += it }
         }
 
         upstream.value = "abcd"
@@ -60,7 +60,7 @@ class ValueMapTest {
     @Test
     fun GIVEN_unsubscribed_WHEN_value_changed_THEN_not_emitted() {
         val values = ArrayList<Int>()
-        val cancellation = mapped.observe { values += it }
+        val cancellation = mapped.subscribe { values += it }
         cancellation.cancel()
         values.clear()
 
@@ -72,8 +72,8 @@ class ValueMapTest {
     @Test
     fun GIVEN_multiple_subscribes_and_one_unsubscribed_WHEN_value_changed_THEN_value_emitted_to_subscribed() {
         val values = ArrayList<Int>()
-        val cancellation = mapped.observe {}
-        mapped.observe { values += it }
+        val cancellation = mapped.subscribe {}
+        mapped.subscribe { values += it }
         cancellation.cancel()
         values.clear()
 
@@ -85,8 +85,8 @@ class ValueMapTest {
     @Test
     fun GIVEN_multiple_subscribes_and_one_unsubscribed_WHEN_value_changed_THEN_value_not_emitted_to_unsubscribed() {
         val values = ArrayList<Int>()
-        val cancellation = mapped.observe { values += it }
-        mapped.observe {}
+        val cancellation = mapped.subscribe { values += it }
+        mapped.subscribe {}
         cancellation.cancel()
         values.clear()
 
@@ -106,9 +106,9 @@ class ValueMapTest {
                     it.length
                 }
 
-        mapped.observe {}
-        mapped.observe {}
-        mapped.observe {}
+        mapped.subscribe {}
+        mapped.subscribe {}
+        mapped.subscribe {}
 
         assertEquals(1, count)
     }
@@ -124,9 +124,9 @@ class ValueMapTest {
                     it.length
                 }
 
-        mapped.observe {}
-        mapped.observe {}
-        mapped.observe {}
+        mapped.subscribe {}
+        mapped.subscribe {}
+        mapped.subscribe {}
         count = 0
 
         upstream.value = "abcd"
@@ -145,11 +145,11 @@ class ValueMapTest {
                     it.length
                 }
 
-        mapped.observe {}
-        mapped.observe {}
+        mapped.subscribe {}
+        mapped.subscribe {}
         upstream.value = "abcd"
         count = 0
-        mapped.observe {}
+        mapped.subscribe {}
 
 
         assertEquals(0, count)
@@ -166,8 +166,8 @@ class ValueMapTest {
                     it.length
                 }
 
-        mapped.observe {}
-        mapped.observe {}
+        mapped.subscribe {}
+        mapped.subscribe {}
         upstream.value = "abcd"
         count = 0
         requireNotNull(upstream.value)
diff --git a/decompose/src/jsMain/kotlin/com/arkivanov/decompose/router/Utils.kt b/decompose/src/jsMain/kotlin/com/arkivanov/decompose/router/Utils.kt
index d6ef3a180..b1fc31f31 100644
--- a/decompose/src/jsMain/kotlin/com/arkivanov/decompose/router/Utils.kt
+++ b/decompose/src/jsMain/kotlin/com/arkivanov/decompose/router/Utils.kt
@@ -34,7 +34,7 @@ internal fun <T> List<T>.findFirstDifferentIndex(other: List<T>): Int {
 
 internal fun <T : Any> Value<T>.subscribe(observer: (new: T, old: T) -> Unit) {
     var old = value
-    observe { new ->
+    subscribe { new ->
         val tmp = old
         old = new
         observer(new, tmp)
diff --git a/decompose/src/nonJsTest/kotlin/com/arkivanov/decompose/value/AbstractMutableValueThreadingTest.kt b/decompose/src/nonJsTest/kotlin/com/arkivanov/decompose/value/AbstractMutableValueThreadingTest.kt
index 4cad19ea9..31535a5a0 100644
--- a/decompose/src/nonJsTest/kotlin/com/arkivanov/decompose/value/AbstractMutableValueThreadingTest.kt
+++ b/decompose/src/nonJsTest/kotlin/com/arkivanov/decompose/value/AbstractMutableValueThreadingTest.kt
@@ -16,7 +16,7 @@ abstract class AbstractMutableValueThreadingTest : AbstractThreadingTest() {
             var lastValue = 0
             var counter = 0
 
-            value.observe {
+            value.subscribe {
                 repeat(1000) { counter++ }
                 lastValue = it
                 repeat(1000) { counter-- }
@@ -41,7 +41,7 @@ abstract class AbstractMutableValueThreadingTest : AbstractThreadingTest() {
             var lastValue = 0
             var counter = 0
 
-            value.observe {
+            value.subscribe {
                 repeat(1000) { counter++ }
                 lastValue = it
                 repeat(1000) { counter-- }
@@ -68,7 +68,7 @@ abstract class AbstractMutableValueThreadingTest : AbstractThreadingTest() {
             var counter = 0
 
             repeat(3) {
-                value.observe {}
+                value.subscribe {}
             }
 
             race { threadIndex ->
@@ -76,7 +76,7 @@ abstract class AbstractMutableValueThreadingTest : AbstractThreadingTest() {
                     value.update { it + 1 }
 
                     if ((threadIndex == 0) && (index == iterationCount / 2)) {
-                        value.observe {
+                        value.subscribe {
                             repeat(1000) { counter++ }
                             lastValue = it
                             repeat(1000) { counter-- }
diff --git a/decompose/src/nonJsTest/kotlin/com/arkivanov/decompose/value/operator/AbstractValueMapThreadingTest.kt b/decompose/src/nonJsTest/kotlin/com/arkivanov/decompose/value/operator/AbstractValueMapThreadingTest.kt
index d80625e38..ca287d9dd 100644
--- a/decompose/src/nonJsTest/kotlin/com/arkivanov/decompose/value/operator/AbstractValueMapThreadingTest.kt
+++ b/decompose/src/nonJsTest/kotlin/com/arkivanov/decompose/value/operator/AbstractValueMapThreadingTest.kt
@@ -22,7 +22,7 @@ abstract class AbstractValueMapThreadingTest : AbstractThreadingTest() {
             val counters = IntArray(observerCount)
 
             repeat(observerCount) { index ->
-                value.observe {
+                value.subscribe {
                     repeat(1000) { counters[index]++ }
                     lastValues[index] = it
                     repeat(1000) { counters[index]-- }
diff --git a/extensions-android/src/main/java/com/arkivanov/decompose/extensions/android/stack/StackRouterView.kt b/extensions-android/src/main/java/com/arkivanov/decompose/extensions/android/stack/StackRouterView.kt
index 82b068c6c..151ab0896 100644
--- a/extensions-android/src/main/java/com/arkivanov/decompose/extensions/android/stack/StackRouterView.kt
+++ b/extensions-android/src/main/java/com/arkivanov/decompose/extensions/android/stack/StackRouterView.kt
@@ -20,7 +20,7 @@ import com.arkivanov.decompose.hashString
 import com.arkivanov.decompose.lifecycle.MergedLifecycle
 import com.arkivanov.decompose.router.stack.ChildStack
 import com.arkivanov.decompose.value.Value
-import com.arkivanov.decompose.value.observe
+import com.arkivanov.decompose.value.subscribe
 import com.arkivanov.essenty.lifecycle.Lifecycle
 import com.arkivanov.essenty.lifecycle.LifecycleRegistry
 import com.arkivanov.essenty.lifecycle.destroy
@@ -43,7 +43,7 @@ class StackRouterView @JvmOverloads constructor(
         lifecycle: Lifecycle,
         replaceChildView: ViewContext.(parent: ViewGroup, newStack: ChildStack<C, T>, oldStack: ChildStack<C, T>?) -> Unit,
     ) {
-        stack.observe(lifecycle) {
+        stack.subscribe(lifecycle) {
             onStackChanged(it, lifecycle, replaceChildView)
         }
     }
diff --git a/extensions-compose-jetbrains/src/commonMain/kotlin/com/arkivanov/decompose/extensions/compose/jetbrains/SubscribeAsState.kt b/extensions-compose-jetbrains/src/commonMain/kotlin/com/arkivanov/decompose/extensions/compose/jetbrains/SubscribeAsState.kt
index 67246b0b1..99856df1d 100644
--- a/extensions-compose-jetbrains/src/commonMain/kotlin/com/arkivanov/decompose/extensions/compose/jetbrains/SubscribeAsState.kt
+++ b/extensions-compose-jetbrains/src/commonMain/kotlin/com/arkivanov/decompose/extensions/compose/jetbrains/SubscribeAsState.kt
@@ -20,7 +20,7 @@ fun <T : Any> Value<T>.subscribeAsState(policy: SnapshotMutationPolicy<T> = stru
     val state = remember(this, policy) { mutableStateOf(value, policy) }
 
     DisposableEffect(this) {
-        val disposable = observe { state.value = it }
+        val disposable = subscribe { state.value = it }
         onDispose { disposable.cancel() }
     }
 
diff --git a/sample/app-ios-compose/app-ios-compose.xcodeproj/project.xcworkspace/xcuserdata/arkivanov.xcuserdatad/UserInterfaceState.xcuserstate b/sample/app-ios-compose/app-ios-compose.xcodeproj/project.xcworkspace/xcuserdata/arkivanov.xcuserdatad/UserInterfaceState.xcuserstate
index b320fa017..95ab41aad 100644
Binary files a/sample/app-ios-compose/app-ios-compose.xcodeproj/project.xcworkspace/xcuserdata/arkivanov.xcuserdatad/UserInterfaceState.xcuserstate and b/sample/app-ios-compose/app-ios-compose.xcodeproj/project.xcworkspace/xcuserdata/arkivanov.xcuserdatad/UserInterfaceState.xcuserstate differ
diff --git a/sample/app-ios/app-ios/DecomposeHelpers/ObservableValue.swift b/sample/app-ios/app-ios/DecomposeHelpers/ObservableValue.swift
index 43e68b67d..588a939d8 100644
--- a/sample/app-ios/app-ios/DecomposeHelpers/ObservableValue.swift
+++ b/sample/app-ios/app-ios/DecomposeHelpers/ObservableValue.swift
@@ -16,7 +16,7 @@ public class ObservableValue<T : AnyObject> : ObservableObject {
     
     init(_ value: Value<T>) {
         self.value = value.value
-        self.cancellation = value.observe { [weak self] value in self?.value = value }
+        self.cancellation = value.subscribe { [weak self] value in self?.value = value }
     }
 
     deinit {
diff --git a/sample/shared/shared/src/androidMain/kotlin/com/arkivanov/sample/shared/counters/counter/CounterView.kt b/sample/shared/shared/src/androidMain/kotlin/com/arkivanov/sample/shared/counters/counter/CounterView.kt
index 31410148f..ac27dd692 100644
--- a/sample/shared/shared/src/androidMain/kotlin/com/arkivanov/sample/shared/counters/counter/CounterView.kt
+++ b/sample/shared/shared/src/androidMain/kotlin/com/arkivanov/sample/shared/counters/counter/CounterView.kt
@@ -7,7 +7,7 @@ import com.arkivanov.decompose.ExperimentalDecomposeApi
 import com.arkivanov.decompose.extensions.android.ViewContext
 import com.arkivanov.decompose.extensions.android.context
 import com.arkivanov.decompose.extensions.android.layoutInflater
-import com.arkivanov.decompose.value.observe
+import com.arkivanov.decompose.value.subscribe
 import com.arkivanov.essenty.lifecycle.subscribe
 import com.arkivanov.sample.shared.R
 import com.arkivanov.sample.shared.dialog.DialogComponent
@@ -28,7 +28,7 @@ internal fun ViewContext.CounterView(component: CounterComponent): View {
     nextButton.setOnClickListener { component.onNextClicked() }
     prevButton.setOnClickListener { component.onPrevClicked() }
 
-    component.model.observe(lifecycle) { model ->
+    component.model.subscribe(lifecycle) { model ->
         toolbar.title = model.title
 
         if (model.isBackEnabled) {
@@ -42,7 +42,7 @@ internal fun ViewContext.CounterView(component: CounterComponent): View {
     }
 
     var dialog: AlertDialog? = null
-    component.dialogSlot.observe(lifecycle) { model ->
+    component.dialogSlot.subscribe(lifecycle) { model ->
         val dialogComponent: DialogComponent? = model.child?.instance
         if ((dialogComponent != null) && (dialog == null)) {
             dialog = showDialog(component = dialogComponent)
diff --git a/sample/shared/shared/src/androidMain/kotlin/com/arkivanov/sample/shared/root/RootView.kt b/sample/shared/shared/src/androidMain/kotlin/com/arkivanov/sample/shared/root/RootView.kt
index aabf1d599..fc79e1b27 100644
--- a/sample/shared/shared/src/androidMain/kotlin/com/arkivanov/sample/shared/root/RootView.kt
+++ b/sample/shared/shared/src/androidMain/kotlin/com/arkivanov/sample/shared/root/RootView.kt
@@ -5,7 +5,7 @@ import com.arkivanov.decompose.ExperimentalDecomposeApi
 import com.arkivanov.decompose.extensions.android.ViewContext
 import com.arkivanov.decompose.extensions.android.layoutInflater
 import com.arkivanov.decompose.extensions.android.stack.StackRouterView
-import com.arkivanov.decompose.value.observe
+import com.arkivanov.decompose.value.subscribe
 import com.arkivanov.sample.shared.R
 import com.arkivanov.sample.shared.beginDelayedSlideTransition
 import com.arkivanov.sample.shared.counters.CountersView
@@ -64,7 +64,7 @@ fun ViewContext.RootView(component: RootComponent): View {
 
     navigationView.setOnNavigationItemSelectedListener(listener)
 
-    component.childStack.observe(lifecycle) { state ->
+    component.childStack.subscribe(lifecycle) { state ->
         navigationView.setOnNavigationItemSelectedListener(null)
 
         navigationView.selectedItemId =
diff --git a/sample/shared/shared/src/jsMain/kotlin/com/arkivanov/sample/shared/Utils.kt b/sample/shared/shared/src/jsMain/kotlin/com/arkivanov/sample/shared/Utils.kt
index 94b286811..195102776 100644
--- a/sample/shared/shared/src/jsMain/kotlin/com/arkivanov/sample/shared/Utils.kt
+++ b/sample/shared/shared/src/jsMain/kotlin/com/arkivanov/sample/shared/Utils.kt
@@ -12,9 +12,8 @@ internal fun <T : Any> Value<T>.useAsState(): StateInstance<T> {
     val (_, set) = state
 
     useEffectOnce {
-        val observer: (T) -> Unit = { set(it) }
-        subscribe(observer)
-        cleanup { unsubscribe(observer) }
+        val cancellation = subscribe { set(it) }
+        cleanup { cancellation.cancel() }
     }
 
     return state