peachsim 0.1.939 → 0.1.1399

package/kotlin/ExpoSources/expo/modules/kotlin/functions/Functions.kt

@@ -0,0 +1,132 @@
+@file:Suppress("FunctionName", "UNCHECKED_CAST")
+
+package expo.modules.kotlin.functions
+
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.ArgumentCastException
+import expo.modules.kotlin.exception.InvalidArgsNumberException
+import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.types.AnyType
+import expo.modules.kotlin.types.toAnyType
+import kotlinx.coroutines.CoroutineScope
+import kotlin.reflect.KType
+
+abstract class AnyFunction(
+    val name: String,
+    @PublishedApi internal val desiredArgsTypes: Array<AnyType>,
+) {
+    internal var isEnumerable: Boolean = true
+
+    // a class member takes the JavaScript `this` as its first argument when
+    // that argument is the owner type
+    @PublishedApi internal var canTakeOwner: Boolean = false
+    @PublishedApi internal var ownerType: KType? = null
+
+    internal val takesOwner: Boolean
+        get() = canTakeOwner && ownerType != null && desiredArgsTypes.firstOrNull()?.kType?.classifier == ownerType?.classifier
+
+    // trailing nullable arguments are optional
+    private val requiredArgumentsCount = run {
+        val last = desiredArgsTypes.indexOfLast { !it.isNullable }
+        last + 1
+    }
+
+    internal fun convertArgs(args: List<Any?>): Array<Any?> {
+        if (requiredArgumentsCount > args.size || args.size > desiredArgsTypes.size)
+            throw InvalidArgsNumberException(args.size, desiredArgsTypes.size, requiredArgumentsCount)
+        val converted = arrayOfNulls<Any?>(desiredArgsTypes.size)
+        for (index in args.indices) {
+            val element = args[index]
+            val desiredType = desiredArgsTypes[index]
+            exceptionDecorator({ cause ->
+                ArgumentCastException(desiredType.toString(), index, jvmClassName(element), cause)
+            }) {
+                converted[index] = desiredType.convert(element)
+            }
+        }
+        return converted
+    }
+
+    fun enumerable(isEnumerable: Boolean = true) = apply {
+        this.isEnumerable = isEnumerable
+    }
+}
+
+// the Java class an argument has when JSI hands it to the converters
+private fun jvmClassName(value: Any?): String = when (value) {
+    null -> "null"
+    is Double -> "class java.lang.Double"
+    is String -> "class java.lang.String"
+    is Boolean -> "class java.lang.Boolean"
+    is List<*> -> "class java.util.ArrayList"
+    is Map<*, *> -> "class java.util.HashMap"
+    is expo.modules.kotlin.jni.JavaScriptTypedArray -> "class expo.modules.kotlin.jni.JavaScriptTypedArray"
+    is expo.modules.kotlin.sharedobjects.SharedObjectId -> "class java.lang.Integer"
+    else -> "class ${value::class.simpleName}"
+}
+
+class SyncFunctionComponent(
+    name: String,
+    desiredArgsTypes: Array<AnyType>,
+    @PublishedApi internal val body: (args: Array<out Any?>) -> Any?,
+) : AnyFunction(name, desiredArgsTypes)
+
+sealed class AsyncFunctionComponent(name: String, desiredArgsTypes: Array<AnyType>) : AnyFunction(name, desiredArgsTypes)
+
+class UntypedAsyncFunctionComponent(
+    name: String,
+    desiredArgsTypes: Array<AnyType>,
+    internal val body: (args: Array<out Any?>) -> Any?,
+) : AsyncFunctionComponent(name, desiredArgsTypes)
+
+class AsyncFunctionWithPromiseComponent(
+    name: String,
+    desiredArgsTypes: Array<AnyType>,
+    internal val body: (args: Array<out Any?>, promise: Promise) -> Unit,
+) : AsyncFunctionComponent(name, desiredArgsTypes)
+
+class SuspendFunctionComponent(
+    name: String,
+    desiredArgsTypes: Array<AnyType>,
+    internal val body: suspend CoroutineScope.(args: Array<out Any?>) -> Any?,
+) : AsyncFunctionComponent(name, desiredArgsTypes)
+
+@PublishedApi
+internal fun createAsyncFunctionComponent(
+    name: String,
+    desiredArgsTypes: Array<AnyType>,
+    body: (args: Array<out Any?>) -> Any?,
+): AsyncFunctionComponent = UntypedAsyncFunctionComponent(name, desiredArgsTypes, body)
+
+class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
+    @PublishedApi internal var component: AsyncFunctionComponent? = null
+
+    fun build(): AsyncFunctionComponent = requireNotNull(component) { "AsyncFunction '$name' has no body" }
+}
+
+inline infix fun <reified R> AsyncFunctionBuilder.Coroutine(crossinline body: suspend () -> R): AsyncFunctionComponent =
+    SuspendFunctionComponent(name, emptyArray()) { body() }.also { component = it }
+
+inline infix fun <reified R, reified P0> AsyncFunctionBuilder.Coroutine(crossinline body: suspend (p0: P0) -> R): AsyncFunctionComponent =
+    SuspendFunctionComponent(name, arrayOf(toAnyType<P0>())) { body(it[0] as P0) }.also { component = it }
+
+inline infix fun <reified R, reified P0, reified P1> AsyncFunctionBuilder.Coroutine(crossinline body: suspend (p0: P0, p1: P1) -> R): AsyncFunctionComponent =
+    SuspendFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>())) { body(it[0] as P0, it[1] as P1) }.also { component = it }
+
+inline infix fun <reified R, reified P0, reified P1, reified P2> AsyncFunctionBuilder.Coroutine(crossinline body: suspend (p0: P0, p1: P1, p2: P2) -> R): AsyncFunctionComponent =
+    SuspendFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }.also { component = it }
+
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3> AsyncFunctionBuilder.Coroutine(crossinline body: suspend (p0: P0, p1: P1, p2: P2, p3: P3) -> R): AsyncFunctionComponent =
+    SuspendFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }.also { component = it }
+
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> AsyncFunctionBuilder.Coroutine(crossinline body: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R): AsyncFunctionComponent =
+    SuspendFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }.also { component = it }
+
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> AsyncFunctionBuilder.Coroutine(crossinline body: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R): AsyncFunctionComponent =
+    SuspendFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }.also { component = it }
+
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> AsyncFunctionBuilder.Coroutine(crossinline body: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R): AsyncFunctionComponent =
+    SuspendFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>(), toAnyType<P6>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }.also { component = it }
+
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> AsyncFunctionBuilder.Coroutine(crossinline body: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R): AsyncFunctionComponent =
+    SuspendFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>(), toAnyType<P6>(), toAnyType<P7>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }.also { component = it }

