peachsim 0.1.658 → 0.1.660

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

@@ -0,0 +1,144 @@
+package androidx.activity
+
+import java.lang.Runnable
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.LifecycleOwner
+
+// 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.
+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
+
+    constructor(fallbackOnBackPressed: Runnable? = null) : this(fallbackOnBackPressed, null)
+
+    private fun updateEnabledCallbacks() {
+        val hadEnabledCallbacks = hasEnabledCallbacks
+        val hasEnabledCallbacks = onBackPressedCallbacks.any { it.isEnabled }
+        this.hasEnabledCallbacks = hasEnabledCallbacks
+        if (hasEnabledCallbacks != hadEnabledCallbacks)
+            onHasEnabledCallbacksChanged?.invoke(hasEnabledCallbacks)
+    }
+
+    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
+    }
+
+    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
+    }
+
+    fun hasEnabledCallbacks(): Boolean = hasEnabledCallbacks
+
+    fun dispatchOnBackStarted(backEvent: BackEventCompat) {
+        val callback = onBackPressedCallbacks.lastOrNull { it.isEnabled }
+        if (inProgressCallback != null) dispatchOnBackCancelled()
+        inProgressCallback = callback
+        callback?.handleOnBackStarted(backEvent)
+    }
+
+    fun dispatchOnBackProgressed(backEvent: BackEventCompat) {
+        val callback = inProgressCallback ?: onBackPressedCallbacks.lastOrNull { it.isEnabled }
+        callback?.handleOnBackProgressed(backEvent)
+    }
+
+    fun onBackPressed() {
+        val callback = inProgressCallback ?: onBackPressedCallbacks.lastOrNull { it.isEnabled }
+        inProgressCallback = null
+        if (callback != null) {
+            callback.handleOnBackPressed()
+            return
+        }
+        fallbackOnBackPressed?.run()
+    }
+
+    fun dispatchOnBackCancelled() {
+        val callback = inProgressCallback ?: onBackPressedCallbacks.lastOrNull { it.isEnabled }
+        inProgressCallback = null
+        callback?.handleOnBackCancelled()
+    }
+
+    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)
+        }
+
+        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 cancel() {
+            lifecycle.removeObserver(this)
+            onBackPressedCallback.removeCancellable(this)
+            currentCancellable?.cancel()
+            currentCancellable = null
+        }
+    }
+}
+
+// androidx.activity's Kotlin registration: a callback from a lambda, bound to
+// owner's lifecycle when one is given
+fun OnBackPressedDispatcher.addCallback(
+    owner: LifecycleOwner? = null,
+    enabled: Boolean = true,
+    onBackPressed: OnBackPressedCallback.() -> Unit
+): OnBackPressedCallback {
+    val callback = object : OnBackPressedCallback(enabled) {
+        override fun handleOnBackPressed() {
+            onBackPressed()
+        }
+    }
+    if (owner != null) {
+        addCallback(owner, callback)
+    } else {
+        addCallback(callback)
+    }
+    return callback
+}

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

@@ -0,0 +1,7 @@
+package androidx.activity
+
+import androidx.lifecycle.LifecycleOwner
+
+interface OnBackPressedDispatcherOwner : LifecycleOwner {
+    val onBackPressedDispatcher: OnBackPressedDispatcher
+}

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

@@ -0,0 +1,55 @@
+package androidx.activity.compose
+
+import androidx.activity.OnBackPressedCallback
+import androidx.activity.OnBackPressedDispatcherOwner
+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.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.lifecycle.compose.LocalLifecycleOwner
+
+// activity-compose 1.9.3'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.
+object LocalOnBackPressedDispatcherOwner {
+    private val LocalOnBackPressedDispatcherOwner =
+        compositionLocalOf<OnBackPressedDispatcherOwner?> { null }
+
+    val current: OnBackPressedDispatcherOwner?
+        @Composable
+        get() = LocalOnBackPressedDispatcherOwner.current
+
+    infix fun provides(dispatcherOwner: OnBackPressedDispatcherOwner): ProvidedValue<OnBackPressedDispatcherOwner?> =
+        LocalOnBackPressedDispatcherOwner.provides(dispatcherOwner)
+}
+
+// activity-compose 1.9.3's BackHandler
+@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 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()
+        }
+    }
+}

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

