peachsim 0.1.649 → 0.1.650

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

@@ -0,0 +1,7 @@
+package android.app
+
+import android.content.ContextWrapper
+
+open class Application : ContextWrapper() {
+    open fun onCreate() {}
+}

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

@@ -0,0 +1,5 @@
+package android.content
+
+abstract class Context
+
+open class ContextWrapper : Context()

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

@@ -0,0 +1,16 @@
+package android.content
+
+class ComponentName(val packageName: String, val className: String) {
+    fun flattenToShortString(): String =
+        if (className.startsWith("$packageName.")) "$packageName/${className.removePrefix(packageName)}"
+        else "$packageName/$className"
+}
+
+class Intent(val action: String?, val categories: Set<String>?, val component: ComponentName?) {
+    fun hasCategory(category: String): Boolean = categories?.contains(category) == true
+
+    companion object {
+        const val ACTION_MAIN = "android.intent.action.MAIN"
+        const val CATEGORY_LAUNCHER = "android.intent.category.LAUNCHER"
+    }
+}

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

@@ -0,0 +1,5 @@
+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

package/kotlin/AppSources/android/util/SuperNotCalledException.kt

@@ -0,0 +1,3 @@
+package android.util
+
+class SuperNotCalledException(message: String) : RuntimeException(message)

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

@@ -0,0 +1,72 @@
+package android.view
+
+import android.content.Context
+
+open class View(val context: Context) {
+    var parent: ViewGroup? = null
+        internal set
+    var layoutParams: ViewGroup.LayoutParams? = null
+    internal var attachedWindow: Window? = null
+
+    val isAttachedToWindow: Boolean get() = attachedWindow != null
+
+    // ViewRootImpl dispatches attach through the tree once the window is added
+    internal open fun dispatchAttachedToWindow(window: Window) {
+        attachedWindow = window
+        onAttachedToWindow()
+    }
+
+    internal open fun dispatchDetachedFromWindow() {
+        onDetachedFromWindow()
+        attachedWindow = null
+    }
+
+    protected open fun onAttachedToWindow() {}
+    protected open fun onDetachedFromWindow() {}
+}
+
+open class ViewGroup(context: Context) : View(context) {
+    open class LayoutParams(val width: Int, val height: Int) {
+        companion object {
+            const val MATCH_PARENT = -1
+            const val WRAP_CONTENT = -2
+        }
+    }
+
+    private val children = mutableListOf<View>()
+
+    val childCount: Int get() = children.size
+    fun getChildAt(index: Int): View? = children.getOrNull(index)
+
+    fun addView(child: View, params: LayoutParams) {
+        child.layoutParams = params
+        addView(child)
+    }
+
+    open fun addView(child: View) {
+        check(child.parent == null) {
+            "The specified child already has a parent. You must call removeView() on the child's parent first."
+        }
+        children += child
+        child.parent = this
+        attachedWindow?.let { child.dispatchAttachedToWindow(it) }
+    }
+
+    fun removeAllViews() {
+        for (child in children) {
+            if (child.isAttachedToWindow) child.dispatchDetachedFromWindow()
+            child.parent = null
+        }
+        children.clear()
+    }
+
+    override fun dispatchAttachedToWindow(window: Window) {
+        super.dispatchAttachedToWindow(window)
+        for (child in children.toList()) child.dispatchAttachedToWindow(window)
+    }
+
+    override fun dispatchDetachedFromWindow() {
+        for (child in children.toList()) child.dispatchDetachedFromWindow()
+        super.dispatchDetachedFromWindow()
+    }
+}

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

@@ -0,0 +1,44 @@
+package android.view
+
+import android.content.Context
+import android.widget.FrameLayout
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import dev.peach.app.PeachWindowHost
+
+// 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,
+    internal val host: PeachWindowHost,
+) {
+    internal val contentParent = FrameLayout(context)
+    val decorView: View get() = contentParent
+
+    // 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
+
+    fun setDecorFitsSystemWindows(decorFitsSystemWindows: Boolean) {
+        val before = fitsSystemWindows
+        this.decorFitsSystemWindows = decorFitsSystemWindows
+        if (fitsSystemWindows != before) host.windowChanged()
+    }
+
+    // Activity.setContentView(View) fills the content parent
+    internal fun setContentView(view: View, params: ViewGroup.LayoutParams) {
+        contentParent.removeAllViews()
+        contentParent.addView(view, params)
+    }
+
+    internal fun addToWindowManager() {
+        contentParent.dispatchAttachedToWindow(this)
+    }
+
+    internal fun removeFromWindowManager() {
+        if (contentParent.isAttachedToWindow) contentParent.dispatchDetachedFromWindow()
+    }
+}