package/kotlin/ExpoSources/expo/modules/kotlin/jni/JavaScriptTypedArray.kt

@@ -0,0 +1,81 @@
+package expo.modules.kotlin.jni
+
+import expo.modules.kotlin.typedarray.TypedArray
+
+enum class TypedArrayKind(val value: Int) {
+    Int8Array(1),
+    Int16Array(2),
+    Int32Array(3),
+    Uint8Array(4),
+    Uint8ClampedArray(5),
+    Uint16Array(6),
+    Uint32Array(7),
+    Float32Array(8),
+    Float64Array(9),
+    BigInt64Array(10),
+    BigUint64Array(11),
+}
+
+// a JavaScript typed array as the wire hands it over: a copy of its bytes,
+// little endian as every engine Peach runs on. a write marks it dirty, and a
+// synchronous call's writes are copied back into the caller's array when the
+// call returns (PeachExpoRuntime).
+class JavaScriptTypedArray internal constructor(
+    override val kind: TypedArrayKind,
+    internal val bytes: ByteArray,
+    // its position among the request's typed arrays, or -1 for a native one
+    internal val ordinal: Int,
+    override val byteOffset: Int,
+) : TypedArray {
+    internal var dirty = false
+
+    override val length: Int get() = bytes.size / elementSize(kind)
+    override val byteLength: Int get() = bytes.size
+
+    override fun read(buffer: ByteArray, position: Int, size: Int) {
+        bytes.copyInto(buffer, 0, position, position + size)
+    }
+
+    override fun write(buffer: ByteArray, position: Int, size: Int) {
+        buffer.copyInto(bytes, position, 0, size)
+        dirty = true
+    }
+
+    private fun unsigned(position: Int): Long = bytes[position].toLong() and 0xff
+
+    private fun readBits(position: Int, size: Int): Long {
+        if (position < 0 || position + size > bytes.size) throw IndexOutOfBoundsException()
+        var bits = 0L
+        for (index in size - 1 downTo 0) bits = (bits shl 8) or unsigned(position + index)
+        return bits
+    }
+
+    private fun writeBits(position: Int, size: Int, bits: Long) {
+        if (position < 0 || position + size > bytes.size) throw IndexOutOfBoundsException()
+        for (index in 0 until size) bytes[position + index] = (bits ushr (8 * index)).toByte()
+        dirty = true
+    }
+
+    override fun readByte(position: Int): Byte = readBits(position, 1).toByte()
+    override fun read2Byte(position: Int): Short = readBits(position, 2).toShort()
+    override fun read4Byte(position: Int): Int = readBits(position, 4).toInt()
+    override fun read8Byte(position: Int): Long = readBits(position, 8)
+    override fun readFloat(position: Int): Float = Float.fromBits(read4Byte(position))
+    override fun readDouble(position: Int): Double = Double.fromBits(read8Byte(position))
+
+    override fun writeByte(position: Int, value: Byte) = writeBits(position, 1, value.toLong())
+    override fun write2Byte(position: Int, value: Short) = writeBits(position, 2, value.toLong())
+    override fun write4Byte(position: Int, value: Int) = writeBits(position, 4, value.toLong())
+    override fun write8Byte(position: Int, value: Long) = writeBits(position, 8, value)
+    override fun writeFloat(position: Int, value: Float) = write4Byte(position, value.toRawBits())
+    override fun writeDouble(position: Int, value: Double) = write8Byte(position, value.toRawBits())
+
+    internal companion object {
+        fun elementSize(kind: TypedArrayKind): Int = when (kind) {
+            TypedArrayKind.Int8Array, TypedArrayKind.Uint8Array, TypedArrayKind.Uint8ClampedArray -> 1
+            TypedArrayKind.Int16Array, TypedArrayKind.Uint16Array -> 2
+            TypedArrayKind.Int32Array, TypedArrayKind.Uint32Array, TypedArrayKind.Float32Array -> 4
+            TypedArrayKind.Float64Array, TypedArrayKind.BigInt64Array, TypedArrayKind.BigUint64Array -> 8
+        }
+    }
+}

