peachsim 0.1.628 → 0.1.630

package/dist-lib/vite-swift.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.628 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.630 | (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.628 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.630 | (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;
@@ -808,7 +808,7 @@ var swiftHost;
 var loadSwiftHost = () => swiftHost ??= import("peachsim/vite-swift");
 var KOTLIN_ROUTE_PREFIX = "/__peach/kotlin";
 var kotlinHost;
-var loadKotlinHost = () => kotlinHost ??= import("peachsim/vite-kotlin");
+var loadKotlinHost = () => kotlinHost ??= import("peachsim/kotlin-host");
 function rnxPlugin(options = {}) {
   const prefix = options.prefix || "/__soot";
   return {
@@ -891,34 +891,17 @@ function rnxPlugin(options = {}) {
         const pathname = (req.url ?? "").split("?")[0];
         if (!pathname.startsWith(KOTLIN_ROUTE_PREFIX)) return next();
         loadKotlinHost().then(async (host) => {
-          if (host.serveKotlinArtifact(pathname, res)) return;
-          if (pathname !== "/__peach/kotlin-package") return next();
           if (!kotlinModuleRoot) {
-            const moduleRoot = import_path2.default.join(
-              import_path2.default.dirname(
-                (0, import_node_module.createRequire)(import_path2.default.join(server.config.root, "package.json")).resolve(
-                  "peachsim/package.json"
-                )
-              ),
-              "kotlin"
-            );
-            kotlinModuleRoot = moduleRoot;
-            server.watcher.add(import_path2.default.join(moduleRoot, "Sources"));
-          }
-          try {
-            const artifact = await host.kotlinArtifact(
-              server.config.root,
-              kotlinModuleRoot,
-              devOrigin()
-            );
-            res.setHeader("access-control-allow-origin", "*");
-            res.setHeader("content-type", "application/json");
-            res.end(JSON.stringify({ ...artifact, hmrPath }));
-          } catch (error) {
-            res.statusCode = 500;
-            res.setHeader("access-control-allow-origin", "*");
-            res.end(error instanceof Error ? error.message : String(error));
+            kotlinModuleRoot = host.peachKotlinModuleRoot(server.config.root);
+            server.watcher.add(import_path2.default.join(kotlinModuleRoot, "Sources"));
           }
+          const served = await host.serveKotlinRequest(pathname, res, {
+            root: server.config.root,
+            moduleRoot: kotlinModuleRoot,
+            origin: devOrigin(),
+            hmrPath
+          });
+          if (!served) next();
         }).catch(next);
       });
       server.watcher.on("change", (file) => {

package/kotlin/README.md

@@ -1,12 +1,22 @@
 # peachsim kotlin
 
 The Android side of a One app's directly imported Kotlin in Peach. Owner spec:
-[`specs/rnx-swift.md`](../../../specs/rnx-swift.md) (direct native source imports).
+[`specs/peach-kotlin.md`](../../../specs/peach-kotlin.md).
 
-- `toolchain.json`: the pinned Kotlin compiler and the kotlinx-coroutines
-  Kotlin/Wasm klibs, with their sha256. `peachsim/vite-kotlin` fetches them once
+Kotlin and Compose must add zero bytes to a native-free baseline bundle. Compiler
+hosts and plugins, runtime, libraries and mounts stay behind lazy entry points.
+Verify emitted chunks and static imports, plus the native-free twin's network
+traffic in `scripts/debug/peach-swift-lazy-network.sh`.
+
+- `toolchain.json`: the pinned Kotlin compiler, kotlinx-coroutines and official
+  AndroidX runtime and Compose Multiplatform UI Kotlin/Wasm klibs, with their
+  sha256 and explicit matching Android pins. Skiko's browser resources and
+  kotlinx-datetime's declared JS module are verified and served beside the wasm.
+  Compose libraries and the compiler's bundled Compose plugin are selected only
+  for sources referencing `androidx.compose`. `peachsim/kotlin-host` fetches libraries once
   into `~/.peach/kotlin/<version>`. kotlinc needs a Java runtime (17 or newer)
-  from `JAVA_HOME` or `PATH`, the one an Android build uses.
+  from `JAVA_HOME` or `PATH`, the one an Android build uses. Its heap is capped
+  at 2 GiB for the complete Compose closure.
 - `Sources/`: the Android and One declarations app Kotlin and One's generated
   glue compile against: `org.json` with Android's parse and print rules,
   `androidx.annotation.Keep`, `dev.onejs.one.OneNativeSourceDispatch` and
@@ -16,3 +26,21 @@ The dev server compiles every `.kt` source of the app, One's glue for each and
 a generated entry into one Kotlin/Wasm module, held to the Kotlin language
 version React Native's Android build pins. Replay:
 `scripts/debug/peach-one-native-source-guest.sh`.
+
+`fixtures/runtime-state/RuntimeState.kt` runs the actual Compose recomposer with
+two roots and shared state through generated One module dispatch. It checks
+props retain remembered state and node/effect identity, shared frame timestamps,
+and disposal cancels only the removed root's LaunchedEffect, DisposableEffect
+and remembered coroutine scope. The surviving root must still recompose.
+
+Compile on Linux with
+`bun remote bun scripts/debug/peach-compose-runtime.ts compile`, then run the
+delivered archive on a Mac GPU with
+`bun heavy --priority -10 --cores 2 --admission-timeout-seconds 120 -- bun scripts/debug/peach-compose-runtime.ts run .remote-out/compose-runtime-host`.
+The source and archive hashes must match; the browser leg uses an isolated home
+and never compiles. Negative controls disable scheduling, recreate a root on
+props changes and skip disposal. A Kotlin Error must retain its dispatch envelope.
+The eager Vite entry must remain byte-identical. Compose dispatch runs in a
+browser worker with no document, after official Skiko initializes. This proves
+runtime behavior, with no Compose UI or Android pixel grade. UI fixtures still
+use the paired Compose oracle.

package/kotlin/fixtures/counter/Counter.kt

@@ -0,0 +1,26 @@
+package dev.contrast.composefixtures
+
+import dev.onejs.one.source.OneModule
+import kotlinx.coroutines.delay
+
+object Counter : OneModule {
+    private var count = 0
+
+    fun read(): Int = count
+
+    fun increment(): Int {
+        count += 1
+        return count
+    }
+
+    fun reset(): Int {
+        count = 0
+        return count
+    }
+
+    suspend fun delayedRead(ms: Int): Int {
+        require(ms >= 0) { "delay must be nonnegative" }
+        delay(ms.toLong())
+        return count
+    }
+}

package/kotlin/fixtures/counter/CounterScreen.kt

@@ -0,0 +1,40 @@
+package dev.contrast.composefixtures
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.unit.dp
+import androidx.compose.material3.Surface
+import androidx.compose.material3.lightColorScheme
+
+@Composable
+fun CounterScreen() {
+    var count by remember { mutableStateOf(Counter.read()) }
+    MaterialTheme(colorScheme = lightColorScheme(primary = Color(0xFF6750A4))) {
+        Surface(modifier = Modifier.fillMaxSize()) {
+            Column(
+                modifier = Modifier.fillMaxSize().padding(24.dp),
+                verticalArrangement = Arrangement.spacedBy(16.dp),
+            ) {
+                Text("Kotlin counter", style = MaterialTheme.typography.headlineSmall)
+                Text("Count: $count", modifier = Modifier.testTag("counter-value"))
+                Button(
+                    onClick = { count = Counter.increment() },
+                    modifier = Modifier.testTag("counter-increment"),
+                ) { Text("Increment") }
+            }
+        }
+    }
+}

package/kotlin/fixtures/headless-counter/Headless.kt

@@ -0,0 +1,228 @@
+@file:OptIn(androidx.compose.ui.ExperimentalComposeUiApi::class, androidx.compose.ui.InternalComposeUiApi::class, androidx.compose.ui.text.ExperimentalTextApi::class, kotlin.js.ExperimentalWasmJsInterop::class)
+package dev.contrast.composefixtures
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.getValue
+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.graphics.asComposeCanvas
+import androidx.compose.ui.input.InputMode
+import androidx.compose.ui.input.InputModeManager
+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.LocalLocaleList
+import androidx.compose.ui.platform.PlatformContext
+import androidx.compose.ui.platform.WindowInfo
+import androidx.compose.ui.platform.registerSkikoComposeImplementation
+import androidx.compose.ui.scene.CanvasLayersComposeScene
+import androidx.compose.ui.scene.hasInvalidations
+import androidx.compose.ui.semantics.SemanticsNode
+import androidx.compose.ui.semantics.SemanticsOwner
+import androidx.compose.ui.semantics.SemanticsProperties
+import androidx.compose.ui.semantics.getOrNull
+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.FontWeight
+import androidx.compose.ui.text.font.PlatformTypefacesLoader
+import androidx.compose.ui.text.font.createPlatformFontFamilyResolver
+import androidx.compose.ui.text.font.platformTypefacesLoader
+import androidx.compose.ui.text.intl.LocaleList
+import androidx.compose.ui.text.platform.Font
+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 dev.onejs.one.source.OneModule
+import kotlin.io.encoding.Base64
+import kotlin.js.js
+import kotlin.time.TimeSource
+import kotlinx.coroutines.Dispatchers
+import org.jetbrains.skia.Color
+import org.jetbrains.skia.Surface
+import org.json.JSONArray
+import org.json.JSONObject
+
+private fun workerGlobals(): String =
+    js("JSON.stringify({ window: typeof window, document: typeof document, languages: globalThis.navigator.languages })")
+
+// the simulated Android device as Compose's platform sees it: its screen,
+// its locale, touch mode (an Android device starts in it, so a tap shows no
+// focus) and the semantics owners inspection reads. everything else is
+// Compose's own default for a platform that supplies nothing.
+private class PeachPlatformContext(
+    size: IntSize,
+    density: Density,
+    override val localeList: LocaleList,
+) : PlatformContext by PlatformContext.Empty(), PlatformContext.SemanticsOwnerListener {
+    val semanticsOwners = mutableSetOf<SemanticsOwner>()
+    override val windowInfo: WindowInfo = object : WindowInfo {
+        override val isWindowFocused: Boolean get() = true
+        override val containerSize: IntSize = size
+        override val containerDpSize: DpSize = with(density) { DpSize(size.width.toDp(), size.height.toDp()) }
+    }
+    override val inputModeManager: InputModeManager = object : InputModeManager {
+        override var inputMode: InputMode by mutableStateOf(InputMode.Touch)
+        override fun requestInputMode(inputMode: InputMode): Boolean {
+            this.inputMode = inputMode
+            return true
+        }
+    }
+    override val semanticsOwnerListener: PlatformContext.SemanticsOwnerListener get() = this
+    override fun onSemanticsOwnerAppended(semanticsOwner: SemanticsOwner) { semanticsOwners.add(semanticsOwner) }
+    override fun onSemanticsOwnerRemoved(semanticsOwner: SemanticsOwner) { semanticsOwners.remove(semanticsOwner) }
+    override fun onSemanticsChange(semanticsOwner: SemanticsOwner) = Unit
+    override fun onLayoutChange(semanticsOwner: SemanticsOwner, semanticsNodeId: Int) = Unit
+}
+
+// a Pixel 8 screen, rendered to a raster surface one 60 Hz frame at a time
+private class DeviceScene(locale: String, content: @Composable () -> Unit) : AutoCloseable {
+    private val size = IntSize(1080, 2400)
+    private val density = Density(420f / 160f)
+    init {
+        registerSkikoComposeImplementation()
+    }
+    val context = PeachPlatformContext(size, density, LocaleList(locale))
+    private val recomposer = FrameRecomposer(Dispatchers.Unconfined)
+    private val scene = CanvasLayersComposeScene(recomposer, density, LayoutDirection.Ltr, size, context)
+        .also { it.setContent(content = content) }
+    private val surface = Surface.makeRasterN32Premul(size.width, size.height)
+    var nanos = 0L
+        private set
+
+    fun frame(): ByteArray {
+        Snapshot.sendApplyNotifications()
+        surface.canvas.clear(Color.TRANSPARENT)
+        recomposer.performFrame(nanos)
+        scene.measureAndLayout()
+        scene.draw(surface.canvas.asComposeCanvas())
+        nanos += 16_666_667L
+        val image = surface.makeImageSnapshot()
+        try {
+            val data = checkNotNull(image.encodeToData())
+            try { return data.bytes } finally { data.close() }
+        } finally { image.close() }
+    }
+
+    fun settle(from: ByteArray): ByteArray {
+        var previous = from
+        repeat(180) {
+            val next = frame()
+            if (!recomposer.hasPendingWork() && !scene.hasInvalidations() && next.contentEquals(previous)) return next
+            previous = next
+        }
+        error("scene never settled")
+    }
+
+    private fun nodes(merged: Boolean): List<SemanticsNode> {
+        fun collect(node: SemanticsNode): List<SemanticsNode> = listOf(node) + node.children.flatMap { collect(it) }
+        return context.semanticsOwners.flatMap {
+            collect(if (merged) it.rootSemanticsNode else it.unmergedRootSemanticsNode)
+        }
+    }
+
+    fun node(tag: String): SemanticsNode =
+        nodes(merged = true).single { it.config.getOrNull(SemanticsProperties.TestTag) == tag }
+
+    // every text node with its bounds, unmerged as Android's accessibility
+    // hierarchy reports a button's label apart from the button
+    fun texts(): JSONArray {
+        val texts = JSONArray()
+        for (node in nodes(merged = false)) {
+            val value = text(node) ?: continue
+            val bounds = node.boundsInRoot
+            texts.put(JSONObject().put("text", value).put("left", bounds.left).put("top", bounds.top)
+                .put("right", bounds.right).put("bottom", bounds.bottom))
+        }
+        return texts
+    }
+
+    fun tap(tag: String) {
+        val center = node(tag).boundsInRoot.center
+        scene.sendPointerEvent(PointerEventType.Press, center, timeMillis = nanos / 1_000_000L, type = PointerType.Touch)
+        scene.sendPointerEvent(PointerEventType.Release, center, timeMillis = nanos / 1_000_000L + 20L, type = PointerType.Touch)
+    }
+
+    override fun close() {
+        scene.close()
+        recomposer.close()
+        surface.close()
+    }
+}
+
+// Android's default and sans-serif families are Roboto. the app's own
+// families resolve as Compose resolves them.
+@Composable
+private fun AndroidFonts(roboto: FontFamily, content: @Composable () -> Unit) {
+    val parent = LocalFontFamilyResolver.current
+    val resolver = remember(parent) {
+        val backend = checkNotNull(parent.platformTypefacesLoader())
+        createPlatformFontFamilyResolver(object : PlatformTypefacesLoader by backend {
+            override val cacheKey: Any get() = this
+            override fun loadPlatformTypes(fontFamily: FontFamily, fontWeight: FontWeight, fontStyle: FontStyle): Any =
+                if (fontFamily == FontFamily.Default || fontFamily == FontFamily.SansSerif)
+                    parent.resolve(roboto, fontWeight, fontStyle, FontSynthesis.All).value
+                else backend.loadPlatformTypes(fontFamily, fontWeight, fontStyle)
+        })
+    }
+    CompositionLocalProvider(LocalFontFamilyResolver provides resolver, content = content)
+}
+
+private fun text(node: SemanticsNode): String? =
+    node.config.getOrNull(SemanticsProperties.Text)?.joinToString { it.text }
+
+object Headless : OneModule {
+    suspend fun capture(regular: String, medium: String, bold: String): String {
+        try {
+            val roboto = 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),
+            )
+            Counter.reset()
+            val start = TimeSource.Monotonic.markNow()
+            DeviceScene("en-US") { AndroidFonts(roboto) { CounterScreen() } }.use { device ->
+                val first = device.frame()
+                val firstFrameMs = start.elapsedNow().inWholeMicroseconds / 1000.0
+                val main = device.settle(first)
+                val mainTexts = device.texts()
+                val value = device.node("counter-value")
+                check(text(value) == "Count: 0")
+                val buttonBounds = device.node("counter-increment").boundsInRoot
+                val tapStart = TimeSource.Monotonic.markNow()
+                device.tap("counter-increment")
+                val incremented = device.settle(main)
+                val interactiveMs = tapStart.elapsedNow().inWholeMicroseconds / 1000.0
+                check(text(device.node("counter-value")) == "Count: 1")
+                check(Counter.read() == 1)
+                val incrementedTexts = device.texts()
+                check(!main.contentEquals(incremented))
+                return JSONObject().put("main", Base64.encode(main)).put("incremented", Base64.encode(incremented))
+                    .put("mainTexts", mainTexts).put("incrementedTexts", incrementedTexts)
+                    .put("firstFrameMs", firstFrameMs).put("interactiveMs", interactiveMs)
+                    .put("buttonBounds", buttonBounds.toString()).put("valueTop", value.boundsInRoot.top)
+                    .put("settledNanos", device.nanos)
+                    .put("globals", workerGlobals()).toString()
+            }
+        } catch (error: Throwable) {
+            throw IllegalStateException(error.stackTraceToString(), error)
+        }
+    }
+
+    // the locale the composition sees is the device's, not the browser's
+    fun locale(tag: String): String {
+        try {
+            var seen: LocaleList? = null
+            DeviceScene(tag) { seen = LocalLocaleList.current }.use { it.frame() }
+            return JSONObject().put("device", tag).put("composition", checkNotNull(seen).joinToString(",") { it.toLanguageTag() })
+                .put("globals", workerGlobals()).toString()
+        } catch (error: Throwable) {
+            throw IllegalStateException(error.stackTraceToString(), error)
+        }
+    }
+}

package/kotlin/fixtures/runtime-state/RuntimeState.kt

@@ -0,0 +1,200 @@
+package dev.contrast.composefixtures
+
+import dev.onejs.one.source.OneModule
+import androidx.compose.runtime.*
+import androidx.compose.runtime.snapshots.Snapshot
+import kotlinx.coroutines.*
+import org.json.JSONObject
+
+private class Node {
+    var text = ""
+    var click: () -> Unit = {}
+    val children = mutableListOf<Node>()
+}
+private class TreeApplier(root: Node) : AbstractApplier<Node>(root) {
+    override fun insertTopDown(index: Int, instance: Node) { current.children.add(index, instance) }
+    override fun insertBottomUp(index: Int, instance: Node) {}
+    override fun remove(index: Int, count: Int) { repeat(count) { current.children.removeAt(index) } }
+    override fun move(from: Int, to: Int, count: Int) { current.children.move(from, to, count) }
+    override fun onClear() { root.children.clear() }
+}
+private val shared = mutableStateOf(0)
+@Composable
+private fun CounterTree() {
+    var count by remember { mutableStateOf(0) }
+    val value = "local=$count shared=${shared.value}"
+    ComposeNode<Node, TreeApplier>(
+        factory = { Node() },
+        update = {
+            set(value) { text = it }
+            set({ count += 1; shared.value += 1 }) { click = it }
+        }
+    )
+}
+
+private class RootEffects {
+    val launched = CompletableDeferred<Unit>()
+    val cancelled = CompletableDeferred<Unit>()
+    val frame = CompletableDeferred<Long>()
+    val scopeStarted = CompletableDeferred<Unit>()
+    val scopeCancelled = CompletableDeferred<Unit>()
+    var starts = 0
+    var disposals = 0
+    var scope: CoroutineScope? = null
+    var scopeJob: Job? = null
+}
+
+@Composable
+private fun LifecycleTree(label: String, effects: RootEffects) {
+    var count by remember { mutableStateOf(0) }
+    val scope = rememberCoroutineScope()
+    SideEffect { effects.scope = scope }
+    DisposableEffect(Unit) {
+        effects.starts += 1
+        onDispose { effects.disposals += 1 }
+    }
+    LaunchedEffect(Unit) {
+        effects.launched.complete(Unit)
+        try {
+            effects.frame.complete(withFrameNanos { it })
+            awaitCancellation()
+        } finally {
+            effects.cancelled.complete(Unit)
+        }
+    }
+    ComposeNode<Node, TreeApplier>(
+        factory = { Node() },
+        update = {
+            set("$label local=$count shared=${shared.value}") { text = it }
+            set({
+                count += 1
+                shared.value += 1
+                if (effects.scopeJob == null) effects.scopeJob = scope.launch {
+                    effects.scopeStarted.complete(Unit)
+                    try { awaitCancellation() } finally { effects.scopeCancelled.complete(Unit) }
+                }
+            }) { click = it }
+        }
+    )
+}
+
+object RuntimeState : OneModule {
+    fun failError(): Int = throw AssertionError("error boundary")
+
+    suspend fun checkLifecycle(retainRoot: Boolean, disposeRoot: Boolean): String = withTimeout(5_000) {
+        shared.value = 0
+        val a = Node()
+        val b = Node()
+        val leftEffects = RootEffects()
+        val rightEffects = RootEffects()
+        var label by mutableStateOf("original")
+        var frame = 0L
+        lateinit var clock: BroadcastFrameClock
+        clock = BroadcastFrameClock { launch { clock.sendFrame(++frame) } }
+        val recomposer = Recomposer(coroutineContext + clock)
+        val runner = launch(clock, CoroutineStart.UNDISPATCHED) { recomposer.runRecomposeAndApplyChanges() }
+        val left = Composition(TreeApplier(a), recomposer)
+        val right = Composition(TreeApplier(b), recomposer)
+        try {
+            left.setContent {
+                if (retainRoot) LifecycleTree(label, leftEffects)
+                else key(label) { LifecycleTree(label, leftEffects) }
+            }
+            right.setContent { LifecycleTree("right", rightEffects) }
+            leftEffects.launched.await()
+            rightEffects.launched.await()
+            val leftFrame = leftEffects.frame.await()
+            val rightFrame = rightEffects.frame.await()
+            check(leftFrame == rightFrame) { "roots received different frame times: $leftFrame/$rightFrame" }
+            recomposer.awaitIdle()
+            check(a.children.single().text == "original local=0 shared=0")
+            check(b.children.single().text == "right local=0 shared=0")
+            val original = a.children.single()
+            original.click()
+            b.children.single().click()
+            leftEffects.scopeStarted.await()
+            rightEffects.scopeStarted.await()
+            Snapshot.sendApplyNotifications()
+            recomposer.awaitIdle()
+            label = "updated"
+            Snapshot.sendApplyNotifications()
+            recomposer.awaitIdle()
+            check(a.children.single().text == "updated local=1 shared=2") {
+                "props update reset remembered state: ${a.children.single().text}"
+            }
+            check(a.children.single() === original) { "props update replaced the root node" }
+            check(b.children.single().text == "right local=1 shared=2") { "props update touched the other root" }
+            check(leftEffects.starts == 1 && leftEffects.disposals == 0) { "props update restarted effects" }
+            check(leftEffects.scope?.isActive == true && rightEffects.scope?.isActive == true)
+            if (disposeRoot) left.dispose()
+            check(leftEffects.disposals == 1) { "left disposal did not run DisposableEffect" }
+            leftEffects.cancelled.await()
+            leftEffects.scopeCancelled.await()
+            check(a.children.isEmpty()) { "left disposal retained nodes" }
+            check(leftEffects.scope?.isActive == false && leftEffects.scopeJob?.isCancelled == true)
+            check(rightEffects.disposals == 0 && !rightEffects.cancelled.isCompleted && !rightEffects.scopeCancelled.isCompleted) {
+                "left disposal cancelled the other root"
+            }
+            check(rightEffects.scope?.isActive == true && rightEffects.scopeJob?.isActive == true)
+            b.children.single().click()
+            Snapshot.sendApplyNotifications()
+            recomposer.awaitIdle()
+            check(b.children.single().text == "right local=2 shared=3") { "surviving root stopped recomposing" }
+            right.dispose()
+            rightEffects.cancelled.await()
+            rightEffects.scopeCancelled.await()
+            check(b.children.isEmpty() && rightEffects.disposals == 1)
+            check(rightEffects.scope?.isActive == false && rightEffects.scopeJob?.isCancelled == true)
+            JSONObject().put("passed", true).put("propsRetainState", true).put("propsRetainNode", true)
+                .put("effectsRetainIdentity", true).put("sharedFrameNanos", leftFrame)
+                .put("launchedEffectCancelled", true).put("disposableEffectDisposed", true)
+                .put("rememberedScopeCancelled", true).put("survivingRootRecomposes", true)
+                .put("uiProven", false).toString()
+        } finally {
+            left.dispose()
+            right.dispose()
+            recomposer.cancel()
+            runner.cancelAndJoin()
+        }
+    }
+
+    suspend fun checkState(startScheduler: Boolean): String = coroutineScope {
+        shared.value = 0
+        val a = Node()
+        val b = Node()
+        var frame = 0L
+        lateinit var clock: BroadcastFrameClock
+        clock = BroadcastFrameClock { launch { clock.sendFrame(++frame) } }
+        val recomposer = Recomposer(coroutineContext + clock)
+        val runner = launch(clock, if (startScheduler) CoroutineStart.UNDISPATCHED else CoroutineStart.LAZY) { recomposer.runRecomposeAndApplyChanges() }
+        val left = Composition(TreeApplier(a), recomposer)
+        val right = Composition(TreeApplier(b), recomposer)
+        try {
+            left.setContent { CounterTree() }
+            right.setContent { CounterTree() }
+            check(a.children.single().text == "local=0 shared=0") { "left initial: ${a.children.single().text}" }
+            check(b.children.single().text == "local=0 shared=0") { "right initial: ${b.children.single().text}" }
+            val original = a.children.single()
+            original.click()
+            Snapshot.sendApplyNotifications()
+            recomposer.awaitIdle()
+            check(a.children.single() === original) { "left node identity changed" }
+            check(a.children.single().text == "local=1 shared=1") { "left after click: ${a.children.single().text}" }
+            check(b.children.single().text == "local=0 shared=1") { "right shared update: ${b.children.single().text}" }
+            left.dispose()
+            check(a.children.isEmpty()) { "left dispose retained ${a.children.size} nodes" }
+            b.children.single().click()
+            Snapshot.sendApplyNotifications()
+            recomposer.awaitIdle()
+            check(b.children.single().text == "local=1 shared=2") { "right after click: ${b.children.single().text}" }
+            right.dispose()
+            check(b.children.isEmpty()) { "right dispose retained ${b.children.size} nodes" }
+            "{\"passed\":true,\"runtime\":\"androidx.compose.runtime:1.13.0-alpha02\",\"localState\":[0,1],\"sharedState\":[0,1,2],\"twoRoots\":true,\"retainedNode\":true,\"dispose\":true,\"uiProven\":false}"
+        } finally {
+            left.dispose()
+            right.dispose()
+            recomposer.cancel()
+            runner.cancelAndJoin()
+        }
+    }
+}