package/kotlin/AppSources/android/widget/FrameLayout.kt

@@ -0,0 +1,6 @@
+package android.widget
+
+import android.content.Context
+import android.view.ViewGroup
+
+open class FrameLayout(context: Context) : ViewGroup(context)

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

@@ -0,0 +1,57 @@
+package androidx.activity
+
+import android.app.Activity
+import android.os.Bundle
+import androidx.lifecycle.HasDefaultViewModelProviderFactory
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.LifecycleRegistry
+import androidx.lifecycle.SAVED_STATE_REGISTRY_OWNER_KEY
+import androidx.lifecycle.SavedStateViewModelFactory
+import androidx.lifecycle.VIEW_MODEL_STORE_OWNER_KEY
+import androidx.lifecycle.ViewModelStore
+import androidx.lifecycle.ViewModelStoreOwner
+import androidx.lifecycle.enableSavedStateHandles
+import androidx.lifecycle.viewmodel.CreationExtras
+import androidx.lifecycle.viewmodel.MutableCreationExtras
+import androidx.savedstate.SavedStateRegistry
+import androidx.savedstate.SavedStateRegistryController
+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.
+open class ComponentActivity : Activity(), LifecycleOwner, ViewModelStoreOwner,
+    HasDefaultViewModelProviderFactory, SavedStateRegistryOwner {
+    private val lifecycleRegistry = LifecycleRegistry(this)
+    private val savedStateRegistryController = SavedStateRegistryController.create(this)
+
+    override val lifecycle: Lifecycle get() = lifecycleRegistry
+    override val viewModelStore: ViewModelStore = ViewModelStore()
+    override val savedStateRegistry: SavedStateRegistry get() = savedStateRegistryController.savedStateRegistry
+    override val defaultViewModelProviderFactory = SavedStateViewModelFactory()
+    override val defaultViewModelCreationExtras: CreationExtras
+        get() = MutableCreationExtras().also {
+            it[SAVED_STATE_REGISTRY_OWNER_KEY] = this
+            it[VIEW_MODEL_STORE_OWNER_KEY] = this
+        }
+
+    init {
+        lifecycleRegistry.addObserver(LifecycleEventObserver { _, event ->
+            if (event == Lifecycle.Event.ON_DESTROY) viewModelStore.clear()
+        })
+        savedStateRegistryController.performAttach()
+        enableSavedStateHandles()
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        savedStateRegistryController.performRestore(null)
+        super.onCreate(savedInstanceState)
+    }
+
+    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/compose/ComponentActivity.kt

@@ -0,0 +1,29 @@
+package androidx.activity.compose
+
+import android.view.ViewGroup
+import androidx.activity.ComponentActivity
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionContext
+import androidx.compose.ui.platform.ComposeView
+
+private val DefaultActivityContentLayoutParams =
+    ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+
+// activity-compose's setContent: reuse the ComposeView already in the content
+// parent, otherwise create one and set it as the content view. the activity
+// itself supplies the view tree owners.
+fun ComponentActivity.setContent(
+    parent: CompositionContext? = null,
+    content: @Composable () -> Unit,
+) {
+    val existingComposeView =
+        (window.decorView as ViewGroup).getChildAt(0) as? ComposeView
+    if (existingComposeView != null) with(existingComposeView) {
+        setParentCompositionContext(parent)
+        setContent(content)
+    } else ComposeView(this).apply {
+        setParentCompositionContext(parent)
+        setContent(content)
+        setContentView(this, DefaultActivityContentLayoutParams)
+    }
+}

package/kotlin/AppSources/androidx/compose/ui/platform/ComposeView.kt

@@ -0,0 +1,67 @@
+package androidx.compose.ui.platform
+
+import android.content.Context
+import android.view.ViewGroup
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionContext
+import androidx.compose.runtime.mutableStateOf
+
+// AbstractComposeView and ComposeView as compose-ui's Android source has them:
+// setContent stores a state-backed lambda, composition starts when the view
+// attaches to a window, a later setContent replaces the lambda inside the same
+// composition, and detaching disposes it (the default view composition
+// strategy).
+class ComposeView(context: Context) : ViewGroup(context) {
+    private val content = mutableStateOf<(@Composable () -> Unit)?>(null)
+    private var shouldCreateCompositionOnAttachedToWindow = false
+    private var parentContext: CompositionContext? = null
+    private var composition: AutoCloseable? = null
+
+    val hasComposition: Boolean get() = composition != null
+
+    @Composable
+    internal fun Content() {
+        content.value?.invoke()
+    }
+
+    fun setParentCompositionContext(parent: CompositionContext?) {
+        parentContext = parent
+    }
+
+    fun setContent(content: @Composable () -> Unit) {
+        shouldCreateCompositionOnAttachedToWindow = true
+        this.content.value = content
+        if (isAttachedToWindow) createComposition()
+    }
+
+    fun createComposition() {
+        check(parentContext != null || isAttachedToWindow) {
+            "createComposition requires a previous call to createComposition(ComposeViewContext)," +
+                " a parent reference, or the View to be attached to a window. Attach the View or " +
+                "call setParentCompositionReference."
+        }
+        ensureCompositionCreated()
+    }
+
+    fun disposeComposition() {
+        composition?.close()
+        composition = null
+    }
+
+    private fun ensureCompositionCreated() {
+        if (composition != null) return
+        check(parentContext == null) { "a ComposeView composing into a parent composition is not supported in Peach yet" }
+        val window = checkNotNull(attachedWindow) { "ComposeView is not attached to a window" }
+        composition = window.host.compose(this)
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        if (shouldCreateCompositionOnAttachedToWindow) ensureCompositionCreated()
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        disposeComposition()
+    }
+}

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

@@ -0,0 +1,136 @@
+@file:OptIn(androidx.compose.ui.InternalComposeUiApi::class)
+
+package dev.peach.app
+
+import android.app.Activity
+import android.app.Application
+import android.content.ComponentName
+import android.content.Intent
+import android.view.ViewGroup
+import android.view.Window
+import androidx.activity.ComponentActivity
+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.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.lifecycle.Lifecycle
+import androidx.navigationevent.NavigationEventDispatcher
+import androidx.navigationevent.NavigationEventDispatcherOwner
+import PeachComposeMount
+import addMount
+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
+// Application and that class (wasm has no reflection).
+internal class PeachAppSpec(
+    val launcher: ComponentName,
+    val component: ComponentName,
+    val targetSdk: Int,
+    val optOutEdgeToEdge: Boolean,
+    val createApplication: () -> Application,
+    val createActivity: () -> Activity,
+)
+
+// the system bars the device delivers to the window's content, in pixels: all
+// of them on an edge-to-edge window, none once the decor fits system windows.
+private class SystemBarInsets(
+    private val window: Window,
+    private val status: Int,
+    private val navigation: Int,
+) : PlatformWindowInsets {
+    // read when compose lays out, so a later change to the window applies
+    private fun delivered(pixels: Int) = if (window.fitsSystemWindows) 0 else pixels
+    override val statusBars = PlatformInsets(getTop = { delivered(status) })
+    override val navigationBars = PlatformInsets(getBottom = { delivered(navigation) })
+    override val systemBars =
+        PlatformInsets(getTop = { delivered(status) }, getBottom = { delivered(navigation) })
+}
+
+private class ActivityOwners(activity: ComponentActivity) : PlatformArchitectureComponentsOwner {
+    override val lifecycleOwner = activity
+    override val viewModelStoreOwner = activity
+    override val savedStateRegistryOwner = activity
+    override val navigationEventDispatcherOwner = object : NavigationEventDispatcherOwner {
+        override val navigationEventDispatcher = NavigationEventDispatcher()
+    }
+}
+
+// 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
+// window added, which attaches the content view and composes it.
+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,
+    invalidate: (Boolean) -> Unit,
+): String {
+    try {
+        require(backend == "graphite" || backend == "raster")
+        preparePeachDevice(locale)
+        val fonts = robotoFamily(regular, medium, bold)
+        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.emit("window", JSONObject().put("decorFitsSystemWindows", window.fitsSystemWindows).toString())
+            }
+        }
+        val enforced = spec.targetSdk > 35 || (spec.targetSdk == 35 && !spec.optOutEdgeToEdge)
+        window = Window(activity, enforced, 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) },
+        )
+        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"
+        }
+        val params = view.layoutParams
+        return JSONObject().put("ok", true).put("id", mountId)
+            .put("decorFitsSystemWindows", window.fitsSystemWindows)
+            .put("wrapWidth", params?.width == ViewGroup.LayoutParams.WRAP_CONTENT)
+            .put("wrapHeight", params?.height == ViewGroup.LayoutParams.WRAP_CONTENT)
+            .toString()
+    } catch (error: Throwable) {
+        return JSONObject().put("ok", false).put("code", "E_KOTLIN_APP")
+            .put("error", "${error::class.simpleName}: ${error.message}").toString()
+    }
+}

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