@@ -2,6 +2,8 @@
 
 package dev.peach.app
 
+import android.os.Bundle
+
 import android.app.Activity
 import android.app.Application
 import android.content.ComponentName
@@ -13,19 +15,25 @@ import android.view.ViewGroup
 import android.view.Window
 import android.view.WindowTheme
 import androidx.activity.ComponentActivity
+import androidx.activity.compose.LocalOnBackPressedDispatcherOwner
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.ui.platform.ComposeView
 import androidx.compose.ui.platform.PlatformArchitectureComponentsOwner
 import androidx.compose.ui.platform.PlatformInsets
 import androidx.compose.ui.platform.PlatformWindowInsets
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
+import androidx.compose.ui.text.font.FontFamily
 import androidx.lifecycle.Lifecycle
 import androidx.navigationevent.NavigationEventDispatcher
 import androidx.navigationevent.NavigationEventDispatcherOwner
 import PeachComposeMount
 import addMount
+import mounts
 import preparePeachDevice
 import robotoFamily
 import org.json.JSONObject
@@ -40,6 +48,9 @@ internal class PeachAppSpec(
     val window: WindowTheme,
     val createApplication: () -> Application,
     val createActivity: () -> Activity,
+    // the activity's configChanges includes uiMode: it takes a night mode
+    // change in onConfigurationChanged rather than relaunching
+    val handlesUiMode: Boolean,
 )
 
 // the system bars the device delivers to the window's content, in pixels: all
@@ -66,6 +77,41 @@ private class ActivityOwners(activity: ComponentActivity) : PlatformArchitecture
     }
 }
 
+// the device and the application one started app process keeps, and what
+// ActivityThread's record holds for its one activity: whether it is paused or
+// stopped, and the state it saved when it stopped, until it resumes
+private class AppProcess(
+    val spec: PeachAppSpec,
+    val application: Application,
+    val density: Float, val fontScale: Float, val locale: String, val gpu: Boolean, val stencilBits: Int,
+    val fonts: FontFamily,
+    val statusBar: Int, val navigationBar: Int,
+    val invalidate: (Boolean) -> Unit,
+) {
+    lateinit var activity: Activity
+    lateinit var mount: PeachComposeMount
+    // the window the device presents, once its scene is in place
+    var window: Window? = null
+    var mountId = 0
+    // the held view's place among its window's views; a relaunched window's
+    // first view takes the place the last window's view held, as it takes
+    // that view's saved state on the device
+    var view = 0
+    var paused = false
+    var stopped = false
+    var state: Bundle? = null
+    // the night mode last reported to the activity: ActivityRecord compares
+    // the configuration with it before a relaunch or onConfigurationChanged
+    var reportedNight = false
+}
+
+private var process: AppProcess? = null
+
+private fun nightConfiguration(night: Boolean) = Configuration().apply {
+    uiMode = Configuration.UI_MODE_TYPE_NORMAL or
+        if (night) Configuration.UI_MODE_NIGHT_YES else Configuration.UI_MODE_NIGHT_NO
+}
+
 // a cold start in ActivityThread's order: the Application and its onCreate,
 // then the launcher activity attached to its window and launcher intent,
 // onCreate, onStart, onPostCreate, onResume and onPostResume, and only then the
@@ -80,57 +126,17 @@ internal fun peachStartApp(
     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)
+        processResources = Resources(nightConfiguration(night))
         val application = spec.createApplication()
         application.onCreate()
