peachsim 0.1.939 → 0.1.1399

package/kotlin/ExpoSources/expo/modules/kotlin/views/ViewDefinitionBuilder.kt

@@ -0,0 +1,71 @@
+@file:Suppress("FunctionName", "UNCHECKED_CAST")
+
+package expo.modules.kotlin.views
+
+import android.content.Context
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.functions.AsyncFunctionComponent
+import expo.modules.kotlin.objects.ObjectDefinitionBuilder
+import expo.modules.kotlin.types.toAnyType
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+
+class ViewManagerDefinition(
+    val name: String,
+    internal val viewClass: KClass<*>,
+    internal val createView: (Context, AppContext) -> ExpoView,
+    internal val props: Map<String, AnyViewProp>,
+    internal val callbacks: List<String>,
+    internal val asyncFunctions: Map<String, AsyncFunctionComponent>,
+    internal val onViewDestroys: ((ExpoView) -> Unit)?,
+    internal val onViewDidUpdateProps: ((ExpoView) -> Unit)?,
+)
+
+// the view's async functions take the view as their first argument when they
+// name its type, as upstream's do; their arities come from ObjectDefinitionBuilder
+class ViewDefinitionBuilder<T : ExpoView>(
+    @PublishedApi internal val viewClass: KClass<T>,
+    @PublishedApi internal val viewType: KType,
+) : ObjectDefinitionBuilder() {
+    @PublishedApi internal var name: String = requireNotNull(viewClass.simpleName)
+    @PublishedApi internal val props = mutableMapOf<String, AnyViewProp>()
+    @PublishedApi internal var onViewDestroys: ((ExpoView) -> Unit)? = null
+    @PublishedApi internal var onViewDidUpdateProps: ((ExpoView) -> Unit)? = null
+
+    fun build(createView: (Context, AppContext) -> ExpoView): ViewManagerDefinition {
+        val functions = asyncFunctions + asyncFunctionBuilders.mapValues { (_, builder) -> builder.build() }
+        for (function in functions.values) {
+            function.ownerType = viewType
+            function.canTakeOwner = true
+        }
+        return ViewManagerDefinition(name, viewClass, createView, props.toMap(), eventNames, functions, onViewDestroys, onViewDidUpdateProps)
+    }
+
+    fun Name(viewName: String) {
+        name = viewName
+    }
+
+    inline fun OnViewDestroys(crossinline body: (view: T) -> Unit) {
+        onViewDestroys = { body(it as T) }
+    }
+
+    inline fun OnViewDidUpdateProps(crossinline body: (view: T) -> Unit) {
+        onViewDidUpdateProps = { body(it as T) }
+    }
+
+    inline fun <reified PropType> Prop(name: String, noinline body: (view: T, prop: PropType) -> Unit): ConcreteViewProp<T, PropType> =
+        ConcreteViewProp(name, toAnyType<PropType>(), body).also { props[name] = it }
+
+    inline fun <reified ViewType : ExpoView, reified PropType> Prop(
+        name: String,
+        noinline body: (view: ViewType, prop: PropType) -> Unit,
+    ): ConcreteViewProp<ViewType, PropType> =
+        ConcreteViewProp(name, toAnyType<PropType>(), body).also { props[name] = it }
+
+    inline fun <reified ViewType : ExpoView, reified PropType> Prop(
+        name: String,
+        defaultValue: PropType,
+        noinline body: (view: ViewType, prop: PropType) -> Unit,
+    ): ConcreteViewPropWithDefault<ViewType, PropType> =
+        ConcreteViewPropWithDefault(name, toAnyType<PropType>(), body, defaultValue).also { props[name] = it }
+}

package/kotlin/ExpoSources/expo/modules/kotlin/views/ViewProps.kt

