peachsim 0.1.669 → 0.1.671

package/dist-lib/swift-compile.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.669 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.671 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __create = Object.create;

package/dist-lib/swift-compile.mjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.669 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.671 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 
 // src/swift-compile.ts
 import { execFile as execFile2 } from "node:child_process";

package/dist-lib/swift-package.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.669 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.671 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __defProp = Object.defineProperty;

package/dist-lib/swift-package.mjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.669 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.671 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 
 // src/swift-package.ts
 function isSwiftManifestFile(file) {

package/dist-lib/swift-submit.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.669 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.671 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __defProp = Object.defineProperty;

package/dist-lib/swift-submit.mjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.669 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.671 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 
 // src/swift-submit.ts
 var SWIFT_COMPILE_PATH = "/api/swift-compile";

package/dist-lib/swift.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.669 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.671 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __defProp = Object.defineProperty;

package/dist-lib/vite-swift.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.669 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.671 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __create = Object.create;
@@ -1718,13 +1718,11 @@ async function compile(packagePath, entry, stamp, moduleRootOverride, hosted, sn
       stamp,
       package: content
     };
-  const toolchain = JSON.parse(
-    import_node_fs4.default.readFileSync(import_node_path5.default.join(moduleRoot, "toolchain.json"), "utf8")
-  );
-  const release = toolchain && typeof toolchain === "object" ? Reflect.get(toolchain, "release") : void 0;
-  if (typeof release !== "string") {
-    throw new Error(`swift toolchain manifest at ${moduleRoot} has no release`);
-  }
+  const toolchain = localSwiftToolchain(moduleRoot);
+  if (!toolchain)
+    throw new Error(
+      `the Swift toolchain ${moduleRoot}/toolchain.json names is not installed under ~/Library/Developer/Toolchains`
+    );
   const artifact = await compileSwiftProjectUnit(snapshotCompileInput(snapshot, entry), {
     // the compile rewrites Sources/App in its root before swiftpm builds, and
     // its lock orders one process only: two vites on one root (a lane's dev
@@ -1737,14 +1735,24 @@ async function compile(packagePath, entry, stamp, moduleRootOverride, hosted, sn
       (0, import_node_crypto3.createHash)("sha256").update(`${moduleRoot}\0${import_node_path5.default.resolve(packagePath)}`).digest("hex").slice(0, 16)
     ),
     moduleRoot,
-    release,
-    toolchainBin: import_node_path5.default.join(
-      import_node_os3.default.homedir(),
-      `Library/Developer/Toolchains/${release}.xctoolchain/usr/bin`
-    )
+    ...toolchain
   });
   return { ...artifact, stamp, package: content };
 }