-        val activity = spec.createActivity()
-        val componentActivity = activity as? ComponentActivity
-        lateinit var window: Window
-        lateinit var mount: PeachComposeMount
-        var mountId = 0
-        // the window's one scene composes the ComposeView it holds; a new
-        // view starts a new composition, as on the device
-        var held by mutableStateOf<ComposeView?>(null)
-        val host = object : PeachWindowHost {
-            override fun compose(view: ComposeView): AutoCloseable {
-                held = view
-                return AutoCloseable { if (held === view) held = null }
-            }
-
-            override fun windowChanged() {
-                if (mountId != 0)
-                    mount.emitAtFrame("window") { window.describe().toString() }
-            }
-        }
-        window = Window(activity, spec.window, host)
-        activity.attach(
-            application,
-            spec.component,
-            Intent(Intent.ACTION_MAIN, setOf(Intent.CATEGORY_LAUNCHER), spec.launcher),
-            window,
-        )
-        activity.performCreate(null)
-        activity.performStart()
-        activity.performPostCreate(null)
-        activity.performResume()
-        mount = PeachComposeMount(
-            density, fontScale, locale, backend == "graphite", stencilBits, fonts, invalidate,
-            owners = componentActivity?.let(::ActivityOwners),
-            insets = SystemBarInsets(window, statusBar, navigationBar),
-            clockRunning = { componentActivity == null || componentActivity.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED) },
+        val app = AppProcess(
+            spec, application, density, fontScale, locale, backend == "graphite", stencilBits,
+            robotoFamily(regular, medium, bold), statusBar, navigationBar, invalidate,
         )
-        mount.setContent { held?.let { view -> key(view) { view.Content() } } }
-        mountId = addMount(mount)
-        window.addToWindowManager()
-        val view = checkNotNull(held) {
-            "${spec.component.flattenToShortString()} set no ComposeView as its content; Peach composes only ComposeView content"
-        }
+        process = app
+        val view = launchActivity(app, null)
         val params = view.layoutParams
-        return window.describe().put("ok", true).put("id", mountId)
+        return app.activity.window.describe().put("ok", true).put("id", app.mountId)
             .put("wrapWidth", params?.width == ViewGroup.LayoutParams.WRAP_CONTENT)
             .put("wrapHeight", params?.height == ViewGroup.LayoutParams.WRAP_CONTENT)
             .toString()
@@ -139,3 +145,181 @@ internal fun peachStartApp(
             .put("error", "${error::class.simpleName}: ${error.message}").toString()
     }
 }