@@ -0,0 +1,35 @@
+@file:Suppress("UNCHECKED_CAST")
+
+package expo.modules.kotlin.views
+
+import expo.modules.kotlin.exception.PropSetException
+import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.types.AnyType
+
+abstract class AnyViewProp(val name: String, internal val type: AnyType) {
+    abstract fun set(prop: Any?, onView: ExpoView)
+}
+
+open class ConcreteViewProp<ViewType : ExpoView, PropType>(
+    name: String,
+    propType: AnyType,
+    protected val setter: (view: ViewType, prop: PropType) -> Unit,
+) : AnyViewProp(name, propType) {
+    override fun set(prop: Any?, onView: ExpoView) {
+        exceptionDecorator({ PropSetException(name, onView::class, it) }) {
+            setter(onView as ViewType, type.convert(prop) as PropType)
+        }
+    }
+}
+
+class ConcreteViewPropWithDefault<ViewType : ExpoView, PropType>(
+    name: String,
+    propType: AnyType,
+    setter: (view: ViewType, prop: PropType) -> Unit,
+    private val defaultValue: PropType,
+) : ConcreteViewProp<ViewType, PropType>(name, propType, setter) {
+    override fun set(prop: Any?, onView: ExpoView) {
+        if (prop == null) setter(onView as ViewType, defaultValue)
+        else super.set(prop, onView)
+    }
+}

package/kotlin/README.md

@@ -17,10 +17,20 @@ traffic in `scripts/debug/peach-swift-lazy-network.sh`.
   into `~/.peach/kotlin/<version>`. kotlinc needs a Java runtime (17 or newer)
   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,
+- `Sources/`: the Android and One declarations every app Kotlin compile
+  (imported modules and pure Kotlin apps) sees: `org.json` with Android's parse
+  and print rules, `android.util.Log` writing the guest console,
+  `android.os.SystemClock`, `Handler`/`Looper`/`MessageQueue` with Android's
+  queue order on the guest event loop, `java.lang.Runnable`,
+  `android.os.Build` values from the active Peach device,
+  `java.security.MessageDigest` for SHA-256, the `%02x` Byte formatter,
   `androidx.annotation.Keep`, `dev.onejs.one.OneNativeSourceDispatch` and
-  `dev.onejs.one.source.OneModule`.
+  `dev.onejs.one.source.OneModule`. Kotlin/Wasm has no implicit `java.lang`
+  import, so app sources import `java.lang.Runnable` explicitly. `AppSources/`
+  adds the activity, window and Compose actuals only pure Kotlin apps compile.
+- `ExpoSources/`: the expo-modules-core Kotlin DSL port and `PeachExpoRuntime`
+  that local Expo Android modules compile against. Owner spec:
+  [`specs/peach-kotlin-expo-modules.md`](../../../specs/peach-kotlin-expo-modules.md).
 
 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

package/kotlin/Sources/android/os/Build.kt

@@ -0,0 +1,17 @@
+package android.os
+
+// Build values follow the active Peach Android device supplied by its host.
+object Build {
+    var MODEL: String = ""
+        private set
+
+    object VERSION {
+        var RELEASE: String = ""
+            internal set
+    }
+
+    internal fun setDevice(model: String, release: String) {
+        MODEL = model
+        VERSION.RELEASE = release
+    }
+}

package/kotlin/Sources/android/os/Handler.kt