@@ -0,0 +1,13 @@
+package dev.peach.app
+
+import androidx.compose.ui.platform.ComposeView
+
+// the device side of a window: one Peach scene for the window's life, which
+// composes whichever ComposeView the window holds once that view attaches.
+// the composition ends when the view disposes it.
+internal interface PeachWindowHost {
+    fun compose(view: ComposeView): AutoCloseable
+
+    // the window's inset policy changed after it was added
+    fun windowChanged()
+}

package/kotlin/ComposeSources/PeachComposeHost.kt

@@ -15,6 +15,8 @@ import androidx.compose.ui.input.pointer.PointerEventType
 import androidx.compose.ui.input.pointer.PointerType
 import androidx.compose.ui.platform.FrameRecomposer
 import androidx.compose.ui.platform.LocalFontFamilyResolver
+import androidx.compose.ui.platform.PlatformArchitectureComponentsOwner
+import androidx.compose.ui.platform.PlatformWindowInsets
 import androidx.compose.ui.platform.PlatformContext
 import androidx.compose.ui.platform.WindowInfo
 import androidx.compose.ui.platform.registerSkikoComposeImplementation
@@ -59,11 +61,19 @@ import org.jetbrains.skiko.setHostOsProvider
 import org.json.JSONArray
 import org.json.JSONObject
 