package/kotlin/ExpoSources/expo/modules/kotlin/modules/Module.kt

@@ -0,0 +1,98 @@
+package expo.modules.kotlin.modules
+
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.AppContextProvider
+import expo.modules.kotlin.classcomponent.ClassComponentBuilder
+import expo.modules.kotlin.classcomponent.ClassDefinitionData
+import expo.modules.kotlin.objects.ObjectDefinitionBuilder
+import expo.modules.kotlin.objects.ObjectDefinitionData
+import expo.modules.kotlin.sharedobjects.SharedObject
+import expo.modules.kotlin.views.ExpoView
+import expo.modules.kotlin.views.ViewDefinitionBuilder
+import expo.modules.kotlin.views.ViewManagerDefinition
+import kotlin.reflect.KClass
+import kotlin.reflect.typeOf
+
+abstract class Module : AppContextProvider {
+    internal var context: AppContext? = null
+    // the runtime's emitter for this module, set when the module is created
+    internal var emitter: ((name: String, body: Map<String, Any?>?) -> Unit)? = null
+
+    override val appContext: AppContext
+        get() = requireNotNull(context) {
+            "You attempted to access the app context before the module was created. " +
+                "Defer accessing the context until after the module initializes."
+        }
+
+    fun sendEvent(name: String, body: Map<String, Any?>? = emptyMap()) {
+        emitter?.invoke(name, body)
+    }
+
+    abstract fun definition(): ModuleDefinitionData
+}
+
+inline fun Module.ModuleDefinition(crossinline block: ModuleDefinitionBuilder.() -> Unit): ModuleDefinitionData =
+    ModuleDefinitionBuilder(this).also(block).buildModule()
+
+class ModuleDefinitionData(
+    val name: String,
+    val objectDefinition: ObjectDefinitionData,
+    internal val onCreate: List<() -> Unit>,
+    internal val onDestroy: List<() -> Unit>,
+    internal val classData: List<ClassDefinitionData>,
+    internal val views: List<ViewManagerDefinition>,
+)
+
+class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null) : ObjectDefinitionBuilder() {
+    private var name: String? = null
+    @PublishedApi internal val onCreate = mutableListOf<() -> Unit>()
+    @PublishedApi internal val onDestroy = mutableListOf<() -> Unit>()
+    @PublishedApi internal val classData = mutableListOf<ClassDefinitionData>()
+    @PublishedApi internal val views = mutableListOf<ViewManagerDefinition>()
+
+    fun buildModule(): ModuleDefinitionData {
+        val moduleName = name ?: module?.let { it::class.simpleName }
+        return ModuleDefinitionData(requireNotNull(moduleName), buildObject(), onCreate, onDestroy, classData, views)
+    }
+
+    // a compose view also takes its props class's MutableState props, which
+    // upstream unwraps by reflection and the host's generated table names here
+    inline fun <reified T : ExpoView> View(viewClass: KClass<T>, body: ViewDefinitionBuilder<T>.() -> Unit = {}) {
+        val view = dev.peach.expo.PeachExpoTypes.viewType(viewClass)
+        val builder = ViewDefinitionBuilder(viewClass, typeOf<T>())
+        for (prop in view.props) builder.props[prop.name] = prop
+        body(builder)
+        views.add(builder.build(view.create))
+    }
+
+    fun Name(name: String) {
+        this.name = name
+    }
+
+    inline fun OnCreate(crossinline body: () -> Unit) {
+        onCreate.add { body() }
+    }
+
+    inline fun OnDestroy(crossinline body: () -> Unit) {
+        onDestroy.add { body() }
+    }
+
+    inline fun Class(name: String, body: ClassComponentBuilder<Unit>.() -> Unit = {}) {
+        classData.add(ClassComponentBuilder(name, Unit::class, typeOf<Unit>()).also(body).buildClass())
+    }
+
+    inline fun <reified SharedObjectType : SharedObject> Class(
+        name: String,
+        sharedObjectClass: KClass<SharedObjectType> = SharedObjectType::class,
+        body: ClassComponentBuilder<SharedObjectType>.() -> Unit = {},
+    ) {
+        classData.add(ClassComponentBuilder(name, sharedObjectClass, typeOf<SharedObjectType>()).also(body).buildClass())
+    }
+
+    inline fun <reified SharedObjectType : SharedObject> Class(
+        sharedObjectClass: KClass<SharedObjectType> = SharedObjectType::class,
+        body: ClassComponentBuilder<SharedObjectType>.() -> Unit = {},
+    ) {
+        Class(requireNotNull(sharedObjectClass.simpleName), sharedObjectClass, body)
+    }
+}