@@ -0,0 +1,35 @@
+package android.os
+
+import java.lang.Runnable
+
+// android.os.Handler's runnable half, posting to its looper's queue
+open class Handler(private val looper: Looper) {
+    @Deprecated("implicitly choosing a Looper during Handler construction can lead to bugs")
+    constructor() : this(Looper.myLooper() ?: throw RuntimeException("Can't create handler inside thread that has not called Looper.prepare()"))
+
+    fun getLooper(): Looper = looper
+
+    fun post(r: Runnable): Boolean = postAtTime(r, SystemClock.uptimeMillis())
+    fun postDelayed(r: Runnable, delayMillis: Long): Boolean =
+        postAtTime(r, SystemClock.uptimeMillis() + delayMillis.coerceAtLeast(0))
+    fun postDelayed(r: Runnable, token: Any?, delayMillis: Long): Boolean =
+        postAtTime(r, token, SystemClock.uptimeMillis() + delayMillis.coerceAtLeast(0))
+    fun postAtTime(r: Runnable, uptimeMillis: Long): Boolean = postAtTime(r, null, uptimeMillis)
+    fun postAtTime(r: Runnable, token: Any?, uptimeMillis: Long): Boolean {
+        looper.queue.enqueue(MessageQueue.Entry(uptimeMillis, this, r, token), front = false)
+        return true
+    }
+    fun postAtFrontOfQueue(r: Runnable): Boolean {
+        looper.queue.enqueue(MessageQueue.Entry(0, this, r, null), front = true)
+        return true
+    }
+
+    fun removeCallbacks(r: Runnable) = looper.queue.remove(this, r, null)
+    fun removeCallbacks(r: Runnable, token: Any?) = looper.queue.remove(this, r, token)
+    fun removeCallbacksAndMessages(token: Any?) = looper.queue.remove(this, null, token)
+    fun hasCallbacks(r: Runnable): Boolean = looper.queue.has(this, r, null)
+
+    companion object {
+        fun createAsync(looper: Looper): Handler = Handler(looper)
+    }
+}

package/kotlin/Sources/android/os/Looper.kt

@@ -0,0 +1,17 @@
+package android.os
+
+// the guest's one thread is Android's main thread: its looper is the main
+// looper and every message runs on the guest event loop
+class Looper private constructor() {
+    internal val queue = MessageQueue()
+
+    fun isCurrentThread(): Boolean = true
+    fun getQueue(): MessageQueue = queue
+
+    companion object {
+        private val main = Looper()
+        fun getMainLooper(): Looper = main
+        fun myLooper(): Looper? = main
+        fun myQueue(): MessageQueue = main.queue
+    }
+}

package/kotlin/Sources/android/os/MessageQueue.kt

@@ -0,0 +1,56 @@
+package android.os
+
+import java.lang.Runnable
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+// MessageQueue's ordering: by uptime, then by enqueue order, with
+// postAtFrontOfQueue at time zero ahead of everything already queued
+class MessageQueue internal constructor() {
+    internal class Entry(val time: Long, val handler: Handler, val callback: Runnable, val token: Any?)
+
+    private val entries = ArrayList<Entry>()
+    private var wake: Job? = null
+    private var wakeAt = Long.MAX_VALUE
+
+    fun isIdle(): Boolean = entries.firstOrNull().let { it == null || it.time > SystemClock.uptimeMillis() }
+
+    internal fun enqueue(entry: Entry, front: Boolean) {
+        val index = if (front) 0 else entries.indexOfFirst { it.time > entry.time }.let { if (it < 0) entries.size else it }
+        entries.add(index, entry)
+        schedule()
+    }
+
+    internal fun remove(handler: Handler, callback: Runnable?, token: Any?) {
+        entries.removeAll { it.handler === handler && (callback == null || it.callback === callback) && (token == null || it.token === token) }
+    }
+
+    internal fun has(handler: Handler, callback: Runnable?, token: Any?): Boolean =
+        entries.any { it.handler === handler && (callback == null || it.callback === callback) && (token == null || it.token === token) }
+
+    @OptIn(DelicateCoroutinesApi::class)
+    private fun schedule() {
+        val next = entries.firstOrNull()?.time ?: return
+        if (wake != null && wakeAt <= next) return
+        wake?.cancel()
+        wakeAt = next
+        wake = GlobalScope.launch(Dispatchers.Main) {
+            delay(next - SystemClock.uptimeMillis())
+            wake = null
+            wakeAt = Long.MAX_VALUE
+            // run what is due one message at a time; a callback may post or
+            // remove, so read the head again after each one
+            while (true) {
+                val head = entries.firstOrNull() ?: break
+                if (head.time > SystemClock.uptimeMillis()) break
+                entries.removeAt(0)
+                head.callback.run()
+            }
+            schedule()
+        }
+    }
+}

package/kotlin/Sources/android/os/SystemClock.kt

