peachsim 0.1.657 → 0.1.658

package/dist-lib/swift-compile.cjs

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

package/kotlin/AppSources/androidx/core/view/WindowCompat.kt

@@ -0,0 +1,32 @@
+package androidx.core.view
+
+import android.view.View
+import android.view.Window
+import android.view.WindowInsetsController
+
+// androidx.core's window helpers as they run from API 30, on the platform
+// window and its insets controller
+object WindowCompat {
+    fun setDecorFitsSystemWindows(window: Window, decorFitsSystemWindows: Boolean) {
+        window.setDecorFitsSystemWindows(decorFitsSystemWindows)
+    }
+
+    fun getInsetsController(window: Window, view: View): WindowInsetsControllerCompat =
+        WindowInsetsControllerCompat(window, view)
+}
+
+class WindowInsetsControllerCompat(window: Window, @Suppress("UNUSED_PARAMETER") view: View) {
+    private val controller = window.insetsController
+
+    private fun appearance(flag: Int) = controller.systemBarsAppearance and flag != 0
+    private fun setAppearance(flag: Int, light: Boolean) =
+        controller.setSystemBarsAppearance(if (light) flag else 0, flag)
+
+    var isAppearanceLightStatusBars: Boolean
+        get() = appearance(WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS)
+        set(light) = setAppearance(WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS, light)
+
+    var isAppearanceLightNavigationBars: Boolean
+        get() = appearance(WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS)
+        set(light) = setAppearance(WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS, light)
+}

package/kotlin/AppSources/dev/peach/app/PeachApp.kt

@@ -6,8 +6,12 @@ import android.app.Activity
 import android.app.Application
 import android.content.ComponentName
 import android.content.Intent
+import android.content.res.Configuration
+import android.content.res.Resources
+import android.content.res.processResources
 import android.view.ViewGroup
 import android.view.Window
+import android.view.WindowTheme
 import androidx.activity.ComponentActivity
 import androidx.compose.ui.platform.ComposeView
 import androidx.compose.ui.platform.PlatformArchitectureComponentsOwner
@@ -26,15 +30,14 @@ import preparePeachDevice
 import robotoFamily
 import org.json.JSONObject
 
-// what the manifest and Gradle files resolved: the launcher component the
-// intent names (an alias stays the alias), the activity class it runs, the
-// app's target SDK and theme opt-out, and constructors for the manifest's
+// what the manifest, Gradle files and theme resolved: the launcher component
+// the intent names (an alias stays the alias), the activity class it runs, what
+// its window read from the theme, and constructors for the manifest's
 // Application and that class (wasm has no reflection).
 internal class PeachAppSpec(
     val launcher: ComponentName,
     val component: ComponentName,
-    val targetSdk: Int,
-    val optOutEdgeToEdge: Boolean,
+    val window: WindowTheme,
     val createApplication: () -> Application,
     val createActivity: () -> Activity,
 )
@@ -71,12 +74,16 @@ internal fun peachStartApp(
     spec: PeachAppSpec,
     density: Float, fontScale: Float, locale: String, backend: String, stencilBits: Int,
     regular: String, medium: String, bold: String,
-    statusBar: Int, navigationBar: Int,
+    statusBar: Int, navigationBar: Int, night: Boolean,
     invalidate: (Boolean) -> Unit,
 ): String {
     try {
         require(backend == "graphite" || backend == "raster")
         preparePeachDevice(locale)
+        processResources = Resources(Configuration().apply {
+            uiMode = Configuration.UI_MODE_TYPE_NORMAL or
+                if (night) Configuration.UI_MODE_NIGHT_YES else Configuration.UI_MODE_NIGHT_NO
+        })
         val fonts = robotoFamily(regular, medium, bold)
         val application = spec.createApplication()
         application.onCreate()
@@ -96,11 +103,10 @@ internal fun peachStartApp(
 
             override fun windowChanged() {
                 if (mountId != 0)
-                    mount.emit("window", JSONObject().put("decorFitsSystemWindows", window.fitsSystemWindows).toString())
+                    mount.emitAtFrame("window") { window.describe().toString() }
             }
         }
-        val enforced = spec.targetSdk > 35 || (spec.targetSdk == 35 && !spec.optOutEdgeToEdge)
-        window = Window(activity, enforced, host)
+        window = Window(activity, spec.window, host)
         activity.attach(
             application,
             spec.component,
@@ -124,8 +130,7 @@ internal fun peachStartApp(
             "${spec.component.flattenToShortString()} set no ComposeView as its content; Peach composes only ComposeView content"
         }
         val params = view.layoutParams
-        return JSONObject().put("ok", true).put("id", mountId)
-            .put("decorFitsSystemWindows", window.fitsSystemWindows)
+        return window.describe().put("ok", true).put("id", mountId)
             .put("wrapWidth", params?.width == ViewGroup.LayoutParams.WRAP_CONTENT)
             .put("wrapHeight", params?.height == ViewGroup.LayoutParams.WRAP_CONTENT)
             .toString()

package/kotlin/AppSources/dev/peach/app/PeachWindowHost.kt

@@ -8,6 +8,7 @@ import androidx.compose.ui.platform.ComposeView
 internal interface PeachWindowHost {
     fun compose(view: ComposeView): AutoCloseable
 
-    // the window's inset policy changed after it was added
+    // the inset policy or status bar the window asks the device for changed
+    // after it was added
     fun windowChanged()
 }

package/kotlin/ComposeSources/PeachComposeHost.kt

@@ -131,6 +131,9 @@ internal class PeachComposeMount(
     var constraints = Constraints()
         set(value) { if (field != value) { field = value; needsMeasure = true } }
     private val events = mutableListOf<JSONObject>()
+    // state reported once a frame, read when the frame draws: like the decor,
+    // the device sees the state a frame ends with, not each step to it
+    private val frameState = linkedMapOf<String, () -> Any?>()
     private val platform = PeachComposePlatform(Density(density, fontScale), LocaleList(locale), IntSize.Zero, owners, insets)
     private val recomposer = FrameRecomposer(Dispatchers.Main) { invalidate(false) }
     private var needsMeasure = true
@@ -159,6 +162,11 @@ internal class PeachComposeMount(
         invalidate(false)
     }
 
+    fun emitAtFrame(name: String, args: () -> Any?) {
+        frameState[name] = args
+        invalidate(false)
+    }
+
     fun measure(): IntSize {
         val measured = scene.measureContent(constraints)
         scene.size = measured
@@ -198,7 +206,9 @@ internal class PeachComposeMount(
         scene.draw(canvas.asComposeCanvas())
         val reply = JSONObject().put("width", measured.width).put("height", measured.height)
             .put("pending", recomposer.hasPendingWork() || scene.hasInvalidations())
-            .put("events", JSONArray(events))
+        for ((name, args) in frameState) events.add(JSONObject().put("name", name).put("args", args()))
+        frameState.clear()
+        reply.put("events", JSONArray(events))
         events.clear()
         if (gpu) checkNotNull(surface).flushAndSubmit()
         else {