+
+// ActivityThread's handleLaunchActivity: a new instance of the launcher
+// activity created from the state its last instance saved, if any, with what
+// that instance retained, then started, restored, resumed and its window
+// added. the window's scene takes the process's mount id, so the device keeps
+// presenting it.
+private fun launchActivity(app: AppProcess, lastNonConfigurationInstance: Any?): ComposeView {
+    val spec = app.spec
+    val activity = spec.createActivity()
+    val componentActivity = activity as? ComponentActivity
+    val state = app.state
+    lateinit var window: Window
+    lateinit var mount: PeachComposeMount
+    // the window's one scene composes the ComposeView it holds; a new
+    // view starts a new composition, as on the device. the key is the view's
+    // place, not the view, so a relaunched window's view lands on the keys its
+    // saved state was written under
+    var held by mutableStateOf<ComposeView?>(null)
+    var place by mutableIntStateOf((app.view - 1).coerceAtLeast(0))
+    val host = object : PeachWindowHost {
+        override fun compose(view: ComposeView): AutoCloseable {
+            held = view
+            place += 1
+            app.view = place
+            return AutoCloseable { if (held === view) held = null }
+        }
+
+        // a change before the window is presented reaches the device with
+        // the window itself
+        override fun windowChanged() {
+            if (app.window === window)
+                mount.emitAtFrame("window") { window.describe().toString() }
+        }
+    }
+    window = Window(activity, spec.window, host)
+    activity.attach(
+        app.application,
+        spec.component,
+        Intent(Intent.ACTION_MAIN, setOf(Intent.CATEGORY_LAUNCHER), spec.launcher),
+        window,
+        lastNonConfigurationInstance,
+    )
+    activity.performCreate(state)
+    activity.performStart()
+    if (state != null) activity.performRestoreInstanceState(state)
+    activity.performPostCreate(state)
+    activity.performResume()
+    app.activity = activity
+    app.paused = false
+    app.stopped = false
+    app.state = null
+    app.reportedNight = isNight(activity.resources.configuration)
+    mount = PeachComposeMount(
+        app.density, app.fontScale, app.locale, app.gpu, app.stencilBits, app.fonts, app.invalidate,
+        night = isNight(activity.resources.configuration),
+        owners = componentActivity?.let(::ActivityOwners),
+        insets = SystemBarInsets(window, app.statusBar, app.navigationBar),
+        clockRunning = { componentActivity == null || componentActivity.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED) },
+    )
+    mount.setContent {
+        val content = @Composable { held?.let { view -> key(place) { view.Content() } }; Unit }
+        // the content view's tree resolves the activity as its back dispatcher owner
+        if (componentActivity != null)
+            CompositionLocalProvider(LocalOnBackPressedDispatcherOwner provides componentActivity, content = content)
+        else content()
+    }
+    if (app.mountId == 0) app.mountId = addMount(mount)
+    else {
+        // the relaunched window takes the device's bounds and reports its
+        // window, which the new instance may have set differently
+        mount.constraints = app.mount.constraints
+        mounts[app.mountId] = mount
+        mount.emitAtFrame("window") { window.describe().toString() }
+        app.invalidate(true)
+    }
+    app.mount = mount
+    app.window = window
+    window.addToWindowManager()
+    return checkNotNull(held) {
+        "${spec.component.flattenToShortString()} set no ComposeView as its content; Peach composes only ComposeView content"
+    }
+}
+
+private fun runningApp() = checkNotNull(process) { "the app is not running" }
+
+// the device's back: an activity with predictive back gets it through its
+// window's back dispatch, where ComponentActivity's dispatcher takes it only
+// while a callback is enabled and the activity's own default handles the
+// rest; without predictive back the key reaches onBackPressed. false when the
+// task moved to the back, which the device then shows as home.
+internal fun peachAppBack(predictive: Boolean): Boolean {
+    val activity = runningApp().activity
+    activity.movedTaskToBack = false
+    val dispatcher = (activity as? ComponentActivity)?.onBackPressedDispatcher
+    if (!predictive) activity.onBackPressed()
+    else if (dispatcher?.hasEnabledCallbacks() == true) dispatcher.onBackPressed()
+    else activity.movedTaskToBack = true
+    return !activity.movedTaskToBack
+}
+
+// ActivityThread's pause and stop; from API 28 an activity that stops saves
+// its state after onStop, kept for a relaunch until it resumes
+private fun pauseAndStop(app: AppProcess) {
+    if (!app.paused) {
+        app.activity.performPause()
+        app.paused = true
+    }
+    if (!app.stopped) {
+        app.activity.performStop()
+        app.stopped = true
+        app.state = Bundle().also(app.activity::performSaveInstanceState)
+    }
+}
+
+// the task left the foreground (onPause, onStop, onSaveInstanceState) or came
+// back to it (onRestart, onStart, onResume, onPostResume). a configuration
+// that changed while it was stopped reaches it first: a relaunch in place of
+// the restart, or onConfigurationChanged.
+internal fun peachAppTask(foreground: Boolean) {
+    val app = runningApp()
+    if (!foreground) return pauseAndStop(app)
+    if (reportConfiguration(app)) return
+    app.activity.performRestart()
+    app.activity.performResume()
+    app.paused = false
+    app.stopped = false
+    app.state = null
+    // the frame clock runs again once the activity is started
+    app.mount.invalidate(false)
+}
+
+// gives a visible activity the process configuration when it differs from the
+// one last reported to it: a relaunch, or onConfigurationChanged under
+// configChanges uiMode. true when it relaunched.
+private fun reportConfiguration(app: AppProcess): Boolean {
+    val configuration = processResources.configuration
+    if (isNight(configuration) == app.reportedNight) return false
+    if (!app.spec.handlesUiMode) {
+        relaunch(app)
+        return true
+    }
+    app.reportedNight = isNight(configuration)
+    app.activity.performConfigurationChanged(Configuration().apply { setTo(configuration) })
+    app.mount.night = app.reportedNight
+    return false
+}
+
+private fun isNight(configuration: Configuration) =
+    configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK == Configuration.UI_MODE_NIGHT_YES
+
+// the device's night mode changed. the process's configuration changes in
+// place and the Application hears it first; a visible activity then takes it.
+// a stopped activity takes it once visible again, if it still differs.
+internal fun peachAppNight(night: Boolean) {
+    val app = runningApp()
+    val configuration = processResources.configuration
+    if (isNight(configuration) == night) return
+    configuration.setTo(nightConfiguration(night))
+    app.application.onConfigurationChanged(Configuration().apply { setTo(configuration) })
+    if (!app.stopped) reportConfiguration(app)
+}
+
+// ActivityThread's handleRelaunchActivityInner: pause and stop with the state
+// saved, collect what the next instance keeps, destroy, then launch anew
+private fun relaunch(app: AppProcess) {
+    val old = app.activity
+    val oldMount = app.mount
+    old.isChangingConfigurations = true
+    pauseAndStop(app)
+    val retained = old.retainNonConfigurationInstances()
+    old.performDestroy()
+    old.window.removeFromWindowManager()
+    try {
+        launchActivity(app, retained)
+    } finally {
+        oldMount.close()
+    }
+}