@@ -0,0 +1,14 @@
+package android.os
+
+// android.os.SystemClock over the guest's monotonic clock; the device boots
+// with the guest, and a browser device never sleeps, so uptime and realtime
+// agree. sleep() is absent: the main thread cannot block here.
+object SystemClock {
+    fun uptimeMillis(): Long = nowMillis().toLong()
+    fun uptimeNanos(): Long = (nowMillis() * 1_000_000.0).toLong()
+    fun elapsedRealtime(): Long = nowMillis().toLong()
+    fun elapsedRealtimeNanos(): Long = (nowMillis() * 1_000_000.0).toLong()
+    fun currentThreadTimeMillis(): Long = nowMillis().toLong()
+}
+
+private fun nowMillis(): Double = js("performance.now()")

package/kotlin/Sources/android/util/Log.kt

@@ -0,0 +1,64 @@
+package android.util
+
+// android.util.Log: the main log buffer is the guest console, one console
+// level per priority. liblog answers 1 for a written line and -EPERM below
+// VERBOSE; isLoggable answers the unset log.tag property's INFO default.
+object Log {
+    const val VERBOSE = 2
+    const val DEBUG = 3
+    const val INFO = 4
+    const val WARN = 5
+    const val ERROR = 6
+    const val ASSERT = 7
+
+    fun v(tag: String?, msg: String): Int = println(VERBOSE, tag, msg)
+    fun v(tag: String?, msg: String?, tr: Throwable?): Int = printlns(VERBOSE, tag, msg, tr)
+    fun d(tag: String?, msg: String): Int = println(DEBUG, tag, msg)
+    fun d(tag: String?, msg: String?, tr: Throwable?): Int = printlns(DEBUG, tag, msg, tr)
+    fun i(tag: String?, msg: String): Int = println(INFO, tag, msg)
+    fun i(tag: String?, msg: String?, tr: Throwable?): Int = printlns(INFO, tag, msg, tr)
+    fun w(tag: String?, msg: String): Int = println(WARN, tag, msg)
+    fun w(tag: String?, msg: String?, tr: Throwable?): Int = printlns(WARN, tag, msg, tr)
+    fun w(tag: String?, tr: Throwable?): Int = printlns(WARN, tag, "", tr)
+    fun e(tag: String?, msg: String): Int = println(ERROR, tag, msg)
+    fun e(tag: String?, msg: String?, tr: Throwable?): Int = printlns(ERROR, tag, msg, tr)
+
+    // an app process's default terrible failure handler logs and continues
+    fun wtf(tag: String?, msg: String?): Int = printlns(ASSERT, tag, msg, null)
+    fun wtf(tag: String?, tr: Throwable): Int = printlns(ASSERT, tag, tr.message, tr)
+    fun wtf(tag: String?, msg: String?, tr: Throwable?): Int = printlns(ASSERT, tag, msg, tr)
+
+    fun isLoggable(tag: String?, level: Int): Boolean = level >= INFO
+
+    fun getStackTraceString(tr: Throwable?): String {
+        var cause = tr ?: return ""
+        // Android hides host lookup failures, which carry no useful trace
+        while (true) {
+            if (cause::class.simpleName == "UnknownHostException") return ""
+            cause = cause.cause ?: break
+        }
+        return tr.stackTraceToString()
+    }
+
+    fun println(priority: Int, tag: String?, msg: String): Int {
+        if (priority < VERBOSE) return -1
+        val line = if (tag == null) msg else "$tag: $msg"
+        when (priority) {
+            VERBOSE, DEBUG -> consoleDebug(line)
+            INFO -> consoleInfo(line)
+            WARN -> consoleWarn(line)
+            else -> consoleError(line)
+        }
+        return 1
+    }
+
+    private fun printlns(priority: Int, tag: String?, msg: String?, tr: Throwable?): Int {
+        val trace = getStackTraceString(tr)
+        return println(priority, tag, if (trace.isEmpty()) msg ?: "" else "${msg ?: ""}\n$trace")
+    }
+}
+
+private fun consoleDebug(line: String): Unit = js("console.debug(line)")
+private fun consoleInfo(line: String): Unit = js("console.info(line)")
+private fun consoleWarn(line: String): Unit = js("console.warn(line)")
+private fun consoleError(line: String): Unit = js("console.error(line)")

