peachsim 0.1.940 → 0.1.1399

package/kotlin/ComposeSources/PeachComposeHost.kt

@@ -1,4 +1,4 @@
-@file:OptIn(androidx.compose.ui.ExperimentalComposeUiApi::class, androidx.compose.ui.InternalComposeUiApi::class, androidx.compose.ui.text.ExperimentalTextApi::class, kotlin.js.ExperimentalJsExport::class, kotlin.js.ExperimentalWasmJsInterop::class)
+@file:OptIn(androidx.compose.ui.ExperimentalComposeUiApi::class, androidx.compose.ui.InternalComposeUiApi::class, androidx.compose.ui.text.ExperimentalTextApi::class, kotlin.js.ExperimentalJsExport::class, kotlin.js.ExperimentalWasmJsInterop::class, org.jetbrains.skiko.InternalSkikoApi::class)
 
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
@@ -18,9 +18,11 @@ import androidx.compose.ui.input.key.KeyEvent
 import androidx.compose.ui.input.key.KeyEventType
 import androidx.compose.ui.input.pointer.PointerEventType
 import androidx.compose.ui.input.pointer.PointerType
+import androidx.compose.ui.layout.Layout
 import androidx.compose.ui.platform.FrameRecomposer
 import androidx.compose.ui.platform.LocalFontFamilyResolver
 import androidx.compose.ui.platform.PlatformArchitectureComponentsOwner
+import androidx.compose.ui.platform.PlatformInsets
 import androidx.compose.ui.platform.PlatformWindowInsets
 import androidx.compose.ui.platform.PlatformContext
 import androidx.compose.ui.platform.PlatformTextInputMethodRequest
@@ -33,6 +35,7 @@ import androidx.compose.ui.semantics.SemanticsOwner
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.text.font.FontSynthesis
+import androidx.compose.ui.text.font.FontVariation
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.font.PlatformTypefacesLoader
 import androidx.compose.ui.text.font.createPlatformFontFamilyResolver
@@ -58,6 +61,12 @@ import androidx.compose.ui.unit.Density
 import androidx.compose.ui.unit.DpSize
 import androidx.compose.ui.unit.IntSize
 import androidx.compose.ui.unit.LayoutDirection
+import androidx.compose.ui.unit.constrainHeight
+import androidx.compose.ui.unit.constrainWidth
+import androidx.navigationevent.NavigationEventDispatcher
+import androidx.navigationevent.NavigationEventInput
+import androidx.navigationevent.NavigationEventDispatcherOwner
+import androidx.navigationevent.compose.LocalNavigationEventDispatcherOwner
 import dev.onejs.one.OneNativeSourceViewDispatch
 import kotlin.io.encoding.Base64
 import kotlinx.coroutines.Dispatchers
@@ -66,26 +75,45 @@ import kotlinx.coroutines.awaitCancellation
 import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.job
 import org.jetbrains.skiko.SystemTheme
-import org.jetbrains.skia.BackendRenderTarget
-import org.jetbrains.skia.Bitmap
 import org.jetbrains.skia.Color
-import org.jetbrains.skia.ColorAlphaType
-import org.jetbrains.skia.ColorSpace
-import org.jetbrains.skia.ColorType
-import org.jetbrains.skia.DirectContext
-import org.jetbrains.skia.ImageInfo
-import org.jetbrains.skia.Surface
-import org.jetbrains.skia.SurfaceColorFormat
-import org.jetbrains.skia.SurfaceOrigin
-import org.jetbrains.skia.SurfaceProps
+import org.jetbrains.skia.Picture
+import org.jetbrains.skia.PictureRecorder
+import org.jetbrains.skia.Rect as SkRect
+import org.jetbrains.skia.impl.getPtr
 import org.jetbrains.skiko.OS
 import org.jetbrains.skiko.setHostOsProvider
 import org.json.JSONArray
 import org.json.JSONObject
 
