peachsim 0.1.657 → 0.1.659

package/dist-lib/swift-compile.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.657 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.659 | (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.657 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.659 | (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.657 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.659 | (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.657 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.659 | (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.657 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.659 | (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.657 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.659 | (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.657 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.659 | (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.657 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.659 | (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/vite.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.657 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.659 | (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;
@@ -184,6 +184,7 @@ function isDaemonLockfileFresh(lock, now = Date.now()) {
 }
 
 // src/host/replacement-module-handler.ts
+var import_node_fs3 = require("node:fs");
 var import_promises = __toESM(require("node:fs/promises"), 1);
 var import_node_path3 = __toESM(require("node:path"), 1);
 
@@ -313,12 +314,15 @@ function transformsFor(filePath) {
       );
   }
 }
+function isLocalSpecifier(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../");
+}
 function isContrastKitSpecifier(specifier) {
   return specifier === "contrast-kit" || specifier.startsWith("contrast-kit/");
 }
 function unsupportedSpecifier(specifier) {
   return new Error(
-    `replacement modules may only import react, react-native, contrast-kit, and the packages rnx stubs for this app; '${specifier}' is none of those. vendor the code into the replacement file, or add the package to peach.config so the simulator bridges it.`
+    `replacement modules may only import react, react-native, contrast-kit, the packages rnx stubs for this app, and other project files by relative path; '${specifier}' is none of those. vendor the code into a project file, or add the package to peach.config so the simulator bridges it.`
   );
 }
 function bridgeDeclaration(name, specifier) {
@@ -343,11 +347,9 @@ function compileReplacementModule(input) {
   const transformed = (0, import_dist.transform)(input.source, {
     transforms: transformsFor(input.filePath),
     filePath: input.filePath,
-    // classic runtime, matching what the app's own Metro build does for a file
-    // that has no automatic-runtime pragma: the file imports React itself.
-    jsxRuntime: "classic",
-    jsxPragma: "React.createElement",
-    jsxFragmentPragma: "React.Fragment",
+    // the automatic runtime, as @react-native/babel-preset and babel-preset-expo
+    // compile the app's own files: jsx needs no React import.
+    jsxRuntime: "automatic",
     production: true,
     sourceMapOptions: { compiledFilename: input.filePath }
   });
@@ -374,6 +376,13 @@ function compileReplacementModule(input) {
     return name;
   };
   const edits = [];
+  const pointAtLocalModule = (specifierToken, specifier) => {
+    edits.push({
+      start: specifierToken.start,
+      end: specifierToken.end,
+      text: JSON.stringify(input.localModuleUrl(specifier))
+    });
+  };
   for (let index = 0; index < tokens.length; index++) {
     const token = tokens[index];
     if (token.type === EXPORT_KEYWORD) {
@@ -393,6 +402,10 @@ function compileReplacementModule(input) {
       }
       if (fromAt > 0 && tokens[fromAt] && read(tokens[fromAt]) === "from" && tokens[fromAt + 1]?.type === import_types.TokenType.string) {
         const specifier2 = readSpecifier(tokens[fromAt + 1]);
+        if (isLocalSpecifier(specifier2)) {
+          pointAtLocalModule(tokens[fromAt + 1], specifier2);
+          continue;
+        }
         throw new Error(
           `a replacement module cannot re-export from another module, and this one re-exports from '${specifier2}'. import what you need and export the binding.`
         );
@@ -445,6 +458,10 @@ function compileReplacementModule(input) {
     const specifierToken = tokens[cursor];
     if (!specifierToken) throw new Error("replacement module import is unterminated");
     const specifier = readSpecifier(specifierToken);
+    if (isLocalSpecifier(specifier)) {
+      pointAtLocalModule(specifierToken, specifier);
+      continue;
+    }
     if (specifier !== "react" && specifier !== "react-native" && !JSX_RUNTIME_SPECIFIERS.has(specifier) && !isContrastKitSpecifier(specifier) && !input.runtimePackages.has(specifier)) {
       throw unsupportedSpecifier(specifier);
     }
@@ -501,6 +518,25 @@ function sendJavaScript(req, res, source) {
   });
   res.end(req.method === "HEAD" ? void 0 : source);
 }
+function resolveLocalImport(fromFile, specifier) {
+  const base = import_node_path3.default.resolve(import_node_path3.default.dirname(fromFile), specifier);
+  const candidates = [
+    ...REPLACEMENT_MODULE_EXTENSIONS.some(
+      (ext) => ext === import_node_path3.default.extname(base).toLowerCase()
+    ) ? [base] : [],
+    ...REPLACEMENT_MODULE_EXTENSIONS.map((ext) => base + ext),
+    ...REPLACEMENT_MODULE_EXTENSIONS.map((ext) => import_node_path3.default.join(base, `index${ext}`))
+  ];
+  const found = candidates.find(
+    (candidate) => (0, import_node_fs3.statSync)(candidate, { throwIfNoEntry: false })?.isFile()
+  );
+  if (!found) {
+    throw new Error(
+      `'${specifier}' imported by ${fromFile} matches no ${REPLACEMENT_MODULE_EXTENSIONS.join(", ")} file`
+    );
+  }
+  return found;
+}
 async function handleReplacementModuleRequest(req, res, options = {}) {
   const rawUrl = req.url || "";
   let url;
@@ -582,7 +618,14 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     const compiled = compileReplacementModule({
       filePath: resolvedTargetPath,
       source: await import_promises.default.readFile(resolvedTargetPath, "utf8"),
-      runtimePackages
+      runtimePackages,
+      // the imported file's url is this request's with only its path changed,
+      // so the token, cache key and runtime packages carry over.
+      localModuleUrl: (specifier) => {
+        const local = new URL(url.href);
+        local.searchParams.set("path", resolveLocalImport(targetPath, specifier));
+        return `${local.pathname}${local.search}`;
+      }
     });
     const map = Buffer.from(JSON.stringify(compiled.sourceMap), "utf8").toString("base64");
     sendJavaScript(

package/kotlin/AppSources/android/app/Activity.kt

@@ -48,12 +48,30 @@ open class Activity : ContextWrapper() {
     protected open fun onPostCreate(savedInstanceState: Bundle?) { called = true }
     protected open fun onResume() { called = true }
     protected open fun onPostResume() { called = true }
+    protected open fun onPause() { called = true }
+    protected open fun onStop() { called = true }
+    protected open fun onRestart() { called = true }
+
+    // Activity's own save writes the window's view hierarchy state; the decor
+    // window here holds no view state of its own
+    protected open fun onSaveInstanceState(outState: Bundle) {}
+
+    // a back the window's callbacks left: the activity asks the task manager,
+    // which moves a root launcher task to the back rather than finishing it
+    // (from Android 12). the only activity Peach runs is that task's root.
+    open fun onBackPressed() {
+        movedTaskToBack = true
+    }
+
+    internal var movedTaskToBack = false
 
     // ActivityLifecycleCallbacks' post events; ComponentActivity's lifecycle
     // moves on these, as its ReportFragment does from API 29.
     internal open fun dispatchActivityPostCreated() {}
     internal open fun dispatchActivityPostStarted() {}
     internal open fun dispatchActivityPostResumed() {}
+    internal open fun dispatchActivityPrePaused() {}
+    internal open fun dispatchActivityPreStopped() {}
 
     private fun require(method: String, call: () -> Unit) {
         called = false
@@ -77,6 +95,32 @@ open class Activity : ContextWrapper() {
         require("onPostCreate") { onPostCreate(icicle) }
     }
 
+    internal fun performPause() {
+        dispatchActivityPrePaused()
+        require("onPause") { onPause() }
+    }
+
+    private var stopped = false
+
+    internal fun performStop() {
+        dispatchActivityPreStopped()
+        require("onStop") { onStop() }
+        stopped = true
+    }
+
+    internal fun performSaveInstanceState(outState: Bundle) {
+        onSaveInstanceState(outState)
+    }
+
+    // ActivityThread brings a stopped activity back with onRestart, then
+    // onStart; one that never stopped has nothing to restart
+    internal fun performRestart() {
+        if (!stopped) return
+        stopped = false
+        require("onRestart") { onRestart() }
+        performStart()
+    }
+
     internal fun performResume() {
         require("onResume") { onResume() }
         require("onPostResume") { onPostResume() }

package/kotlin/AppSources/android/app/UiModeManager.kt

@@ -0,0 +1,9 @@
+package android.app
+
+class UiModeManager private constructor() {
+    companion object {
+        const val MODE_NIGHT_AUTO = 0
+        const val MODE_NIGHT_NO = 1
+        const val MODE_NIGHT_YES = 2
+    }
+}

package/kotlin/AppSources/android/content/Context.kt

@@ -1,5 +1,12 @@
 package android.content
 
-abstract class Context
+import android.content.res.Resources
+import android.content.res.processResources
 
-open class ContextWrapper : Context()
+abstract class Context {
+    abstract val resources: Resources
+}
+
+open class ContextWrapper : Context() {
+    override val resources: Resources get() = processResources
+}

package/kotlin/AppSources/android/content/res/Configuration.kt

@@ -0,0 +1,16 @@
+package android.content.res
+
+// the device configuration an app reads through its resources: a phone's
+// normal ui mode type, night or not as the device's dark theme is set
+class Configuration {
+    var uiMode: Int = UI_MODE_TYPE_NORMAL or UI_MODE_NIGHT_NO
+
+    companion object {
+        const val UI_MODE_TYPE_MASK = 0x0f
+        const val UI_MODE_TYPE_NORMAL = 0x01
+        const val UI_MODE_NIGHT_MASK = 0x30
+        const val UI_MODE_NIGHT_UNDEFINED = 0x00
+        const val UI_MODE_NIGHT_NO = 0x10
+        const val UI_MODE_NIGHT_YES = 0x20
+    }
+}

package/kotlin/AppSources/android/content/res/Resources.kt

@@ -0,0 +1,7 @@
+package android.content.res
+
+class Resources internal constructor(val configuration: Configuration)
+
+// the app process's resources, set once the device configuration is known at
+// cold start; every context in the process reads the same configuration
+internal lateinit var processResources: Resources

package/kotlin/AppSources/android/graphics/Color.kt

@@ -0,0 +1,13 @@
+package android.graphics
+
+// the packed ARGB ints android.graphics.Color names and builds
+object Color {
+    const val BLACK = -0x1000000
+    const val WHITE = -0x1
+    const val TRANSPARENT = 0
+
+    fun argb(alpha: Int, red: Int, green: Int, blue: Int): Int =
+        (alpha shl 24) or (red shl 16) or (green shl 8) or blue
+
+    fun alpha(color: Int): Int = color ushr 24
+}

package/kotlin/AppSources/android/os/Bundle.kt

@@ -1,5 +1,11 @@
 package android.os
 
-// a cold start has no saved instance state, so the launcher receives null;
-// the type exists for the signatures that name it.
-class Bundle
+import androidx.savedstate.SavedState
+import androidx.savedstate.savedState
+
+// on Android androidx's SavedState is Bundle; here a Bundle holds the
+// multiplatform SavedState that a save writes into. a cold start has no saved
+// instance state, so the launcher receives null.
+class Bundle internal constructor(internal val state: SavedState) {
+    constructor() : this(savedState())
+}

package/kotlin/AppSources/android/view/View.kt

@@ -1,8 +1,10 @@
 package android.view
 
 import android.content.Context
+import android.content.res.Resources
 
 open class View(val context: Context) {
+    val resources: Resources get() = context.resources
     var parent: ViewGroup? = null
         internal set
     var layoutParams: ViewGroup.LayoutParams? = null

package/kotlin/AppSources/android/view/Window.kt

@@ -1,33 +1,124 @@
 package android.view
 
 import android.content.Context
+import android.graphics.Color
 import android.widget.FrameLayout
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
 import dev.peach.app.PeachWindowHost
+import org.json.JSONObject
+
+// what PhoneWindow.generateLayout read from the activity's theme
+internal class WindowTheme(
+    val edgeToEdgeEnforced: Boolean,
+    val statusBarColor: Int,
+    val statusBarContrastEnforced: Boolean,
+    val navigationBarContrastEnforced: Boolean,
+    val lightStatusBar: Boolean,
+    val lightNavigationBar: Boolean,
+)
+
+// DecorView's light contrast scrim behind a transparent bar
+private const val SCRIM_LIGHT = -0x19000001
 
 // PhoneWindow's content parent (android.R.id.content) inside its decor. the
 // window is added, and its views attached, after the activity resumes.
 class Window internal constructor(
     context: Context,
-    private val edgeToEdgeEnforced: Boolean,
+    theme: WindowTheme,
     internal val host: PeachWindowHost,
 ) {
+    private val edgeToEdgeEnforced = theme.edgeToEdgeEnforced
     internal val contentParent = FrameLayout(context)
     val decorView: View get() = contentParent
+    val attributes = WindowManager.LayoutParams()
 
-    // PhoneWindow fits system windows unless told otherwise, and applies that
-    // only while edge to edge is not enforced for the app's target SDK
-    private var decorFitsSystemWindows by mutableStateOf(true)
-    internal val fitsSystemWindows: Boolean get() = decorFitsSystemWindows && !edgeToEdgeEnforced
+    // PhoneWindow fits system windows until told otherwise; an enforced edge
+    // to edge window never does, and ignores the request
+    private var fits by mutableStateOf(!edgeToEdgeEnforced)
+    internal val fitsSystemWindows: Boolean get() = fits
 
     fun setDecorFitsSystemWindows(decorFitsSystemWindows: Boolean) {
-        val before = fitsSystemWindows
-        this.decorFitsSystemWindows = decorFitsSystemWindows
-        if (fitsSystemWindows != before) host.windowChanged()
+        if (edgeToEdgeEnforced || fits == decorFitsSystemWindows) return
+        fits = decorFitsSystemWindows
+        host.windowChanged()
     }
 
+    fun decorFitsSystemWindows(): Boolean = fits
+
+    // the theme's statusBarColor, transparent while edge to edge is enforced,
+    // where setting it does nothing
+    private var statusBar = if (edgeToEdgeEnforced) Color.TRANSPARENT else theme.statusBarColor
+
+    var statusBarColor: Int
+        get() = statusBar
+        set(color) {
+            if (edgeToEdgeEnforced || color == statusBar) return
+            statusBar = color
+            host.windowChanged()
+        }
+
+    fun getStatusBarColor(): Int = statusBarColor
+    fun setStatusBarColor(color: Int) { statusBarColor = color }
+
+    // the theme's navigation bar color resolves through device configuration
+    // peach kotlin does not model, so it reads only once the app sets it; an
+    // enforced edge to edge window reports transparent
+    private var navigationBar: Int? = null
+
+    var navigationBarColor: Int
+        get() = if (edgeToEdgeEnforced) Color.TRANSPARENT
+            else checkNotNull(navigationBar) { "the theme's navigation bar color is not modeled; read it after setting it" }
+        set(color) { navigationBar = color }
+
+    fun getNavigationBarColor(): Int = navigationBarColor
+    fun setNavigationBarColor(color: Int) { navigationBarColor = color }
+
+    var isStatusBarContrastEnforced: Boolean = theme.statusBarContrastEnforced
+        set(value) {
+            if (field == value) return
+            field = value
+            host.windowChanged()
+        }
+
+    var isNavigationBarContrastEnforced: Boolean = theme.navigationBarContrastEnforced
+
+    fun setStatusBarContrastEnforced(enforced: Boolean) { isStatusBarContrastEnforced = enforced }
+    fun setNavigationBarContrastEnforced(enforced: Boolean) { isNavigationBarContrastEnforced = enforced }
+
+    val insetsController: WindowInsetsController = object : WindowInsetsController {
+        private var appearance =
+            (if (theme.lightStatusBar) WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS else 0) or
+                (if (theme.lightNavigationBar) WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS else 0)
+
+        override val systemBarsAppearance: Int get() = appearance
+
+        override fun setSystemBarsAppearance(appearance: Int, mask: Int) {
+            val next = (this.appearance and mask.inv()) or (appearance and mask)
+            if (next == this.appearance) return
+            this.appearance = next
+            host.windowChanged()
+        }
+    }
+
+    // DecorView.calculateBarColor for the status bar of a window that draws
+    // its bar backgrounds: a transparent color under enforced contrast shows
+    // the scrim for the bar's appearance
+    private fun drawnStatusBarColor(): Int {
+        if (!isStatusBarContrastEnforced || Color.alpha(statusBar) != 0) return statusBar
+        check(insetsController.systemBarsAppearance and WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS != 0) {
+            "a dark status bar's contrast scrim is the device's dynamic system_bar_background_semi_transparent, which peach kotlin does not model"
+        }
+        return SCRIM_LIGHT
+    }
+
+    // what the decor draws for this window: its inset policy and its status
+    // bar color as unsigned ARGB
+    internal fun describe(): JSONObject = JSONObject()
+        .put("decorFitsSystemWindows", fits)
+        .put("statusBarColor", drawnStatusBarColor().toLong() and 0xffffffffL)
+
     // Activity.setContentView(View) fills the content parent
     internal fun setContentView(view: View, params: ViewGroup.LayoutParams) {
         contentParent.removeAllViews()

package/kotlin/AppSources/android/view/WindowInsetsController.kt

@@ -0,0 +1,12 @@
+package android.view
+
+// the window's requested system bar appearance: light bars ask for dark icons
+interface WindowInsetsController {
+    fun setSystemBarsAppearance(appearance: Int, mask: Int)
+    val systemBarsAppearance: Int
+
+    companion object {
+        const val APPEARANCE_LIGHT_STATUS_BARS = 1 shl 3
+        const val APPEARANCE_LIGHT_NAVIGATION_BARS = 1 shl 4
+    }
+}

package/kotlin/AppSources/android/view/WindowManager.kt

@@ -0,0 +1,16 @@
+package android.view
+
+interface WindowManager {
+    // the window attributes edge to edge code sets; the cutout mode is held as
+    // the app sets it
+    class LayoutParams {
+        var layoutInDisplayCutoutMode: Int = LAYOUT_IN_DISPLAY_CUTOUT_MODE_DEFAULT
+
+        companion object {
+            const val LAYOUT_IN_DISPLAY_CUTOUT_MODE_DEFAULT = 0
+            const val LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES = 1
+            const val LAYOUT_IN_DISPLAY_CUTOUT_MODE_NEVER = 2
+            const val LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS = 3
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+package androidx.activity
+
+// androidx.activity's BackEventCompat: one predictive back gesture sample
+class BackEventCompat(
+    val touchX: Float,
+    val touchY: Float,
+    val progress: Float,
+    val swipeEdge: Int,
+) {
+    override fun toString(): String =
+        "BackEventCompat{touchX=$touchX, touchY=$touchY, progress=$progress, swipeEdge=$swipeEdge}"
+
+    companion object {
+        const val EDGE_LEFT = 0
+        const val EDGE_RIGHT = 1
+    }
+}

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

@@ -0,0 +1,5 @@
+package androidx.activity
+
+internal interface Cancellable {
+    fun cancel()
+}

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

@@ -21,10 +21,11 @@ import androidx.savedstate.SavedStateRegistryOwner
 
 // androidx.activity's ComponentActivity owners, on the multiplatform
 // lifecycle, viewmodel and savedstate libraries: the registry attaches in the
-// constructor and restores in onCreate before super, the lifecycle moves on
-// the post callbacks, and destroy clears the view model store.
+// constructor and restores in onCreate before super, the lifecycle moves up on
+// the post callbacks and down on the pre callbacks, as ReportFragment does from
+// API 29, and destroy clears the view model store.
 open class ComponentActivity : Activity(), LifecycleOwner, ViewModelStoreOwner,
-    HasDefaultViewModelProviderFactory, SavedStateRegistryOwner {
+    HasDefaultViewModelProviderFactory, SavedStateRegistryOwner, OnBackPressedDispatcherOwner {
     private val lifecycleRegistry = LifecycleRegistry(this)
     private val savedStateRegistryController = SavedStateRegistryController.create(this)
 
@@ -51,7 +52,25 @@ open class ComponentActivity : Activity(), LifecycleOwner, ViewModelStoreOwner,
         super.onCreate(savedInstanceState)
     }
 
+    override fun onSaveInstanceState(outState: Bundle) {
+        lifecycleRegistry.currentState = Lifecycle.State.CREATED
+        super.onSaveInstanceState(outState)
+        savedStateRegistryController.performSave(outState.state)
+    }
+
+    // the dispatcher gets the back first; without an enabled callback it falls
+    // back to Activity's own
+    override fun onBackPressed() {
+        onBackPressedDispatcher.onBackPressed()
+    }
+
+    final override val onBackPressedDispatcher: OnBackPressedDispatcher by lazy {
+        OnBackPressedDispatcher { super@ComponentActivity.onBackPressed() }
+    }
+
     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)
+    override fun dispatchActivityPrePaused() = lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE)
+    override fun dispatchActivityPreStopped() = lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
 }

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

@@ -0,0 +1,71 @@
+package androidx.activity
+
+import android.app.UiModeManager
+import android.content.res.Configuration
+import android.content.res.Resources
+import android.graphics.Color
+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.
+
+// DecorView's light scrim and the platform's dark scrim
+internal val DefaultLightScrim = Color.argb(0xe6, 0xFF, 0xFF, 0xFF)
+internal val DefaultDarkScrim = Color.argb(0x80, 0x1b, 0x1b, 0x1b)
+
+fun ComponentActivity.enableEdgeToEdge(
+    statusBarStyle: SystemBarStyle = SystemBarStyle.auto(Color.TRANSPARENT, Color.TRANSPARENT),
+    navigationBarStyle: SystemBarStyle = SystemBarStyle.auto(DefaultLightScrim, DefaultDarkScrim),
+) {
+    val view = window.decorView
+    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.isNavigationBarContrastEnforced = navigationBarStyle.nightMode == UiModeManager.MODE_NIGHT_AUTO
+    WindowInsetsControllerCompat(window, view).run {
+        isAppearanceLightStatusBars = !statusBarIsDark
+        isAppearanceLightNavigationBars = !navigationBarIsDark
+    }
+    window.attributes.layoutInDisplayCutoutMode =
+        WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS
+}
+
+class SystemBarStyle private constructor(
+    private val lightScrim: Int,
+    internal val darkScrim: Int,
+    internal val nightMode: Int,
+    internal val detectDarkMode: (Resources) -> Boolean,
+) {
+    companion object {
+        fun auto(
+            lightScrim: Int,
+            darkScrim: Int,
+            detectDarkMode: (Resources) -> Boolean = { resources ->
+                (resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) ==
+                    Configuration.UI_MODE_NIGHT_YES
+            },
+        ): SystemBarStyle = SystemBarStyle(lightScrim, darkScrim, UiModeManager.MODE_NIGHT_AUTO, detectDarkMode)
+
+        fun dark(scrim: Int): SystemBarStyle =
+            SystemBarStyle(scrim, scrim, UiModeManager.MODE_NIGHT_YES) { true }
+
+        fun light(scrim: Int, darkScrim: Int): SystemBarStyle =
+            SystemBarStyle(scrim, darkScrim, UiModeManager.MODE_NIGHT_NO) { false }
+    }
+
+    internal fun getScrim(isDark: Boolean) = if (isDark) darkScrim else lightScrim
+
+    internal fun getScrimWithEnforcedContrast(isDark: Boolean): Int = when {
+        nightMode == UiModeManager.MODE_NIGHT_AUTO -> Color.TRANSPARENT
+        isDark -> darkScrim
+        else -> lightScrim
+    }
+}