package/kotlin/Sources/java/security/MessageDigest.kt

@@ -0,0 +1,114 @@
+package java.security
+
+class NoSuchAlgorithmException(message: String) : Exception(message)
+
+class MessageDigest private constructor() {
+    companion object {
+        fun getInstance(algorithm: String): MessageDigest {
+            if (algorithm.uppercase() != "SHA-256")
+                throw NoSuchAlgorithmException("$algorithm MessageDigest not available")
+            return MessageDigest()
+        }
+    }
+
+    fun digest(input: ByteArray): ByteArray = sha256(input)
+
+    private fun sha256(input: ByteArray): ByteArray {
+        val bitLength = input.size.toLong() * 8L
+        val paddedLength = ((input.size + 9 + 63) / 64) * 64
+        val padded = ByteArray(paddedLength)
+        input.copyInto(padded)
+        padded[input.size] = 0x80.toByte()
+        for (index in 0 until 8) {
+            padded[paddedLength - 1 - index] = (bitLength ushr (index * 8)).toByte()
+        }
+
+        val state = intArrayOf(
+            0x6a09e667,
+            0xbb67ae85.toInt(),
+            0x3c6ef372,
+            0xa54ff53a.toInt(),
+            0x510e527f,
+            0x9b05688c.toInt(),
+            0x1f83d9ab,
+            0x5be0cd19,
+        )
+        val constants = intArrayOf(
+            0x428a2f98.toInt(), 0x71374491, 0xb5c0fbcf.toInt(), 0xe9b5dba5.toInt(),
+            0x3956c25b, 0x59f111f1, 0x923f82a4.toInt(), 0xab1c5ed5.toInt(),
+            0xd807aa98.toInt(), 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74,
+            0x80deb1fe.toInt(), 0x9bdc06a7.toInt(), 0xc19bf174.toInt(),
+            0xe49b69c1.toInt(), 0xefbe4786.toInt(), 0x0fc19dc6, 0x240ca1cc,
+            0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da.toInt(), 0x983e5152.toInt(),
+            0xa831c66d.toInt(), 0xb00327c8.toInt(), 0xbf597fc7.toInt(), 0xc6e00bf3.toInt(),
+            0xd5a79147.toInt(), 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138,
+            0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e.toInt(),
+            0x92722c85.toInt(), 0xa2bfe8a1.toInt(), 0xa81a664b.toInt(), 0xc24b8b70.toInt(),
+            0xc76c51a3.toInt(), 0xd192e819.toInt(), 0xd6990624.toInt(), 0xf40e3585.toInt(),
+            0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+            0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee,
+            0x78a5636f, 0x84c87814.toInt(), 0x8cc70208.toInt(), 0x90befffa.toInt(),
+            0xa4506ceb.toInt(), 0xbef9a3f7.toInt(), 0xc67178f2.toInt(),
+        )
+        val words = IntArray(64)
+        var offset = 0
+        while (offset < padded.size) {
+            for (index in 0 until 16) {
+                val start = offset + index * 4
+                words[index] =
+                    ((padded[start].toInt() and 0xff) shl 24) or
+                    ((padded[start + 1].toInt() and 0xff) shl 16) or
+                    ((padded[start + 2].toInt() and 0xff) shl 8) or
+                    (padded[start + 3].toInt() and 0xff)
+            }
+            for (index in 16 until 64) {
+                val x = words[index - 15]
+                val y = words[index - 2]
+                val small0 = x.rotateRight(7) xor x.rotateRight(18) xor (x ushr 3)
+                val small1 = y.rotateRight(17) xor y.rotateRight(19) xor (y ushr 10)
+                words[index] = words[index - 16] + small0 + words[index - 7] + small1
+            }
+
+            var a = state[0]
+            var b = state[1]
+            var c = state[2]
+            var d = state[3]
+            var e = state[4]
+            var f = state[5]
+            var g = state[6]
+            var h = state[7]
+            for (index in 0 until 64) {
+                val large1 = e.rotateRight(6) xor e.rotateRight(11) xor e.rotateRight(25)
+                val choose = (e and f) xor (e.inv() and g)
+                val first = h + large1 + choose + constants[index] + words[index]
+                val large0 = a.rotateRight(2) xor a.rotateRight(13) xor a.rotateRight(22)
+                val majority = (a and b) xor (a and c) xor (b and c)
+                val second = large0 + majority
+                h = g
+                g = f
+                f = e
+                e = d + first
+                d = c
+                c = b
+                b = a
+                a = first + second
+            }
+            state[0] += a
+            state[1] += b
+            state[2] += c
+            state[3] += d
+            state[4] += e
+            state[5] += f
+            state[6] += g
+            state[7] += h
+            offset += 64
+        }
+
+        return ByteArray(32) { index ->
+            (state[index / 4] ushr (24 - (index % 4) * 8)).toByte()
+        }
+    }
+
+    private fun Int.rotateRight(distance: Int): Int =
+        (this ushr distance) or (this shl (32 - distance))
+}