-// 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 fun readPeachWindowInsets(insets: String) = insets.split(',').map { it.toInt() }.also {
+    require(it.size == 24 && it.all { pixel -> pixel >= 0 })
+}
+
+// the window delivers inset types to its compose views; a fitting decor consumes them.
+internal class PeachWindowInsets(
+    private val pixels: () -> List<Int>,
+    imeBottom: () -> Int,
+    private val consumesInsets: () -> Boolean,
+) : PlatformWindowInsets {
+    private fun type(index: Int): PlatformInsets {
+        fun side(offset: Int) = { if (consumesInsets()) 0 else pixels()[index * 4 + offset] }
+        return PlatformInsets(side(0), side(1), side(2), side(3))
+    }
+    override val statusBars = type(0)
+    override val navigationBars = type(1)
+    override val displayCutout = type(2)
+    override val systemGestures = type(3)
+    override val mandatorySystemGestures = type(4)
+    override val tappableElement = type(5)
+    override val ime = PlatformInsets({ 0 }, { 0 }, { 0 }, { if (consumesInsets()) 0 else imeBottom() })
+    override val systemBars = PlatformInsets(
+        { maxOf(statusBars.left, navigationBars.left) },
+        { maxOf(statusBars.top, navigationBars.top) },
+        { maxOf(statusBars.right, navigationBars.right) },
+        { maxOf(statusBars.bottom, navigationBars.bottom) },
+    )
+}
+
 // the values android.view.ViewConfiguration gives a window: config.xml's dp
 // dimensions resolved as getDimensionPixelSize does, rounding half up
 internal class AndroidViewConfiguration(private val density: Float) : ViewConfiguration {
@@ -141,6 +169,23 @@ internal class PeachComposePlatform(
     private var session: PeachInputSession? = null
     val input get() = session?.takeIf { it.job.isActive }
     var onInputChange: () -> Unit = {}
+    var onDialogChange: () -> Unit = {}
+    private val dialogs = mutableListOf<PeachDialogWindow>()
+    private var nextDialog = 0
+
+    override fun attachDialogWindow(dispatcher: NavigationEventDispatcher): AutoCloseable {
+        val window = PeachDialogWindow(++nextDialog, dispatcher, onDialogChange)
+        dialogs.add(window)
+        onDialogChange()
+        return AutoCloseable { dialogs.remove(window); onDialogChange() }
+    }
+
+    fun dialogState(): JSONArray = JSONArray().also { state -> dialogs.forEach { state.put(it.describe()) } }
+    fun dialogBack(): Boolean {
+        val window = dialogs.lastOrNull() ?: return false
+        window.back()
+        return true
+    }
     private var nextInput = 1
 
     override suspend fun startInputMethod(request: PlatformTextInputMethodRequest): Nothing {
@@ -168,6 +213,43 @@ internal class PeachComposePlatform(
     }
 }
 
+// each dialog has its own window dispatch. scoped AndroidX inputs observe
+// default and overlay handlers; registration ids change only on re-registration.
+private class PeachDialogWindow(
+    private val id: Int,
+    dispatcher: NavigationEventDispatcher,
+    private val changed: () -> Unit,
+) {
+    private var nextRegistration = 0
+    private inner class BackInput(private val priority: Int) : NavigationEventInput() {
+        var registration = 0
+            private set
+        override fun onHasEnabledHandlersChanged(hasEnabledHandlers: Boolean) {
+            registration = if (hasEnabledHandlers) ++nextRegistration else 0
+            changed()
+        }
+        override fun onRemoved() { registration = 0; changed() }
+        fun back() = dispatchOnBackCompleted()
+        fun describe(): JSONObject = JSONObject().put("priority", priority).put("registration", registration)
+    }
+    private val default = BackInput(0)
+    private val overlay = BackInput(1000000)
+    init {
+        dispatcher.addInput(default, NavigationEventDispatcher.PRIORITY_DEFAULT)
+        dispatcher.addInput(overlay, NavigationEventDispatcher.PRIORITY_OVERLAY)
+    }
+    fun back(): Boolean {
+        if (overlay.registration != 0) overlay.back()
+        else if (default.registration != 0) default.back()
+        else return false
+        return true
+    }
+    fun describe(): JSONObject = JSONObject().put("id", id).put("callbacks", JSONArray().also { callbacks ->
+        listOf(default, overlay).filter { it.registration != 0 }.sortedBy { it.registration }
+            .forEach { callbacks.put(it.describe()) }
+    })
+}
+
 internal class PeachInputSession(val token: Int, val request: PlatformTextInputMethodRequest, val job: Job) {
     var keyboard = true
         private set
@@ -284,8 +366,6 @@ internal class PeachComposeMount(
     density: Float,
     fontScale: Float,
     locale: String,
-    private val gpu: Boolean,
-    private val stencilBits: Int,
     private val fonts: FontFamily,
     val invalidate: (Boolean) -> Unit,
     night: Boolean,
@@ -305,29 +385,62 @@ internal class PeachComposeMount(
     // 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 var importedInsets by mutableStateOf(List(24) { 0 })
+    private var importedIme by mutableStateOf(0)
+    private val platform = PeachComposePlatform(Density(density, fontScale), LocaleList(locale), IntSize.Zero, owners,
+        insets ?: PeachWindowInsets({ importedInsets }, { importedIme }, { false }))
+    // imported views own a dispatcher instead of sharing the empty platform owner's.
+    private val importedNavigation = if (owners == null) object : NavigationEventDispatcherOwner {
+        override val navigationEventDispatcher = NavigationEventDispatcher()
+    } else null
+    private val importedBack = importedNavigation?.let {
+        PeachDialogWindow(0, it.navigationEventDispatcher) {}
+    }
     private val recomposer = FrameRecomposer(Dispatchers.Main) { invalidate(false) }
     private var needsMeasure = true
     private var measuredSize = IntSize.Zero
+    private var rootSize = IntSize.Zero
     private val scene = CanvasLayersComposeScene(
         recomposer, platform.density, LayoutDirection.Ltr, null, platform,
         invalidateLayout = { needsMeasure = true; invalidate(true) }, invalidateDraw = { invalidate(false) },
     )
     // the session's state as last reported; a change reports it again
     private var reportedInput: String? = null
-    private var surface: Surface? = null
-    private var context: DirectContext? = null
-    private var target: BackendRenderTarget? = null
-    private var pixels: Bitmap? = null
-    private var size = IntSize.Zero
+    private var picture: Picture? = null
+
+    init {
+        platform.onInputChange = { invalidate(false) }
+        platform.onDialogChange = { emitAtFrame("dialogs") { platform.dialogState().toString() } }
+    }
 
-    init { platform.onInputChange = { invalidate(false) } }
+    fun dialogState(): JSONArray = platform.dialogState()
+    fun dialogBack(): Boolean = platform.dialogBack()
+    fun back(): Boolean {
+        // app activities dispatch their own back; imported views have no activity owner.
+        val receivingWindow = importedBack ?: return false
+        return platform.dialogBack() || receivingWindow.back()
+    }
 
     fun setContent(content: @Composable () -> Unit) {
         try {
             scene.setContent {
-                CompositionLocalProvider(LocalSystemTheme provides if (night) SystemTheme.DARK else SystemTheme.LIGHT) {
-                    PeachAndroidFonts(fonts, content)
+                // the parent measures the imported root; popup windows keep their own minimums.
+                Layout(content = {
+                    CompositionLocalProvider(
+                        LocalSystemTheme provides if (night) SystemTheme.DARK else SystemTheme.LIGHT,
+                        LocalNavigationEventDispatcherOwner provides
+                            checkNotNull(importedNavigation ?: LocalNavigationEventDispatcherOwner.current),
+                    ) {
+                        PeachAndroidFonts(fonts, content)
+                    }
+                }) { measurables, _ ->
+                    val rootConstraints = checkNotNull(constraints)
+                    val placeables = measurables.map { it.measure(rootConstraints) }
+                    rootSize = IntSize(
+                        rootConstraints.constrainWidth(placeables.maxOfOrNull { it.width } ?: 0),
+                        rootConstraints.constrainHeight(placeables.maxOfOrNull { it.height } ?: 0),
+                    )
+                    layout(rootSize.width, rootSize.height) { placeables.forEach { it.place(0, 0) } }
                 }
             }
         } catch (failure: Throwable) {
@@ -341,13 +454,25 @@ internal class PeachComposeMount(
         invalidate(false)
     }
 
+    fun windowInsets(insets: String, imeBottom: Int) {
+        require(imeBottom >= 0)
+        val next = readPeachWindowInsets(insets)
+        if (next == importedInsets && imeBottom == importedIme) return
+        importedInsets = next
+        importedIme = imeBottom
+        needsMeasure = true
+        invalidate(true)
+    }
+
     fun emitAtFrame(name: String, args: () -> Any?) {
         frameState[name] = args
         invalidate(false)
     }
 
     fun measure(): IntSize {
-        val measured = scene.measureContent(checkNotNull(constraints))
+        // intrinsic root constraints can be unbounded; popup windows measure within the laid-out view.
+        scene.measureContent(Constraints(maxWidth = measuredSize.width, maxHeight = measuredSize.height))
+        val measured = rootSize
         scene.size = measured
         platform.size = measured
         measuredSize = measured
@@ -356,52 +481,40 @@ internal class PeachComposeMount(
     }
 
     fun frame(nanos: Long): String {
-        Snapshot.sendApplyNotifications()
-        if (clockRunning()) recomposer.performFrame(nanos)
-        val measured = if (needsMeasure && constraints != null) 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.
-        val backing = IntSize(measured.width.coerceAtLeast(1), measured.height.coerceAtLeast(1))
-        if (backing != size) {
-            releaseSurface()
-            size = backing
+        releaseFrame()
+        try {
+            Snapshot.sendApplyNotifications()
+            if (clockRunning()) recomposer.performFrame(nanos)
+            val measured = if (needsMeasure && constraints != null) measure() else measuredSize
             platform.size = measured
             scene.size = measured
-            if (gpu) {
-                context = DirectContext.makeGL()
-                target = BackendRenderTarget.makeGL(size.width, size.height, 1, stencilBits, 0, 0x8058)
-                surface = checkNotNull(Surface.makeFromBackendRenderTarget(
-                    checkNotNull(context), checkNotNull(target), SurfaceOrigin.BOTTOM_LEFT,
-                    SurfaceColorFormat.RGBA_8888, ColorSpace.sRGB, SurfaceProps(),
-                )) { "Skiko GPU surface creation failed" }
-            } else {
-                surface = Surface.makeRasterN32Premul(size.width, size.height)
-                pixels = Bitmap().also { check(it.allocPixels(ImageInfo(size.width, size.height, ColorType.RGBA_8888, ColorAlphaType.PREMUL, ColorSpace.sRGB))) }
+            scene.measureAndLayout()
+            val recorder = PictureRecorder()
+            try {
+                val canvas = recorder.beginRecording(SkRect.makeWH(
+                    measured.width.coerceAtLeast(1).toFloat(), measured.height.coerceAtLeast(1).toFloat(),
+                ))
+                canvas.clear(Color.TRANSPARENT)
+                scene.draw(canvas.asComposeCanvas())
+                picture = recorder.finishRecordingAsPicture()
+            } finally { recorder.close() }
+            val reply = JSONObject().put("width", measured.width).put("height", measured.height)
+                .put("pending", recomposer.hasPendingWork() || scene.hasInvalidations())
+            for ((name, args) in frameState) events.add(JSONObject().put("name", name).put("args", args()))
+            frameState.clear()
+            reply.put("events", JSONArray(events))
+            val input = platform.input?.state()?.toString()
+            if (input != reportedInput) {
+                reportedInput = input
+                reply.put("input", input?.let { JSONObject(it) } ?: JSONObject.NULL)
             }
+            events.clear()
+            reply.put("picture", getPtr(checkNotNull(picture)))
+            return reply.toString()
+        } catch (failure: Throwable) {
+            releaseFrame()
+            throw failure
         }
-        scene.measureAndLayout()
-        val canvas = checkNotNull(surface).canvas
-        canvas.clear(Color.TRANSPARENT)
-        scene.draw(canvas.asComposeCanvas())
-        val reply = JSONObject().put("width", measured.width).put("height", measured.height)
-            .put("pending", recomposer.hasPendingWork() || scene.hasInvalidations())
-        for ((name, args) in frameState) events.add(JSONObject().put("name", name).put("args", args()))
-        frameState.clear()
-        reply.put("events", JSONArray(events))
-        val input = platform.input?.state()?.toString()
-        if (input != reportedInput) {
-            reportedInput = input
-            reply.put("input", input?.let { JSONObject(it) } ?: JSONObject.NULL)
-        }
-        events.clear()
-        if (gpu) checkNotNull(surface).flushAndSubmit()
-        else {
-            check(checkNotNull(surface).readPixels(checkNotNull(pixels), 0, 0))
-            val map = checkNotNull(checkNotNull(pixels).peekPixels())
-            try { reply.put("pointer", map.addr).put("length", size.width * size.height * 4) }
-            finally { map.close() }
-        }
-        return reply.toString()
     }
 
     fun pointer(phase: String, x: Float, y: Float, millis: Long) {
@@ -455,18 +568,17 @@ internal class PeachComposeMount(
         return nodes.toString()
     }
 
-    private fun releaseSurface() {
-        pixels?.close(); pixels = null
-        surface?.close(); surface = null
-        target?.close(); target = null
-        context?.close(); context = null
+    fun releaseFrame() {
+        picture?.close()
+        picture = null
     }
 
     override fun close() {
         try { scene.close() }
         finally {
+            importedNavigation?.navigationEventDispatcher?.dispose()
             try { recomposer.close() }
-            finally { releaseSurface() }
+            finally { releaseFrame() }
         }
     }
 }
@@ -503,23 +615,24 @@ internal fun preparePeachDevice(locale: String) {
     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),
-)
+internal fun robotoFamily(font: String): FontFamily {
+    val data = Base64.decode(font)
+    return FontFamily(listOf(FontWeight.Normal, FontWeight.Medium, FontWeight.Bold).map { weight ->
+        Font("Roboto-${weight.weight}", getData = { data }, weight = weight,
+            variationSettings = FontVariation.Settings(weight, FontStyle.Normal))
+    })
+}
 
 @JsExport
 fun peachViewMount(source: String, view: String, hash: String, props: String,
-    density: Float, fontScale: Float, locale: String, night: Boolean, backend: String, stencilBits: Int,
-    regular: String, medium: String, bold: String, invalidate: (Boolean) -> Unit): String {
+    density: Float, fontScale: Float, locale: String, night: Boolean,
+    font: String, invalidate: (Boolean) -> Unit): String {
     try {
         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")
         preparePeachDevice(locale)
-        val mount = PeachComposeMount(density, fontScale, locale, backend == "graphite", stencilBits, robotoFamily(regular, medium, bold), invalidate, night)
+        val mount = PeachComposeMount(density, fontScale, locale, robotoFamily(font), invalidate, night)
         mount.props = props
         mount.setContent { dispatch.Content(view, mount.props, mount::emit) }
         return JSONObject().put("ok", true).put("id", addMount(mount)).toString()
@@ -532,6 +645,7 @@ fun peachViewMount(source: String, view: String, hash: String, props: String,
 // 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 peachViewInsets(id: Int, insets: String, imeBottom: Int) { checkNotNull(mounts[id]).windowInsets(insets, imeBottom) }
 @JsExport fun peachViewConstraints(id: Int, minWidth: Int, maxWidth: Int, minHeight: Int, maxHeight: Int) {
     checkNotNull(mounts[id]).also {
         it.constraints = Constraints(minWidth, maxWidth, minHeight, maxHeight)
@@ -539,6 +653,8 @@ fun peachViewMount(source: String, view: String, hash: String, props: String,
     }
 }
 @JsExport fun peachViewFrame(id: Int, millis: Double): String = checkNotNull(mounts[id]).frame((millis * 1_000_000).toLong())
+@JsExport fun peachViewReleaseFrame(id: Int) { checkNotNull(mounts[id]).releaseFrame() }
+@JsExport fun peachViewBack(id: Int): Boolean = checkNotNull(mounts[id]).back()
 @JsExport fun peachViewPointer(id: Int, phase: String, x: Float, y: Float, millis: Double) = checkNotNull(mounts[id]).pointer(phase, x, y, millis.toLong())
 @JsExport fun peachViewInputEdit(id: Int, token: Int, command: String): Boolean = checkNotNull(mounts[id]).inputEdit(token, command)
 @JsExport fun peachViewInputKey(id: Int, token: Int, key: String, ctrl: Boolean, shift: Boolean, alt: Boolean): Boolean =

package/kotlin/ExpoComposeSources/PeachAndroidView.kt

@@ -0,0 +1,87 @@
+import android.graphics.Canvas
+import android.graphics.ViewCanvas
+import android.view.View
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.ui.draw.drawWithContent
+import androidx.compose.ui.graphics.drawscope.clipRect
+import androidx.compose.ui.graphics.nativeCanvas
+import androidx.compose.ui.layout.Layout
+import androidx.compose.ui.unit.constrainWidth
+import androidx.compose.ui.unit.constrainHeight
+import org.jetbrains.skia.Paint
+import org.jetbrains.skia.Rect
+
+// the Android view tree draws into the same Skia picture as a compose view.
+// invalidation schedules drawing; requestLayout also schedules measurement.
+@Composable
+internal fun PeachAndroidView(view: View) {
+    var drawRevision by remember(view) { mutableIntStateOf(0) }
+    var layoutRevision by remember(view) { mutableIntStateOf(0) }
+    DisposableEffect(view) {
+        view.invalidateHost = { layout ->
+            drawRevision++
+            if (layout) layoutRevision++
+        }
+        view.dispatchAttachedToWindow(Any())
+        onDispose {
+            view.dispatchDetachedFromWindow()
+            view.invalidateHost = null
+        }
+    }
+    Layout(content = {}, modifier = Modifier.fillMaxSize().drawWithContent {
+        drawRevision
+        clipRect {
+            val native = drawContext.canvas.nativeCanvas
+            view.draw(Canvas(object : ViewCanvas {
+                private var offsetX = 0f
+                private var offsetY = 0f
+                private var clip = Rect.makeWH(view.width.toFloat(), view.height.toFloat())
+                private val saves = mutableMapOf<Int, Triple<Float, Float, Rect>>()
+                override fun drawColor(color: Int) {
+                    val paint = Paint()
+                    try { paint.color = color; native.drawPaint(paint) } finally { paint.close() }
+                }
+                override fun save(): Int {
+                    val count = native.save()
+                    saves[count] = Triple(offsetX, offsetY, clip)
+                    return count
+                }
+                override fun restoreToCount(count: Int) {
+                    native.restoreToCount(count)
+                    val state = checkNotNull(saves[count])
+                    offsetX = state.first; offsetY = state.second; clip = state.third
+                    saves.keys.filter { it >= count }.forEach { saves.remove(it) }
+                }
+                override fun translate(dx: Float, dy: Float) {
+                    offsetX += dx; offsetY += dy
+                    native.translate(dx, dy)
+                }
+                override fun clipRect(left: Float, top: Float, right: Float, bottom: Float): Boolean {
+                    native.clipRect(Rect.makeLTRB(left, top, right, bottom))
+                    clip = Rect.makeLTRB(maxOf(clip.left, left + offsetX), maxOf(clip.top, top + offsetY),
+                        minOf(clip.right, right + offsetX), minOf(clip.bottom, bottom + offsetY))
+                    return clip.left < clip.right && clip.top < clip.bottom
+                }
+            }))
+        }
+    }) { _, constraints ->
+        layoutRevision
+        fun spec(min: Int, max: Int, bounded: Boolean): Int = when {
+            min == max -> View.MeasureSpec.makeMeasureSpec(max, View.MeasureSpec.EXACTLY)
+            bounded -> View.MeasureSpec.makeMeasureSpec(max, View.MeasureSpec.AT_MOST)
+            else -> View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED)
+        }
+        view.measure(spec(constraints.minWidth, constraints.maxWidth, constraints.hasBoundedWidth),
+            spec(constraints.minHeight, constraints.maxHeight, constraints.hasBoundedHeight))
+        val width = constraints.constrainWidth(view.measuredWidth)
+        val height = constraints.constrainHeight(view.measuredHeight)
+        layout(width, height) { view.layout(0, 0, width, height) }
+    }
+}

package/kotlin/ExpoComposeSources/PeachExpoViewMount.kt

@@ -0,0 +1,24 @@
+@file:OptIn(kotlin.js.ExperimentalJsExport::class, androidx.compose.ui.ExperimentalComposeUiApi::class, androidx.compose.ui.InternalComposeUiApi::class)
+
+import dev.peach.expo.PeachExpoRuntime
+import expo.modules.kotlin.views.ExpoComposeView
+import org.json.JSONObject
+
+// one mounted Expo view as the native scene the tenant presents. the
+// view already exists: its first props created it
+@JsExport
+fun peachExpoViewMount(id: String, density: Float, fontScale: Float, locale: String, night: Boolean,
+    font: String, invalidate: (Boolean) -> Unit): String {
+    try {
+        val view = PeachExpoRuntime.mountedView(id)
+        if (view is ExpoComposeView<*>) view.validateHostingAncestor()
+        preparePeachDevice(locale)
+        val mount = PeachComposeMount(density, fontScale, locale, robotoFamily(font), invalidate, night)
+        mount.setContent {
+            if (view is ExpoComposeView<*>) view.HostedContent() else PeachAndroidView(view)
+        }
+        return JSONObject().put("ok", true).put("id", addMount(mount)).toString()
+    } catch (error: Throwable) {
+        return JSONObject().put("ok", false).put("code", "E_EXPO_VIEW").put("error", "Expo view $id: ${error.message}").toString()
+    }
+}

package/kotlin/ExpoComposeSources/dev/peach/expo/PeachExpoCompose.kt

@@ -0,0 +1,28 @@
+@file:Suppress("UNCHECKED_CAST")
+
+package dev.peach.expo
+
+import androidx.compose.runtime.MutableState
+import expo.modules.kotlin.exception.PropSetException
+import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.types.AnyType
+import expo.modules.kotlin.types.toAnyType
+import expo.modules.kotlin.views.AnyViewProp
+import expo.modules.kotlin.views.ExpoComposeView
+import expo.modules.kotlin.views.ExpoView
+
+// a compose view's MutableState prop: a new value replaces the state's, as
+// ComposeViewProp sets it, so the content recomposes
+class ComposeStateProp(name: String, type: AnyType, private val write: (Any, Any?) -> Unit) : AnyViewProp(name, type) {
+    override fun set(prop: Any?, onView: ExpoView) {
+        exceptionDecorator({ PropSetException(name, onView::class, it) }) {
+            val props = (onView as ExpoComposeView<*>).props ?: return
+            write(props, type.convert(prop))
+        }
+    }
+}
+
+object PeachExpoCompose {
+    inline fun <P : Any, reified T> prop(name: String, noinline state: (P) -> MutableState<T>): AnyViewProp =
+        ComposeStateProp(name, toAnyType<T>()) { props, value -> state(props as P).value = value as T }
+}

package/kotlin/ExpoComposeSources/expo/modules/kotlin/views/ExpoComposeView.kt

@@ -0,0 +1,70 @@
+package expo.modules.kotlin.views
+
+import android.content.Context
+import android.util.Log
+import androidx.compose.runtime.Composable
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.viewevent.ViewEvent
+
+// a scope passed through the compose view hierarchy
+interface ComposableScope
+
+private object EmptyComposableScope : ComposableScope
+
+fun ComposableScope(): ComposableScope = EmptyComposableScope
+
+inline fun <T : ComposableScope> T.withIf(condition: Boolean, block: T.() -> T): T =
+    if (condition) block() else this
+
+// a marker for the classes that carry a compose view's props
+interface ComposeProps
+
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.BINARY)
+annotation class OptimizedComposeProps
+
+// the name for the global event dispatcher
+internal const val GLOBAL_EVENT_NAME = "onGlobalEvent"
+
+// a compose view. one with a hosting view composes its own content in a
+// ComposeView, which Peach presents as one compose scene; one without renders
+// only inside a compose parent, which Peach has no React Native children for
+// yet, so it stays hidden and logs the missing host, as upstream does when its
+// parent is not a compose view
+abstract class ExpoComposeView<T : ComposeProps>(
+    context: Context,
+    appContext: AppContext,
+    private val withHostingView: Boolean = false,
+) : ExpoView(context, appContext) {
+    open val props: T? = null
+
+    private val globalEvent by lazy { ViewEvent<Pair<String, Map<String, Any?>>>(GLOBAL_EVENT_NAME, this, null) }
+
+    val globalEventDispatcher: (String, Map<String, Any?>) -> Unit = { name, params ->
+        globalEvent.invoke(Pair(name, params))
+    }
+
+    @Composable
+    abstract fun ComposableScope.Content()
+
+    override val shouldUseAndroidLayout = withHostingView
+
+    @Composable
+    internal fun HostedContent() {
+        if (withHostingView) with(ComposableScope()) { Content() }
+    }
+
+    internal fun validateHostingAncestor() {
+        if (withHostingView) return
+        Log.e("ExpoComposeView", "", MissingHostException(this::class.simpleName ?: "ExpoComposeView"))
+    }
+}
+
+internal class MissingHostException(componentName: String) :
+    CodedException(
+        "A Jetpack Compose view \"$componentName\" must be rendered as a direct child of a <Host> component. " +
+            "Wrap your component with `<Host>` from '@expo/ui/jetpack-compose'. " +
+            "Note that inserting another `<View>` (or any non-Compose ViewGroup) between `<Host>` and this " +
+            "component breaks the Compose composition boundary and will still trigger this error."
+    )