package/kotlin/ExpoSources/expo/modules/kotlin/objects/ObjectDefinitionBuilder.kt

@@ -0,0 +1,236 @@
+@file:Suppress("FunctionName", "UNCHECKED_CAST")
+
+package expo.modules.kotlin.objects
+
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.functions.AsyncFunctionBuilder
+import expo.modules.kotlin.functions.AsyncFunctionComponent
+import expo.modules.kotlin.functions.AsyncFunctionWithPromiseComponent
+import expo.modules.kotlin.functions.SyncFunctionComponent
+import expo.modules.kotlin.functions.createAsyncFunctionComponent
+import expo.modules.kotlin.types.AnyType
+import expo.modules.kotlin.types.anyTypeOf
+import expo.modules.kotlin.types.toAnyType
+import kotlin.reflect.KType
+
+// generated arities 0 to 8, as upstream's ObjectDefinitionBuilder declares
+
+class ObjectDefinitionData(
+    internal val legacyConstantsProvider: () -> Map<String, Any?>,
+    internal val syncFunctions: Map<String, SyncFunctionComponent>,
+    internal val asyncFunctions: Map<String, AsyncFunctionComponent>,
+    internal val eventNames: List<String>,
+    internal val properties: Map<String, PropertyComponentBuilder>,
+    internal val constants: Map<String, ConstantComponentBuilder>,
+)
+
+class EventObservingDefinition(internal val start: Boolean, internal val event: String?, internal val body: () -> Unit)
+
+open class ObjectDefinitionBuilder {
+    private var legacyConstantsProvider = { emptyMap<String, Any?>() }
+    @PublishedApi internal var eventNames = listOf<String>()
+    @PublishedApi internal val syncFunctions = mutableMapOf<String, SyncFunctionComponent>()
+    @PublishedApi internal val asyncFunctions = mutableMapOf<String, AsyncFunctionComponent>()
+    @PublishedApi internal val asyncFunctionBuilders = mutableMapOf<String, AsyncFunctionBuilder>()
+    @PublishedApi internal val properties = mutableMapOf<String, PropertyComponentBuilder>()
+    @PublishedApi internal val constants = mutableMapOf<String, ConstantComponentBuilder>()
+    private val eventObservers = mutableListOf<EventObservingDefinition>()
+
+    fun buildObject(): ObjectDefinitionData {
+        // android exports startObserving and stopObserving unless the module
+        // defines functions with those names
+        for ((start, name) in listOf(true to "startObserving", false to "stopObserving")) {
+            if (!asyncFunctions.containsKey(name) && !asyncFunctionBuilders.containsKey(name)) {
+                AsyncFunction(name) { eventName: String ->
+                    for (observer in eventObservers) {
+                        if (observer.start == start && (observer.event == null || observer.event == eventName)) observer.body()
+                    }
+                }
+            }
+        }
+        return ObjectDefinitionData(
+            legacyConstantsProvider,
+            syncFunctions.toMap(),
+            asyncFunctions + asyncFunctionBuilders.mapValues { (_, builder) -> builder.build() },
+            eventNames,
+            properties.toMap(),
+            constants.toMap(),
+        )
+    }
+
+    @Deprecated("Use `Constant` or `Property` instead")
+    fun Constants(legacyConstantsProvider: () -> Map<String, Any?>) {
+        this.legacyConstantsProvider = legacyConstantsProvider
+    }
+
+    @Deprecated("Use `Constant` or `Property` instead")
+    fun Constants(vararg constants: Pair<String, Any?>) {
+        legacyConstantsProvider = { constants.toMap() }
+    }
+
+    fun Events(vararg events: String) {
+        eventNames = events.toList()
+    }
+
+    fun Events(events: Array<String>) {
+        eventNames = events.toList()
+    }
+
+    fun OnStartObserving(eventName: String, body: () -> Unit) {
+        eventObservers.add(EventObservingDefinition(true, eventName, body))
+    }
+
+    fun OnStartObserving(body: () -> Unit) {
+        eventObservers.add(EventObservingDefinition(true, null, body))
+    }
+
+    fun OnStopObserving(eventName: String, body: () -> Unit) {
+        eventObservers.add(EventObservingDefinition(false, eventName, body))
+    }
+
+    fun OnStopObserving(body: () -> Unit) {
+        eventObservers.add(EventObservingDefinition(false, null, body))
+    }
+
+    open fun Property(name: String): PropertyComponentBuilder =
+        PropertyComponentBuilder(name).also { properties[name] = it }
+
+    inline fun <reified T> Property(name: String, crossinline body: () -> T): PropertyComponentBuilder =
+        PropertyComponentBuilder(name).also {
+            it.get(body)
+            properties[name] = it
+        }
+
+    open fun Constant(name: String): ConstantComponentBuilder =
+        ConstantComponentBuilder(name).also { constants[name] = it }
+
+    inline fun <reified T> Constant(name: String, crossinline body: () -> T): ConstantComponentBuilder =
+        ConstantComponentBuilder(name).also {
+            it.get(body)
+            constants[name] = it
+        }
+
+    fun AsyncFunction(name: String) = AsyncFunctionBuilder(name).also { asyncFunctionBuilders[name] = it }
+
+    inline fun Function(name: String, crossinline body: () -> Any?): SyncFunctionComponent =
+        SyncFunctionComponent(name, emptyArray()) { body() }.also { syncFunctions[name] = it }
+
+    inline fun AsyncFunction(name: String, crossinline body: () -> Any?): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, emptyArray()) { body() }.also { asyncFunctions[name] = it }
+
+    inline fun <R> Function(name: String, crossinline body: () -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, emptyArray()) { body() }.also { syncFunctions[name] = it }
+
+    inline fun <R> AsyncFunction(name: String, crossinline body: () -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, emptyArray()) { body() }.also { asyncFunctions[name] = it }
+
+    inline fun <R, reified P0> Function(name: String, crossinline body: (p0: P0) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>())) { body(it[0] as P0) }.also { syncFunctions[name] = it }
+
+    // one Promise argument is the promise itself, as upstream decides by class
+    inline fun <R, reified P0> AsyncFunction(name: String, crossinline body: (p0: P0) -> R): AsyncFunctionComponent =
+        if (P0::class == Promise::class) {
+            AsyncFunctionWithPromiseComponent(name, emptyArray()) { _, promise -> body(promise as P0) }
+        } else {
+            createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>())) { body(it[0] as P0) }
+        }.also { asyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1> Function(name: String, crossinline body: (p0: P0, p1: P1) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>())) { body(it[0] as P0, it[1] as P1) }.also { syncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1> AsyncFunction(name: String, crossinline body: (p0: P0, p1: P1) -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>())) { body(it[0] as P0, it[1] as P1) }.also { asyncFunctions[name] = it }
+
+    inline fun <R, reified P0> AsyncFunction(name: String, crossinline body: (p0: P0, promise: Promise) -> R): AsyncFunctionComponent =
+        AsyncFunctionWithPromiseComponent(name, arrayOf(toAnyType<P0>())) { it, promise -> body(it[0] as P0, promise) }.also { asyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2> Function(name: String, crossinline body: (p0: P0, p1: P1, p2: P2) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }.also { syncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2> AsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2) -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }.also { asyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1> AsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, promise: Promise) -> R): AsyncFunctionComponent =
+        AsyncFunctionWithPromiseComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>())) { it, promise -> body(it[0] as P0, it[1] as P1, promise) }.also { asyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3> Function(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }.also { syncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3> AsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }.also { asyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2> AsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, promise: Promise) -> R): AsyncFunctionComponent =
+        AsyncFunctionWithPromiseComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>())) { it, promise -> body(it[0] as P0, it[1] as P1, it[2] as P2, promise) }.also { asyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4> Function(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }.also { syncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4> AsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }.also { asyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3> AsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, promise: Promise) -> R): AsyncFunctionComponent =
+        AsyncFunctionWithPromiseComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>())) { it, promise -> body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, promise) }.also { asyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> Function(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }.also { syncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> AsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }.also { asyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4> AsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, promise: Promise) -> R): AsyncFunctionComponent =
+        AsyncFunctionWithPromiseComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>())) { it, promise -> body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, promise) }.also { asyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> Function(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>(), toAnyType<P6>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }.also { syncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> AsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>(), toAnyType<P6>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }.also { asyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> AsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, promise: Promise) -> R): AsyncFunctionComponent =
+        AsyncFunctionWithPromiseComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>())) { it, promise -> body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, promise) }.also { asyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> Function(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>(), toAnyType<P6>(), toAnyType<P7>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }.also { syncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> AsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>(), toAnyType<P6>(), toAnyType<P7>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }.also { asyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> AsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, promise: Promise) -> R): AsyncFunctionComponent =
+        AsyncFunctionWithPromiseComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>(), toAnyType<P6>())) { it, promise -> body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, promise) }.also { asyncFunctions[name] = it }
+}
+
+
+open class PropertyComponentBuilder(val name: String) {
+    var getter: SyncFunctionComponent? = null
+    var setter: SyncFunctionComponent? = null
+
+    inline fun <R> get(crossinline body: () -> R) = apply {
+        getter = SyncFunctionComponent("get", emptyArray()) { body() }
+    }
+
+    inline fun <reified T> set(crossinline body: (newValue: T) -> Unit) = apply {
+        setter = SyncFunctionComponent("set", arrayOf(toAnyType<T>())) { body(it[0] as T) }
+    }
+}
+
+// a class property whose getter and setter take the caller
+class PropertyComponentBuilderWithThis<ThisType>(@PublishedApi internal val thisType: KType, name: String) : PropertyComponentBuilder(name) {
+    inline fun <R> get(crossinline body: (ThisType) -> R) = apply {
+        getter = SyncFunctionComponent("get", arrayOf(anyTypeOf(thisType))) { body(it[0] as ThisType) }
+    }
+
+    inline fun <reified T> set(crossinline body: (self: ThisType, newValue: T) -> Unit) = apply {
+        setter = SyncFunctionComponent("set", arrayOf(anyTypeOf(thisType), toAnyType<T>())) { body(it[0] as ThisType, it[1] as T) }
+    }
+}
+
+// a constant's getter runs once, on its first read
+class ConstantComponentBuilder(val name: String) {
+    var getter: SyncFunctionComponent? = null
+    internal var value: Any? = null
+    internal var evaluated = false
+
+    inline fun <R> get(crossinline body: () -> R) = apply {
+        getter = SyncFunctionComponent("get", emptyArray()) { body() }
+    }
+}