+function localSwiftToolchain(moduleRoot) {
+  const manifest = import_node_path5.default.join(moduleRoot, "toolchain.json");
+  if (!import_node_fs4.default.existsSync(manifest)) return null;
+  const toolchain = JSON.parse(import_node_fs4.default.readFileSync(manifest, "utf8"));
+  const release = toolchain && typeof toolchain === "object" ? Reflect.get(toolchain, "release") : void 0;
+  if (typeof release !== "string") {
+    throw new Error(`swift toolchain manifest at ${moduleRoot} has no release`);
+  }
+  const toolchainBin = import_node_path5.default.join(
+    import_node_os3.default.homedir(),
+    `Library/Developer/Toolchains/${release}.xctoolchain/usr/bin`
+  );
+  return import_node_fs4.default.existsSync(import_node_path5.default.join(toolchainBin, "swift")) ? { release, toolchainBin } : null;
+}
 async function compileRemote(packagePath, entry, snapshot, hosted) {
   const auth = hosted ? null : resolveCliAuth();
   if (!hosted && (!auth || auth.kind === "github")) {

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.669 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.671 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __create = Object.create;

package/kotlin/AppSources/androidx/activity/ActivityFlags.kt

@@ -0,0 +1,9 @@
+package androidx.activity
+
+// androidx.activity 1.13.0's ActivityFlags
+@ExperimentalActivityApi
+object ActivityFlags {
+    // a lifecycle-bound back callback keeps its place in the dispatch queue
+    // across ON_STOP and ON_START, rather than moving to the top on each start
+    var isOnBackPressedLifecycleOrderMaintained: Boolean = true
+}

package/kotlin/AppSources/androidx/activity/BackEventCompat.kt

@@ -1,17 +1,38 @@
 package androidx.activity
 
-// androidx.activity's BackEventCompat: one predictive back gesture sample
+import androidx.navigationevent.NavigationEvent
+
+// androidx.activity 1.13.0's BackEventCompat: one predictive back gesture sample
 class BackEventCompat(
     val touchX: Float,
     val touchY: Float,
     val progress: Float,
     val swipeEdge: Int,
+    val frameTimeMillis: Long = 0,
 ) {
+    constructor(navigationEvent: NavigationEvent) : this(
+        touchX = navigationEvent.touchX,
+        touchY = navigationEvent.touchY,
+        progress = navigationEvent.progress,
+        swipeEdge = navigationEvent.swipeEdge,
+        frameTimeMillis = navigationEvent.frameTimeMillis,
+    )
+
+    fun toNavigationEvent(): NavigationEvent = NavigationEvent(
+        touchX = touchX,
+        touchY = touchY,
+        progress = progress,
+        swipeEdge = swipeEdge,
+        frameTimeMillis = frameTimeMillis,
+    )
+
     override fun toString(): String =
-        "BackEventCompat{touchX=$touchX, touchY=$touchY, progress=$progress, swipeEdge=$swipeEdge}"
+        "BackEventCompat(touchX=$touchX, touchY=$touchY, progress=$progress, " +
+            "swipeEdge=$swipeEdge, frameTimeMillis=$frameTimeMillis)"
 
     companion object {
-        const val EDGE_LEFT = 0
-        const val EDGE_RIGHT = 1
+        const val EDGE_LEFT: Int = 0
+        const val EDGE_RIGHT: Int = 1
+        const val EDGE_NONE: Int = 2
     }
 }

package/kotlin/AppSources/androidx/activity/ComponentActivity.kt

@@ -14,6 +14,9 @@ import androidx.lifecycle.ViewModelStoreOwner
 import androidx.lifecycle.enableSavedStateHandles
 import androidx.lifecycle.viewmodel.CreationExtras
 import androidx.lifecycle.viewmodel.MutableCreationExtras
+import androidx.navigationevent.DirectNavigationEventInput
+import androidx.navigationevent.NavigationEventDispatcher
+import androidx.navigationevent.NavigationEventDispatcherOwner
 import androidx.savedstate.SavedStateRegistry
 import androidx.savedstate.SavedStateRegistryController
 import androidx.savedstate.SavedStateRegistryOwner
@@ -25,7 +28,8 @@ import androidx.savedstate.SavedStateRegistryOwner
 // API 29, and destroy clears the view model store unless the activity is
 // changing configurations.
 open class ComponentActivity : Activity(), LifecycleOwner, ViewModelStoreOwner,
-    HasDefaultViewModelProviderFactory, SavedStateRegistryOwner, OnBackPressedDispatcherOwner {
+    HasDefaultViewModelProviderFactory, SavedStateRegistryOwner, OnBackPressedDispatcherOwner,
+    NavigationEventDispatcherOwner {
     private val lifecycleRegistry = LifecycleRegistry(this)
     private val savedStateRegistryController = SavedStateRegistryController.create(this)
 
@@ -92,16 +96,23 @@ open class ComponentActivity : Activity(), LifecycleOwner, ViewModelStoreOwner,
         savedStateRegistryController.performSave(outState.state)
     }
 
-    // the dispatcher gets the back first; without an enabled callback it falls
-    // back to Activity's own
+    // onBackPressed's back, an input of the navigation event dispatcher: an
+    // enabled handler gets it first; without one it falls back to Activity's own
+    private val onBackPressedInput: DirectNavigationEventInput by lazy {
+        DirectNavigationEventInput().also(navigationEventDispatcher::addInput)
+    }
+
     override fun onBackPressed() {
-        onBackPressedDispatcher.onBackPressed()
+        onBackPressedInput.backCompleted()
     }
 
     final override val onBackPressedDispatcher: OnBackPressedDispatcher by lazy {
         OnBackPressedDispatcher { super@ComponentActivity.onBackPressed() }
     }
 
+    override val navigationEventDispatcher: NavigationEventDispatcher
+        get() = onBackPressedDispatcher.eventDispatcher
+
     override fun dispatchActivityPostCreated() = lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
     override fun dispatchActivityPostStarted() = lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
     override fun dispatchActivityPostResumed() = lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)

package/kotlin/AppSources/androidx/activity/EdgeToEdge.kt

@@ -8,11 +8,12 @@ import android.view.WindowManager
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsControllerCompat
 
-// androidx.activity 1.9.3's EdgeToEdge as it runs on Peach's API 37 device,
-// where it takes EdgeToEdgeApi30: the decor stops fitting system windows, the
-// bars take each style's scrim (transparent for auto styles), status bar
-// contrast is off, navigation bar contrast follows an auto style, the bars'
-// appearance follows dark mode and the window lays out into every cutout.
+// androidx.activity 1.13.0's EdgeToEdge as it runs on Peach's API 37 device,
+// where it takes EdgeToEdgeApi35: the decor stops fitting system windows, the
+// bars turn transparent, navigation bar contrast follows an auto style, the
+// bars' appearance follows dark mode and the window lays out into every
+// cutout. a style's non-transparent scrim is an androidx.core ProtectionLayout
+// view added to the decor, which Peach's ComposeView-only window cannot host.
 
 // DecorView's light scrim and the platform's dark scrim
 internal val DefaultLightScrim = Color.argb(0xe6, 0xFF, 0xFF, 0xFF)
@@ -26,9 +27,12 @@ fun ComponentActivity.enableEdgeToEdge(
     val statusBarIsDark = statusBarStyle.detectDarkMode(view.resources)
     val navigationBarIsDark = navigationBarStyle.detectDarkMode(view.resources)
     WindowCompat.setDecorFitsSystemWindows(window, false)
-    window.statusBarColor = statusBarStyle.getScrimWithEnforcedContrast(statusBarIsDark)
-    window.navigationBarColor = navigationBarStyle.getScrimWithEnforcedContrast(navigationBarIsDark)
-    window.isStatusBarContrastEnforced = false
+    window.statusBarColor = Color.TRANSPARENT
+    window.navigationBarColor = Color.TRANSPARENT
+    check(
+        statusBarStyle.getScrimWithEnforcedContrast(statusBarIsDark) == Color.TRANSPARENT &&
+            navigationBarStyle.getScrimWithEnforcedContrast(navigationBarIsDark) == Color.TRANSPARENT
+    ) { "enableEdgeToEdge with a non-transparent scrim adds a ProtectionLayout view; Peach composes only ComposeView content" }
     window.isNavigationBarContrastEnforced = navigationBarStyle.nightMode == UiModeManager.MODE_NIGHT_AUTO
     WindowInsetsControllerCompat(window, view).run {
         isAppearanceLightStatusBars = !statusBarIsDark

package/kotlin/AppSources/androidx/activity/ExperimentalActivityApi.kt

@@ -0,0 +1,6 @@
+package androidx.activity
+
+// androidx.activity 1.13.0's ExperimentalActivityApi
+@RequiresOptIn(level = RequiresOptIn.Level.WARNING)
+@Retention(AnnotationRetention.BINARY)
+annotation class ExperimentalActivityApi

package/kotlin/AppSources/androidx/activity/OnBackPressedCallback.kt

@@ -1,28 +1,69 @@
 package androidx.activity
 
-// androidx.activity 1.9.3's OnBackPressedCallback
+import androidx.navigationevent.NavigationEvent
+import androidx.navigationevent.NavigationEventHandler
+import androidx.navigationevent.NavigationEventInfo
+
+// androidx.activity 1.13.0's OnBackPressedCallback: each registration is a
+// NavigationEventHandler on the dispatcher's NavigationEventDispatcher
 abstract class OnBackPressedCallback(enabled: Boolean) {
+    private val eventHandlers: MutableList<OnBackPressedEventHandler> = mutableListOf()
+
     var isEnabled: Boolean = enabled
         set(value) {
             field = value
-            enabledChangedCallback?.invoke()
+            // a handler registered without a lifecycle is always lifecycle active
+            for (callback in eventHandlers) callback.isBackEnabled = callback.isLifecycleActive && value
         }
 
-    private val cancellables = mutableListOf<Cancellable>()
-    internal var enabledChangedCallback: (() -> Unit)? = null
+    private val closeables = mutableListOf<AutoCloseable>()
 
-    fun remove() = cancellables.toList().forEach { it.cancel() }
+    fun remove() {
+        for (closeable in closeables.toList()) closeable.close()
+        closeables.clear()
+        for (callback in eventHandlers) callback.remove()
+        eventHandlers.clear()
+    }
 
     open fun handleOnBackStarted(backEvent: BackEventCompat) {}
     open fun handleOnBackProgressed(backEvent: BackEventCompat) {}
     abstract fun handleOnBackPressed()
     open fun handleOnBackCancelled() {}
 
-    internal fun addCancellable(cancellable: Cancellable) {
-        cancellables.add(cancellable)
+    internal fun addCloseable(closeable: AutoCloseable) {
+        closeables += closeable
     }
 
-    internal fun removeCancellable(cancellable: Cancellable) {
-        cancellables.remove(cancellable)
+    internal fun createNavigationEventHandler(info: NavigationEventInfo): OnBackPressedEventHandler {
+        val newHandler = OnBackPressedEventHandler(onBackPressedCallback = this, info)
+        eventHandlers += newHandler
+        return newHandler
+    }
+
+    internal class OnBackPressedEventHandler(
+        private val onBackPressedCallback: OnBackPressedCallback,
+        info: NavigationEventInfo,
+    ) : NavigationEventHandler<NavigationEventInfo>(initialInfo = info, isBackEnabled = onBackPressedCallback.isEnabled) {
+        var isLifecycleActive: Boolean = true
+            set(value) {
+                field = value
+                isBackEnabled = value && onBackPressedCallback.isEnabled
+            }
+
+        override fun onBackStarted(event: NavigationEvent) {
+            onBackPressedCallback.handleOnBackStarted(BackEventCompat(event))
+        }
+
+        override fun onBackProgressed(event: NavigationEvent) {
+            onBackPressedCallback.handleOnBackProgressed(BackEventCompat(event))
+        }
+
+        override fun onBackCompleted() {
+            onBackPressedCallback.handleOnBackPressed()
+        }
+
+        override fun onBackCancelled() {
+            onBackPressedCallback.handleOnBackCancelled()
+        }
     }
 }

package/kotlin/AppSources/androidx/activity/OnBackPressedDispatcher.kt

@@ -1,125 +1,101 @@
 package androidx.activity
 
-import java.lang.Runnable
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
 import androidx.lifecycle.LifecycleOwner
+import androidx.navigationevent.NavigationEvent
+import androidx.navigationevent.NavigationEventDispatcher
+import androidx.navigationevent.NavigationEventInfo
+import androidx.navigationevent.NavigationEventInput
+import java.lang.Runnable
 
-// androidx.activity 1.9.3's OnBackPressedDispatcher. the device's back
-// dispatch stands in for its OnBackInvokedDispatcher registration: a window
-// with predictive back gives this dispatcher the back only while it has an
-// enabled callback (hasEnabledCallbacks), as the registered callback does.
+// androidx.activity 1.13.0's OnBackPressedDispatcher, a NavigationEventInput
+// over its own NavigationEventDispatcher. the device's back dispatch stands in
+// for its OnBackInvokedDispatcher inputs: a window with predictive back gives
+// this dispatcher the back only while it has an enabled handler
+// (hasEnabledCallbacks), as the registered OnBackInvokedCallback does.
 class OnBackPressedDispatcher(
     private val fallbackOnBackPressed: Runnable?,
     private val onHasEnabledCallbacksChanged: ((Boolean) -> Unit)?,
 ) {
-    private val onBackPressedCallbacks = ArrayDeque<OnBackPressedCallback>()
-    private var inProgressCallback: OnBackPressedCallback? = null
     private var hasEnabledCallbacks = false
+    private val eventInput by lazy { OnBackPressedEventInput() }
 
-    constructor(fallbackOnBackPressed: Runnable? = null) : this(fallbackOnBackPressed, null)
+    internal val eventDispatcher
+        get() = eventInput.dispatcher
 
-    private fun updateEnabledCallbacks() {
-        val hadEnabledCallbacks = hasEnabledCallbacks
-        val hasEnabledCallbacks = onBackPressedCallbacks.any { it.isEnabled }
-        this.hasEnabledCallbacks = hasEnabledCallbacks
-        if (hasEnabledCallbacks != hadEnabledCallbacks)
-            onHasEnabledCallbacksChanged?.invoke(hasEnabledCallbacks)
-    }
+    constructor(fallbackOnBackPressed: Runnable? = null) : this(fallbackOnBackPressed, null)
 
     fun addCallback(onBackPressedCallback: OnBackPressedCallback) {
-        addCancellableCallback(onBackPressedCallback)
-    }
-
-    internal fun addCancellableCallback(onBackPressedCallback: OnBackPressedCallback): Cancellable {
-        onBackPressedCallbacks.add(onBackPressedCallback)
-        val cancellable = OnBackPressedCancellable(onBackPressedCallback)
-        onBackPressedCallback.addCancellable(cancellable)
-        updateEnabledCallbacks()
-        onBackPressedCallback.enabledChangedCallback = ::updateEnabledCallbacks
-        return cancellable
+        val info = OnBackPressedCallbackInfo(onBackPressedCallback)
+        val handler = onBackPressedCallback.createNavigationEventHandler(info)
+        eventDispatcher.addHandler(handler)
     }
 
+    @OptIn(ExperimentalActivityApi::class)
     fun addCallback(owner: LifecycleOwner, onBackPressedCallback: OnBackPressedCallback) {
         val lifecycle = owner.lifecycle
         if (lifecycle.currentState === Lifecycle.State.DESTROYED) return
-        onBackPressedCallback.addCancellable(LifecycleOnBackPressedCancellable(lifecycle, onBackPressedCallback))
-        updateEnabledCallbacks()
-        onBackPressedCallback.enabledChangedCallback = ::updateEnabledCallbacks
+        val info = OnBackPressedCallbackInfo(onBackPressedCallback, owner)
+        val eventHandler = onBackPressedCallback.createNavigationEventHandler(info)
+        // the order flag adds the handler once, so its place in the queue holds,
+        // and toggles it with the lifecycle; the legacy order re-adds it on each
+        // start, which moves it to the top
+        if (ActivityFlags.isOnBackPressedLifecycleOrderMaintained) {
+            eventHandler.isLifecycleActive = false
+            eventDispatcher.addHandler(eventHandler)
+        }
+        val observer = object : LifecycleEventObserver {
+            override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
+                when (event) {
+                    Lifecycle.Event.ON_START ->
+                        if (ActivityFlags.isOnBackPressedLifecycleOrderMaintained) eventHandler.isLifecycleActive = true
+                        else eventDispatcher.addHandler(eventHandler)
+                    Lifecycle.Event.ON_STOP ->
+                        if (ActivityFlags.isOnBackPressedLifecycleOrderMaintained) eventHandler.isLifecycleActive = false
+                        else eventHandler.remove()
+                    Lifecycle.Event.ON_DESTROY -> {
+                        eventHandler.remove()
+                        lifecycle.removeObserver(this)
+                    }
+                    else -> Unit
+                }
+            }
+        }
+        lifecycle.addObserver(observer)
+        onBackPressedCallback.addCloseable(AutoCloseable { lifecycle.removeObserver(observer) })
     }
 
     fun hasEnabledCallbacks(): Boolean = hasEnabledCallbacks
 
     fun dispatchOnBackStarted(backEvent: BackEventCompat) {
-        val callback = onBackPressedCallbacks.lastOrNull { it.isEnabled }
-        if (inProgressCallback != null) dispatchOnBackCancelled()
-        inProgressCallback = callback
-        callback?.handleOnBackStarted(backEvent)
+        eventInput.backStarted(backEvent.toNavigationEvent())
     }
 
     fun dispatchOnBackProgressed(backEvent: BackEventCompat) {
-        val callback = inProgressCallback ?: onBackPressedCallbacks.lastOrNull { it.isEnabled }
-        callback?.handleOnBackProgressed(backEvent)
+        eventInput.backProgressed(backEvent.toNavigationEvent())
     }
 
     fun onBackPressed() {
-        val callback = inProgressCallback ?: onBackPressedCallbacks.lastOrNull { it.isEnabled }
-        inProgressCallback = null
-        if (callback != null) {
-            callback.handleOnBackPressed()
-            return
-        }
-        fallbackOnBackPressed?.run()
+        eventInput.backCompleted()
     }
 
     fun dispatchOnBackCancelled() {
-        val callback = inProgressCallback ?: onBackPressedCallbacks.lastOrNull { it.isEnabled }
-        inProgressCallback = null
-        callback?.handleOnBackCancelled()
+        eventInput.backCancelled()
     }
 
-    private inner class OnBackPressedCancellable(
-        private val onBackPressedCallback: OnBackPressedCallback,
-    ) : Cancellable {
-        override fun cancel() {
-            onBackPressedCallbacks.remove(onBackPressedCallback)
-            if (inProgressCallback == onBackPressedCallback) {
-                onBackPressedCallback.handleOnBackCancelled()
-                inProgressCallback = null
-            }
-            onBackPressedCallback.removeCancellable(this)
-            onBackPressedCallback.enabledChangedCallback?.invoke()
-            onBackPressedCallback.enabledChangedCallback = null
-        }
-    }
-
-    // a lifecycle-bound callback receives back only between ON_START and ON_STOP
-    private inner class LifecycleOnBackPressedCancellable(
-        private val lifecycle: Lifecycle,
-        private val onBackPressedCallback: OnBackPressedCallback,
-    ) : LifecycleEventObserver, Cancellable {
-        private var currentCancellable: Cancellable? = null
-
-        init {
-            lifecycle.addObserver(this)
-        }
+    private inner class OnBackPressedEventInput : NavigationEventInput() {
+        val dispatcher = NavigationEventDispatcher { fallbackOnBackPressed?.run() }.also { it.addInput(this) }
 
-        override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
-            if (event === Lifecycle.Event.ON_START) {
-                currentCancellable = addCancellableCallback(onBackPressedCallback)
-            } else if (event === Lifecycle.Event.ON_STOP) {
-                currentCancellable?.cancel()
-            } else if (event === Lifecycle.Event.ON_DESTROY) {
-                cancel()
-            }
+        override fun onHasEnabledHandlersChanged(hasEnabledHandlers: Boolean) {
+            hasEnabledCallbacks = hasEnabledHandlers
+            onHasEnabledCallbacksChanged?.invoke(hasEnabledHandlers)
         }
 
-        override fun cancel() {
-            lifecycle.removeObserver(this)
-            onBackPressedCallback.removeCancellable(this)
-            currentCancellable?.cancel()
-            currentCancellable = null
-        }
+        fun backStarted(event: NavigationEvent) = dispatchOnBackStarted(event)
+        fun backProgressed(event: NavigationEvent) = dispatchOnBackProgressed(event)
+        fun backCancelled() = dispatchOnBackCancelled()
+        fun backCompleted() = dispatchOnBackCompleted()
     }
 }
 
@@ -128,17 +104,19 @@ class OnBackPressedDispatcher(
 fun OnBackPressedDispatcher.addCallback(
     owner: LifecycleOwner? = null,
     enabled: Boolean = true,
-    onBackPressed: OnBackPressedCallback.() -> Unit
+    onBackPressed: OnBackPressedCallback.() -> Unit,
 ): OnBackPressedCallback {
     val callback = object : OnBackPressedCallback(enabled) {
         override fun handleOnBackPressed() {
             onBackPressed()
         }
     }
-    if (owner != null) {
-        addCallback(owner, callback)
-    } else {
-        addCallback(callback)
-    }
+    if (owner != null) addCallback(owner, callback)
+    else addCallback(callback)
     return callback
 }
+
+private data class OnBackPressedCallbackInfo(
+    val callback: OnBackPressedCallback,
+    val owner: LifecycleOwner? = null,
+) : NavigationEventInfo()

package/kotlin/AppSources/androidx/activity/compose/BackHandler.kt

@@ -1,18 +1,23 @@
 package androidx.activity.compose
 
-import androidx.activity.OnBackPressedCallback
+import androidx.activity.ActivityFlags
+import androidx.activity.ExperimentalActivityApi
 import androidx.activity.OnBackPressedDispatcherOwner
+import androidx.activity.compose.internal.BackHandlerCompat
+import androidx.activity.compose.internal.BackHandlerDispatcherCompat
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.ProvidedValue
 import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.compositionLocalOf
-import androidx.compose.runtime.getValue
+import androidx.compose.runtime.currentCompositeKeyHashCode
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberUpdatedState
-import androidx.lifecycle.compose.LocalLifecycleOwner
+import androidx.lifecycle.compose.LifecycleStartEffect
+import androidx.navigationevent.NavigationEventDispatcherOwner
+import androidx.navigationevent.NavigationEventInfo
+import androidx.navigationevent.compose.LocalNavigationEventDispatcherOwner
 
-// activity-compose 1.9.3's LocalOnBackPressedDispatcherOwner. on the device
+// activity-compose 1.13.0's LocalOnBackPressedDispatcherOwner. on the device
 // an unprovided value resolves from the view tree or the context, both of
 // which reach the activity that set the content; the window host provides that
 // activity here.
@@ -28,28 +33,54 @@ object LocalOnBackPressedDispatcherOwner {
         LocalOnBackPressedDispatcherOwner.provides(dispatcherOwner)
 }
 
-// activity-compose 1.9.3's BackHandler
+// activity-compose 1.13.0's BackHandler: a handler on the navigation event
+// dispatcher when one is provided, else a callback on the back dispatcher
+@OptIn(ExperimentalActivityApi::class)
 @Composable
 fun BackHandler(enabled: Boolean = true, onBack: () -> Unit) {
-    val currentOnBack by rememberUpdatedState(onBack)
-    val backCallback = remember {
-        object : OnBackPressedCallback(enabled) {
-            override fun handleOnBackPressed() {
-                currentOnBack()
-            }
-        }
-    }
-    SideEffect {
-        backCallback.isEnabled = enabled
+    val owner = LocalNavigationEventDispatcherOwner.current
+        ?: LocalOnBackPressedDispatcherOwner.current
+        ?: error(
+            "No NavigationEventDispatcherOwner was provided via " +
+                "LocalNavigationEventDispatcherOwner and no OnBackPressedDispatcherOwner was " +
+                "provided via LocalOnBackPressedDispatcherOwner. Please provide one of the two."
+        )
+    val dispatcher = remember(owner) {
+        BackHandlerDispatcherCompat(
+            (owner as? NavigationEventDispatcherOwner)?.navigationEventDispatcher,
+            (owner as? OnBackPressedDispatcherOwner)?.onBackPressedDispatcher,
+        )
     }
-    val backDispatcher = checkNotNull(LocalOnBackPressedDispatcherOwner.current) {
-        "No OnBackPressedDispatcherOwner was provided via LocalOnBackPressedDispatcherOwner"
-    }.onBackPressedDispatcher
-    val lifecycleOwner = LocalLifecycleOwner.current
-    DisposableEffect(lifecycleOwner, backDispatcher) {
-        backDispatcher.addCallback(lifecycleOwner, backCallback)
-        onDispose {
-            backCallback.remove()
+    val compositeKey = currentCompositeKeyHashCode
+    val handler = remember(dispatcher, compositeKey) { ComposeBackHandler(BackHandlerInfo(owner, compositeKey)) }
+    if (ActivityFlags.isOnBackPressedLifecycleOrderMaintained) {
+        SideEffect { handler.currentOnBackCompleted = onBack }
+        LifecycleStartEffect(enabled, handler) {
+            handler.isBackEnabled = enabled
+            onStopOrDispose { handler.isBackEnabled = false }
+        }
+        DisposableEffect(dispatcher, handler) {
+            dispatcher.addHandler(handler)
+            onDispose { dispatcher.removeHandler(handler) }
+        }
+    } else {
+        SideEffect {
+            handler.isBackEnabled = enabled
+            handler.currentOnBackCompleted = onBack
+        }
+        LifecycleStartEffect(dispatcher, handler) {
+            dispatcher.addHandler(handler)
+            onStopOrDispose { dispatcher.removeHandler(handler) }
         }
     }
 }
+
+private class ComposeBackHandler(info: BackHandlerInfo) : BackHandlerCompat(info) {
+    var currentOnBackCompleted: () -> Unit = {}
+
+    override fun onBackCompleted() {
+        currentOnBackCompleted()
+    }
+}
+
+private data class BackHandlerInfo(val owner: Any, val compositeKey: Long) : NavigationEventInfo()