-private class PeachComposePlatform(
+// owners and window insets come from the hosting window: an activity's
+// ComposeView passes the activity and the insets its window delivers; an
+// imported composable keeps the empty defaults.
+internal class PeachComposePlatform(
     val density: Density,
     override val localeList: LocaleList,
     var size: IntSize,
-) : PlatformContext by PlatformContext.Empty(), PlatformContext.SemanticsOwnerListener {
+    owners: PlatformArchitectureComponentsOwner?,
+    insets: PlatformWindowInsets?,
+    base: PlatformContext = PlatformContext.Empty(),
+) : PlatformContext by base, PlatformContext.SemanticsOwnerListener {
+    override val architectureComponentsOwner: PlatformArchitectureComponentsOwner = owners ?: base.architectureComponentsOwner
+    override val windowInsets: PlatformWindowInsets = insets ?: base.windowInsets
     val owners = mutableSetOf<SemanticsOwner>()
     override val windowInfo: WindowInfo = object : WindowInfo {
         override val isWindowFocused: Boolean get() = true
@@ -87,7 +97,7 @@ private class PeachComposePlatform(
 // android's default and sans-serif families use the same device font bytes as
 // peach's react native renderer. compose owns shaping and all other families.
 @Composable
-private fun PeachAndroidFonts(roboto: FontFamily, content: @Composable () -> Unit) {
+internal fun PeachAndroidFonts(roboto: FontFamily, content: @Composable () -> Unit) {
     val parent = LocalFontFamilyResolver.current
     val resolver = remember(parent, roboto) {
         val backend = checkNotNull(parent.platformTypefacesLoader())
@@ -102,23 +112,26 @@ private fun PeachAndroidFonts(roboto: FontFamily, content: @Composable () -> Uni
     CompositionLocalProvider(LocalFontFamilyResolver provides resolver, content = content)
 }
 
-private class PeachComposeMount(
-    dispatch: OneNativeSourceViewDispatch,
-    view: String,
-    propsJson: String,
+// one compose scene presented by the tenant canvas. the frame clock runs only
+// while clockRunning answers true, as Android's window recomposer pauses its
+// clock below STARTED.
+internal class PeachComposeMount(
     density: Float,
     fontScale: Float,
     locale: String,
     private val gpu: Boolean,
     private val stencilBits: Int,
-    fonts: FontFamily,
+    private val fonts: FontFamily,
     val invalidate: (Boolean) -> Unit,
+    owners: PlatformArchitectureComponentsOwner? = null,
+    insets: PlatformWindowInsets? = null,
+    private val clockRunning: () -> Boolean = { true },
 ) : AutoCloseable {
-    var props by mutableStateOf(propsJson)
+    var props by mutableStateOf("")
     var constraints = Constraints()
         set(value) { if (field != value) { field = value; needsMeasure = true } }
     private val events = mutableListOf<JSONObject>()
-    private val platform = PeachComposePlatform(Density(density, fontScale), LocaleList(locale), IntSize.Zero)
+    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
     private var measuredSize = IntSize.Zero
@@ -132,22 +145,20 @@ private class PeachComposeMount(
     private var pixels: Bitmap? = null
     private var size = IntSize.Zero
 
-    init {
+    fun setContent(content: @Composable () -> Unit) {
         try {
-            scene.setContent {
-                PeachAndroidFonts(fonts) {
-                    dispatch.Content(view, props) { name, args ->
-                        events.add(JSONObject().put("name", name).put("args", args))
-                        invalidate(false)
-                    }
-                }
-            }
+            scene.setContent { PeachAndroidFonts(fonts, content) }
         } catch (failure: Throwable) {
             close()
             throw failure
         }
     }
 
+    fun emit(name: String, args: Any?) {
+        events.add(JSONObject().put("name", name).put("args", args))
+        invalidate(false)
+    }
+
     fun measure(): IntSize {
         val measured = scene.measureContent(constraints)
         scene.size = measured
@@ -159,7 +170,7 @@ private class PeachComposeMount(
 
     fun frame(nanos: Long): String {
         Snapshot.sendApplyNotifications()
-        recomposer.performFrame(nanos)
+        if (clockRunning()) recomposer.performFrame(nanos)
         val measured = if (needsMeasure) measure() else measuredSize
         // a zero-size composition still runs its effects and reports its size;
         // its backing surface uses one pixel until layout gives it real bounds.
@@ -241,35 +252,45 @@ private class PeachComposeMount(
     }
 }
 
-private val mounts = mutableMapOf<Int, PeachComposeMount>()
+internal val mounts = mutableMapOf<Int, PeachComposeMount>()
 private var nextMount = 1
 private var deviceLocale: String? = null
 
+internal fun addMount(mount: PeachComposeMount): Int = nextMount++.also { mounts[it] = mount }
+
+// the process-wide device setup every scene shares: skiko's platform, the
+// host OS and the device locale, fixed for the life of the process.
+internal fun preparePeachDevice(locale: String) {
+    registerSkikoComposeImplementation()
+    if (deviceLocale == null) {
+        setHostOsProvider { OS.Android }
+        val locales = LocaleList(locale)
+        setPlatformLocaleProvider { locales }
+        deviceLocale = locale
+    }
+    require(deviceLocale == locale) { "device locale changes require a new Kotlin process" }
+}
+
+internal fun robotoFamily(regular: String, medium: String, bold: String) = FontFamily(
+    Font("Roboto-400", Base64.decode(regular), FontWeight.Normal),
+    Font("Roboto-500", Base64.decode(medium), FontWeight.Medium),
+    Font("Roboto-700", Base64.decode(bold), FontWeight.Bold),
+)
+
 @JsExport
 fun peachViewMount(source: String, view: String, hash: String, props: String,
     density: Float, fontScale: Float, locale: String, backend: String, stencilBits: Int,
     regular: String, medium: String, bold: String, invalidate: (Boolean) -> Unit): String {
     try {
-        registerSkikoComposeImplementation()
         val dispatch = peachViewDispatcher(source)
         if (dispatch.contractHash != hash) return JSONObject().put("ok", false).put("code", "E_NATIVE_SOURCE_REBUILD")
             .put("error", "composable source $source changed; rebuild the app").toString()
         require(backend == "graphite" || backend == "raster")
-        if (deviceLocale == null) {
-            setHostOsProvider { OS.Android }
-            val locales = LocaleList(locale)
-            setPlatformLocaleProvider { locales }
-            deviceLocale = locale
-        }
-        require(deviceLocale == locale) { "device locale changes require a new Kotlin process" }
-        val fonts = FontFamily(
-            Font("Roboto-400", Base64.decode(regular), FontWeight.Normal),
-            Font("Roboto-500", Base64.decode(medium), FontWeight.Medium),
-            Font("Roboto-700", Base64.decode(bold), FontWeight.Bold),
-        )
-        val id = nextMount++
-        mounts[id] = PeachComposeMount(dispatch, view, props, density, fontScale, locale, backend == "graphite", stencilBits, fonts, invalidate)
-        return JSONObject().put("ok", true).put("id", id).toString()
+        preparePeachDevice(locale)
+        val mount = PeachComposeMount(density, fontScale, locale, backend == "graphite", stencilBits, robotoFamily(regular, medium, bold), invalidate)
+        mount.props = props
+        mount.setContent { dispatch.Content(view, mount.props, mount::emit) }
+        return JSONObject().put("ok", true).put("id", addMount(mount)).toString()
     } catch (error: Throwable) {
         return JSONObject().put("ok", false).put("code", "E_NATIVE_SOURCE").put("error", "$source.$view: ${error.message}").toString()
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peachsim",
-  "version": "0.1.649",
+  "version": "0.1.650",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for peach.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",