package/kotlin/ExpoSources/expo/modules/kotlin/records/Record.kt

@@ -0,0 +1,12 @@
+package expo.modules.kotlin.records
+
+// For supported field types, see https://docs.expo.dev/modules/module-api/#argument-types
+interface Record
+
+@Target(AnnotationTarget.PROPERTY)
+@Retention(AnnotationRetention.RUNTIME)
+annotation class Field(val key: String = "")
+
+@Target(AnnotationTarget.PROPERTY)
+@Retention(AnnotationRetention.RUNTIME)
+annotation class Required

package/kotlin/ExpoSources/expo/modules/kotlin/runtime/Runtime.kt

@@ -0,0 +1,9 @@
+package expo.modules.kotlin.runtime
+
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.sharedobjects.SharedObjectRegistry
+
+// the one JavaScript runtime a Kotlin/Wasm process answers
+class Runtime internal constructor(val appContext: AppContext) {
+    internal val sharedObjectRegistry = SharedObjectRegistry()
+}

package/kotlin/ExpoSources/expo/modules/kotlin/sharedobjects/SharedObject.kt

@@ -0,0 +1,50 @@
+package expo.modules.kotlin.sharedobjects
+
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.runtime.Runtime
+
+open class SharedObject(runtime: Runtime? = null) {
+    constructor(appContext: AppContext) : this(appContext.runtime)
+
+    // the id of the JavaScript object this one maps to, or 0 when unlinked
+    internal var sharedObjectId: SharedObjectId = SharedObjectId(0)
+
+    internal var runtime: Runtime? = runtime
+
+    val appContext: AppContext?
+        get() = runtime?.appContext
+
+    fun emit(event: String) {
+        emitInternal(event, emptyArray())
+    }
+
+    fun emit(event: String, payload: Any?) {
+        emitInternal(event, arrayOf(payload))
+    }
+
+    @Deprecated(
+        "Multi-argument event emission is deprecated. Use `emit(event)` or `emit(event, payload)` and pass a single payload (typically a Map/Bundle) instead.",
+        ReplaceWith("emit(event, args)"),
+    )
+    fun emit(event: String, vararg args: Any?) {
+        emitInternal(event, args)
+    }
+
+    private fun emitInternal(event: String, payload: Array<out Any?>) {
+        if (sharedObjectId.value == 0) return
+        val registry = runtime?.sharedObjectRegistry ?: return
+        registry.emit(this, event, payload.toList())
+    }
+
+    open fun onStartListeningToEvent(eventName: String) = Unit
+
+    open fun onStopListeningToEvent(eventName: String) = Unit
+
+    @Suppress("DEPRECATION")
+    open fun sharedObjectDidRelease() = deallocate()
+
+    @Deprecated("Use sharedObjectDidRelease() instead.", ReplaceWith("sharedObjectDidRelease()"))
+    open fun deallocate() = Unit
+
+    open fun getAdditionalMemoryPressure(): Int = 0
+}