package/kotlin/Sources/kotlin/text/StringFormat.kt

@@ -0,0 +1,9 @@
+package kotlin.text
+
+fun String.format(vararg args: Any?): String {
+    if (this != "%02x" || args.size != 1 || args[0] !is Byte)
+        throw IllegalArgumentException("Peach Kotlin formatting supports only %02x Byte conversion")
+    return ((args[0] as Byte).toInt() and 0xff).toString(16).padStart(2, '0')
+}
+
+fun String.toByteArray(): ByteArray = encodeToByteArray()

package/kotlin/Sources/org/json/JSON.kt

@@ -139,6 +139,20 @@ private fun write(value: Any?, out: StringBuilder) {
     }
 }
 
+private fun typeMismatch(indexOrName: Any, value: Any, required: String): JSONException {
+    val className = when (value) {
+        JSONObject.NULL -> "org.json.JSONObject\$1"
+        is String -> "java.lang.String"
+        is Boolean -> "java.lang.Boolean"
+        is Int -> "java.lang.Integer"
+        is Long -> "java.lang.Long"
+        is Double -> "java.lang.Double"
+        is Float -> "java.lang.Float"
+        else -> value::class.qualifiedName
+    }
+    return JSONException("Value $value at $indexOrName of type $className cannot be converted to $required")
+}
+
 class JSONArray() {
     private val values = ArrayList<Any?>()
 
@@ -161,6 +175,22 @@ class JSONArray() {
         return values[index] ?: throw JSONException("Value at $index is null.")
     }
 
+    fun getString(index: Int): String = get(index).toString()
+
+    fun getJSONArray(index: Int): JSONArray {
+        val value = get(index)
+        return value as? JSONArray ?: throw typeMismatch(index, value, "JSONArray")
+    }
+
+    fun optJSONArray(index: Int): JSONArray? = opt(index) as? JSONArray
+
+    fun getJSONObject(index: Int): JSONObject {
+        val value = get(index)
+        return value as? JSONObject ?: throw typeMismatch(index, value, "JSONObject")
+    }
+
+    fun optJSONObject(index: Int): JSONObject? = opt(index) as? JSONObject
+
     fun put(value: Any?): JSONArray {
         values.add(value)
         return this
@@ -214,6 +244,20 @@ class JSONObject() {
         else -> value.toString()
     }
 
+    fun getJSONArray(name: String): JSONArray {
+        val value = get(name)
+        return value as? JSONArray ?: throw typeMismatch(name, value, "JSONArray")
+    }
+
+    fun optJSONArray(name: String): JSONArray? = opt(name) as? JSONArray
+
+    fun getJSONObject(name: String): JSONObject {
+        val value = get(name)
+        return value as? JSONObject ?: throw typeMismatch(name, value, "JSONObject")
+    }
+
+    fun optJSONObject(name: String): JSONObject? = opt(name) as? JSONObject
+
     fun optInt(name: String, fallback: Int = 0): Int = when (val value = opt(name)) {
         is Number -> value.toInt()
         is String -> value.toDoubleOrNull()?.toInt() ?: fallback

package/kotlin/fixtures/counter/Counter.d.kt.ts

@@ -13,4 +13,5 @@ export declare const CounterEffects: {
   dispose(): Promise<void>
   cancel(): Promise<void>
   read(): Promise<number[]>
+  awaitDisposed(): Promise<number[]>
 }

package/kotlin/fixtures/counter/Counter.kt

@@ -2,6 +2,8 @@ package dev.contrast.composefixtures
 
 import dev.onejs.one.source.OneModule
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.first
 
 object Counter : OneModule {
     private var count = 0
@@ -30,6 +32,7 @@ object CounterEffects : OneModule {
     private var entered = 0
     private var disposed = 0
     private var cancelled = 0
+    private val changes = MutableStateFlow(0)
     private var compositionLocale = ""
     private var currentLocale = ""
     internal fun recordLocale(current: String, composition: String) {
@@ -37,8 +40,12 @@ object CounterEffects : OneModule {
         compositionLocale = composition
     }
     fun locales(): List<String> = listOf(currentLocale, compositionLocale)
-    fun enter() { entered += 1 }
-    fun dispose() { disposed += 1 }
-    fun cancel() { cancelled += 1 }
+    fun enter() { entered += 1; changes.value += 1 }
+    fun dispose() { disposed += 1; changes.value += 1 }
+    fun cancel() { cancelled += 1; changes.value += 1 }
     fun read(): List<Int> = listOf(entered, disposed, cancelled)
+    suspend fun awaitDisposed(): List<Int> {
+        changes.first { entered > 0 && disposed == entered && cancelled == entered }
+        return read()
+    }
 }

package/kotlin/fixtures/counter/CounterApp.native.tsx

@@ -13,7 +13,7 @@ export default function Index() {
     if (callback > 0) void CounterEffects.locales().then(setLocales)
   }, [callback])
   useEffect(() => {
-    if (!mounted) void CounterEffects.read().then(setEffects)
+    if (!mounted) void CounterEffects.awaitDisposed().then(setEffects)
   }, [mounted])
   return (
     <View style={{ flex: 1 }}>

package/kotlin/fixtures/counter/vite.config.ts

@@ -1,10 +1,10 @@
 import { one } from 'one/vite'
-import { rnxPlugin } from 'peachsim/vite'
+import { peachPlugin } from 'peachsim/vite'
 export default {
   root: import.meta.dirname,
   plugins: [
     one({ web: { defaultRenderMode: 'spa' }, native: { bundler: 'vite' } }),
-    rnxPlugin(),
+    peachPlugin(),
   ],
   server: { host: '0.0.0.0' },
 }

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

@@ -28,6 +28,7 @@ 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.FontVariation
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.font.PlatformTypefacesLoader
 import androidx.compose.ui.text.font.createPlatformFontFamilyResolver
@@ -182,13 +183,13 @@ 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 {
+    suspend fun capture(font: 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),
-            )
+            val data = Base64.decode(font)
+            val roboto = FontFamily(listOf(FontWeight.Normal, FontWeight.Medium, FontWeight.Bold).map { weight ->
+                Font("Roboto-${weight.weight}", getData = { data }, weight = weight,
+                    variationSettings = FontVariation.Settings(weight, FontStyle.Normal))
+            })
             Counter.reset()
             val start = TimeSource.Monotonic.markNow()
             DeviceScene("en-US") { AndroidFonts(roboto) { CounterScreen() } }.use { device ->

package/kotlin/fixtures/import-animation/Animation.d.kt.ts

@@ -0,0 +1,7 @@
+// generated by one typegen; edits will be replaced
+import type { ReactElement } from 'react'
+
+export declare function Animation(props: {
+  title: string
+  onStep?: ((value0: number) => void) | null
+}): ReactElement