package/kotlin/AppSources/java/lang/Runnable.kt

@@ -0,0 +1,6 @@
+package java.lang
+
+// java.lang.Runnable, which the platform and androidx signatures name
+fun interface Runnable {
+    fun run()
+}

package/kotlin/ComposeSources/PeachComposeHost.kt

@@ -7,6 +7,7 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.snapshots.Snapshot
+import androidx.compose.ui.LocalSystemTheme
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.graphics.asComposeCanvas
 import androidx.compose.ui.input.InputMode
@@ -44,6 +45,7 @@ import androidx.compose.ui.unit.LayoutDirection
 import dev.onejs.one.OneNativeSourceViewDispatch
 import kotlin.io.encoding.Base64
 import kotlinx.coroutines.Dispatchers
+import org.jetbrains.skiko.SystemTheme
 import org.jetbrains.skia.BackendRenderTarget
 import org.jetbrains.skia.Bitmap
 import org.jetbrains.skia.Color
@@ -123,11 +125,14 @@ internal class PeachComposeMount(
     private val stencilBits: Int,
     private val fonts: FontFamily,
     val invalidate: (Boolean) -> Unit,
+    night: Boolean,
     owners: PlatformArchitectureComponentsOwner? = null,
     insets: PlatformWindowInsets? = null,
     private val clockRunning: () -> Boolean = { true },
 ) : AutoCloseable {
     var props by mutableStateOf("")
+    // the configuration's night mode, which isSystemInDarkTheme reads
+    var night by mutableStateOf(night)
     var constraints = Constraints()
         set(value) { if (field != value) { field = value; needsMeasure = true } }
     private val events = mutableListOf<JSONObject>()
@@ -150,7 +155,11 @@ internal class PeachComposeMount(
 
     fun setContent(content: @Composable () -> Unit) {
         try {
-            scene.setContent { PeachAndroidFonts(fonts, content) }
+            scene.setContent {
+                CompositionLocalProvider(LocalSystemTheme provides if (night) SystemTheme.DARK else SystemTheme.LIGHT) {
+                    PeachAndroidFonts(fonts, content)
+                }
+            }
         } catch (failure: Throwable) {
             close()
             throw failure
@@ -289,7 +298,7 @@ internal fun robotoFamily(regular: String, medium: String, bold: String) = FontF
 
 @JsExport
 fun peachViewMount(source: String, view: String, hash: String, props: String,
-    density: Float, fontScale: Float, locale: String, backend: String, stencilBits: Int,
+    density: Float, fontScale: Float, locale: String, night: Boolean, backend: String, stencilBits: Int,
     regular: String, medium: String, bold: String, invalidate: (Boolean) -> Unit): String {
     try {
         val dispatch = peachViewDispatcher(source)
@@ -297,7 +306,7 @@ fun peachViewMount(source: String, view: String, hash: String, props: String,
             .put("error", "composable source $source changed; rebuild the app").toString()
         require(backend == "graphite" || backend == "raster")
         preparePeachDevice(locale)
-        val mount = PeachComposeMount(density, fontScale, locale, backend == "graphite", stencilBits, robotoFamily(regular, medium, bold), invalidate)
+        val mount = PeachComposeMount(density, fontScale, locale, backend == "graphite", stencilBits, robotoFamily(regular, medium, bold), invalidate, night)
         mount.props = props
         mount.setContent { dispatch.Content(view, mount.props, mount::emit) }
         return JSONObject().put("ok", true).put("id", addMount(mount)).toString()
@@ -307,6 +316,9 @@ fun peachViewMount(source: String, view: String, hash: String, props: String,
 }
 
 @JsExport fun peachViewUpdate(id: Int, props: String) { checkNotNull(mounts[id]).props = props }
+// a host activity that handles uiMode itself, as React Native's does, keeps
+// its views and hands them the new configuration
+@JsExport fun peachViewNight(id: Int, night: Boolean) { checkNotNull(mounts[id]).night = night }
 @JsExport fun peachViewConstraints(id: Int, minWidth: Int, maxWidth: Int, minHeight: Int, maxHeight: Int) {
     checkNotNull(mounts[id]).also {
         it.constraints = Constraints(minWidth, maxWidth, minHeight, maxHeight)

package/kotlin/fork/README.md

@@ -10,6 +10,7 @@ builds until upstream supplies equivalent worker and native host hooks.
 | --- | --- | --- |
 | Compose `ui` | `Actuals.wasm.kt` | clock reads `globalThis.performance.now()` |
 | Compose `ui` | `PlatformClipboard.web.kt` | worker-safe secure-context and clipboard reads |
+| Compose `ui` | `SystemTheme.kt` | `LocalSystemTheme` visible to the host, which provides the device's night mode |
 | Compose `ui-text` | `PlatformLocale.web.kt` | explicit `setPlatformLocaleProvider`; its default keeps upstream navigator behavior |
 | Skiko | `OsArch.web.kt` | explicit `setHostOsProvider`; its default lazily retains upstream OS detection |
 | Skiko | `Actuals.web.kt` | nanosecond clock reads `globalThis.performance.now()` |

package/kotlin/fork/compose-worker-globals.patch

@@ -105,3 +105,29 @@ index 7aa3e26..47e20a8 100644
  
  /**
   * https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API
+diff --git a/compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/SystemTheme.kt b/compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/SystemTheme.kt
+index a14f182..9c4862d 100644
+--- a/compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/SystemTheme.kt
++++ b/compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/SystemTheme.kt
+@@ -12,6 +12,11 @@
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
++ *
++ * modified for Peach: the system theme composition local is visible to a
++ * native host, which provides the device's night mode to the scenes it owns,
++ * as later upstream releases expose it. see the fork record for the patch and
++ * upstream revision.
+  */
+ 
+ package androidx.compose.ui
+@@ -27,7 +32,8 @@ enum class SystemTheme {
+     Dark, Light, Unknown
+ }
+ 
+-internal val LocalSystemTheme = staticCompositionLocalOf { currentSystemTheme }
++@InternalComposeUiApi
++val LocalSystemTheme = staticCompositionLocalOf { currentSystemTheme }
+ 
+ @InternalComposeUiApi
+ @Composable

package/kotlin/fork/fork.json

@@ -18,7 +18,7 @@
       "tag": "v1.13.0-alpha01",
       "commit": "a9e47e8aa04c95cfe572ab4297c770f3cbfb234e",
       "patch": "compose-worker-globals.patch",
-      "patchSha256": "51fa45bda1e0aae7db2eab1b056def406352958257e1d3b899c5c3d8aa5edddb"
+      "patchSha256": "5c45b67b3028637e6eafa351db004f23ad50c6f00ac2b5e7738fd026ac93cef0"
     },
     {
       "name": "skiko",