peachsim 0.1.1406 → 0.1.1463

package/kotlin/ExpoSources/dev/peach/expo/PeachExpoTypes.kt

@@ -3,6 +3,7 @@
 package dev.peach.expo
 
 import android.content.Context
+import android.view.View
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.exception.CodedException
 import expo.modules.kotlin.exception.EnumNoSuchValueException
@@ -13,7 +14,6 @@ import expo.modules.kotlin.exception.exceptionDecorator
 import expo.modules.kotlin.types.AnyType
 import expo.modules.kotlin.types.TypeCastException
 import expo.modules.kotlin.views.AnyViewProp
-import expo.modules.kotlin.views.ExpoView
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
 import kotlin.reflect.typeOf
@@ -38,9 +38,9 @@ object PeachExpoTypes {
 
     private class Frame(val type: KClass<*>?, val name: String, val values: Map<*, *>?)
 
-    class ViewType(val create: (Context, AppContext) -> ExpoView, val props: List<AnyViewProp>)
+    class ViewType(val create: (Context, AppContext) -> View, val props: List<AnyViewProp>)
 
-    private class ViewClass(val props: KClass<*>?, val create: (Context, AppContext) -> ExpoView)
+    private class ViewClass(val props: KClass<*>?, val create: (Context, AppContext) -> View)
 
     private val views = HashMap<KClass<*>, ViewClass>()
     private val composeProps = HashMap<KClass<*>, List<AnyViewProp>>()
@@ -49,7 +49,7 @@ object PeachExpoTypes {
     // records under construction; a frame with no values builds defaults
     private val frames = ArrayList<Frame>()
 
-    fun <V : ExpoView> view(type: KClass<V>, props: KClass<*>?, create: (Context, AppContext) -> V) {
+    fun <V : View> view(type: KClass<V>, props: KClass<*>?, create: (Context, AppContext) -> V) {
         views[type] = ViewClass(props, create)
     }
 

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

@@ -1,5 +1,6 @@
 package expo.modules.kotlin.modules
 
+import android.view.View
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.AppContextProvider
 import expo.modules.kotlin.classcomponent.ClassComponentBuilder
@@ -7,7 +8,6 @@ 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
@@ -57,7 +57,7 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
 
     // 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 = {}) {
+    inline fun <reified T : View> 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

package/kotlin/ExpoSources/expo/modules/kotlin/viewevent/ViewEvent.kt

@@ -1,7 +1,7 @@
 package expo.modules.kotlin.viewevent
 
 import android.util.Log
-import expo.modules.kotlin.views.ExpoView
+import android.view.View
 import kotlin.reflect.KProperty
 
 typealias CoalescingKey<T> = (event: T) -> Short
@@ -14,14 +14,14 @@ fun interface ViewEventCallback<T> {
 // reaches JavaScript as { payload }, as convertEventBody wraps it
 open class ViewEvent<T>(
     private val name: String,
-    private val view: ExpoView,
+    private val view: View,
     private val coalescingKey: CoalescingKey<T>?,
 ) : ViewEventCallback<T> {
     private var isValidated = false
 
     override operator fun invoke(arg: T) {
         if (!isValidated) {
-            if (name !in view.callbacks) {
+            if (name !in ViewEventRegistry.callbacks(view)) {
                 Log.w("ExpoModulesCore", "⚠️ Event $name wasn't exported from ${view::class}")
                 return
             }
@@ -32,23 +32,37 @@ open class ViewEvent<T>(
             is Map<*, *> -> arg
             else -> mapOf("payload" to arg)
         }
-        view.emitter?.invoke(name, body)
+        ViewEventRegistry.emit(view, name, body)
     }
 }
 
-class ViewEventDelegate<T>(private val view: ExpoView, private val coalescingKey: CoalescingKey<T>?) {
+class ViewEventDelegate<T>(private val view: View, private val coalescingKey: CoalescingKey<T>?) {
     fun getValue(property: KProperty<*>): ViewEventCallback<T> = ViewEvent(property.name, view, coalescingKey)
 
-    operator fun getValue(thisRef: ExpoView, property: KProperty<*>): ViewEventCallback<T> = getValue(property)
+    operator fun getValue(thisRef: View, property: KProperty<*>): ViewEventCallback<T> = getValue(property)
 }
 
 @Suppress("NOTHING_TO_INLINE")
 inline operator fun <T> ViewEventDelegate<T>.getValue(thisObj: Any?, property: KProperty<*>): ViewEventCallback<T> = getValue(property)
 
 @Suppress("FunctionName")
-inline fun <reified T> ExpoView.EventDispatcher(noinline coalescingKey: CoalescingKey<T>? = null): ViewEventDelegate<T> =
+inline fun <reified T> View.EventDispatcher(noinline coalescingKey: CoalescingKey<T>? = null): ViewEventDelegate<T> =
     ViewEventDelegate(this, coalescingKey)
 
 @Suppress("FunctionName")
-fun ExpoView.EventDispatcher(coalescingKey: CoalescingKey<Map<String, Any>>? = null): ViewEventDelegate<Map<String, Any>> =
+fun View.EventDispatcher(coalescingKey: CoalescingKey<Map<String, Any>>? = null): ViewEventDelegate<Map<String, Any>> =
     ViewEventDelegate(this, coalescingKey)
+
+// the runtime binds every Android view, including views outside the ExpoView hierarchy.
+internal object ViewEventRegistry {
+    private class Binding(val callbacks: List<String>, val emit: (String, Any?) -> Unit)
+    private val bindings = HashMap<View, Binding>()
+
+    fun bind(view: View, callbacks: List<String>, emit: (String, Any?) -> Unit) {
+        bindings[view] = Binding(callbacks, emit)
+    }
+
+    fun unbind(view: View) { bindings.remove(view) }
+    fun callbacks(view: View): List<String> = bindings[view]?.callbacks ?: emptyList()
+    fun emit(view: View, name: String, body: Any?) { bindings[view]?.emit?.invoke(name, body) }
+}

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

@@ -17,7 +17,4 @@ abstract class ExpoView(context: Context, val appContext: AppContext) : LinearLa
         canvas.restoreToCount(checkpoint)
     }
 
-    // the runtime's sink for this view's events, set when the view is created
-    internal var emitter: ((name: String, body: Any?) -> Unit)? = null
-    internal var callbacks: List<String> = emptyList()
 }

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

@@ -3,6 +3,7 @@
 package expo.modules.kotlin.views
 
 import android.content.Context
+import android.view.View
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.functions.AsyncFunctionComponent
 import expo.modules.kotlin.objects.ObjectDefinitionBuilder
@@ -13,26 +14,26 @@ import kotlin.reflect.KType
 class ViewManagerDefinition(
     val name: String,
     internal val viewClass: KClass<*>,
-    internal val createView: (Context, AppContext) -> ExpoView,
+    internal val createView: (Context, AppContext) -> View,
     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)?,
+    internal val onViewDestroys: ((View) -> Unit)?,
+    internal val onViewDidUpdateProps: ((View) -> 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>(
+class ViewDefinitionBuilder<T : View>(
     @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
+    @PublishedApi internal var onViewDestroys: ((View) -> Unit)? = null
+    @PublishedApi internal var onViewDidUpdateProps: ((View) -> Unit)? = null
 
-    fun build(createView: (Context, AppContext) -> ExpoView): ViewManagerDefinition {
+    fun build(createView: (Context, AppContext) -> View): ViewManagerDefinition {
         val functions = asyncFunctions + asyncFunctionBuilders.mapValues { (_, builder) -> builder.build() }
         for (function in functions.values) {
             function.ownerType = viewType
@@ -56,13 +57,13 @@ class ViewDefinitionBuilder<T : ExpoView>(
     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(
+    inline fun <reified ViewType : View, 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(
+    inline fun <reified ViewType : View, reified PropType> Prop(
         name: String,
         defaultValue: PropType,
         noinline body: (view: ViewType, prop: PropType) -> Unit,

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

@@ -2,33 +2,34 @@
 
 package expo.modules.kotlin.views
 
+import android.view.View
 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)
+    abstract fun set(prop: Any?, onView: View)
 }
 
-open class ConcreteViewProp<ViewType : ExpoView, PropType>(
+open class ConcreteViewProp<ViewType : View, PropType>(
     name: String,
     propType: AnyType,
     protected val setter: (view: ViewType, prop: PropType) -> Unit,
 ) : AnyViewProp(name, propType) {
-    override fun set(prop: Any?, onView: ExpoView) {
+    override fun set(prop: Any?, onView: View) {
         exceptionDecorator({ PropSetException(name, onView::class, it) }) {
             setter(onView as ViewType, type.convert(prop) as PropType)
         }
     }
 }
 
-class ConcreteViewPropWithDefault<ViewType : ExpoView, PropType>(
+class ConcreteViewPropWithDefault<ViewType : View, 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) {
+    override fun set(prop: Any?, onView: View) {
         if (prop == null) setter(onView as ViewType, defaultValue)
         else super.set(prop, onView)
     }

package/kotlin/fixtures/import-drawing/Drawing.d.kt.ts

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

package/kotlin/fixtures/import-drawing/Drawing.kt

@@ -0,0 +1,101 @@
+package dev.contrast.kotlindrawing
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectDragGestures
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.lightColorScheme
+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.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun Drawing(title: String, onStep: ((Int) -> Unit)? = null) {
+    var count by remember { mutableStateOf(0) }
+    var taps by remember { mutableStateOf(0) }
+    var moved by remember { mutableStateOf(false) }
+    var transformed by remember { mutableStateOf(false) }
+    val density = LocalDensity.current.density
+    MaterialTheme(colorScheme = lightColorScheme()) {
+        Surface(Modifier.fillMaxSize()) {
+            Column(Modifier.fillMaxSize().padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                Text(title, Modifier.testTag("drawing-title"))
+                Text("Count: $count", Modifier.testTag("drawing-count"))
+                Text("taps=$taps;moved=${if (moved) 1 else 0};transformed=${if (transformed) 1 else 0}", Modifier.testTag("drawing-state"))
+                Box(Modifier.size(240.dp, 144.dp).background(Color(0xFFE8EEF8)).testTag("drawing-stage").semantics { contentDescription = "Drawing stage" }) {
+                    Canvas(
+                        Modifier.size(240.dp, 144.dp).testTag("drawing-canvas").graphicsLayer {
+                            rotationZ = if (transformed) 180f else 0f
+                            scaleX = if (transformed) 0.75f else 1f
+                            scaleY = if (transformed) 0.75f else 1f
+                        },
+                    ) {
+                        drawRect(Color(0xFFFFC107), Offset(16.dp.toPx(), 16.dp.toPx()), Size(64.dp.toPx(), 40.dp.toPx()))
+                        drawCircle(if (taps % 2 == 1) Color(0xFFE91E63) else Color(0xFF673AB7), 20.dp.toPx(), Offset(if (moved) 152.dp.toPx() else 112.dp.toPx(), if (moved) 96.dp.toPx() else 56.dp.toPx()))
+                        val path = Path().apply {
+                            moveTo(184.dp.toPx(), 24.dp.toPx())
+                            lineTo(220.dp.toPx(), 88.dp.toPx())
+                            lineTo(164.dp.toPx(), 112.dp.toPx())
+                            close()
+                        }
+                        drawPath(path, Color(0xFF009688))
+                    }
+                }
+                Box(
+                    Modifier.size(240.dp, 48.dp).background(Color(0xFFD1C4E9)).testTag("drawing-tap").semantics { contentDescription = "Tap drawing" }.pointerInput(Unit) {
+                        detectTapGestures {
+                            taps += 1
+                            count += 1
+                            onStep?.invoke(count)
+                        }
+                    },
+                ) { Text("Tap drawing", Modifier.padding(8.dp)) }
+                Box(
+                    Modifier.size(240.dp, 64.dp).background(Color(0xFFB2DFDB)).testTag("drawing-drag").semantics { contentDescription = "Drag drawing right" }.pointerInput(Unit) {
+                        var horizontal = 0f
+                        detectDragGestures(
+                            onDragStart = { horizontal = 0f },
+                            onDragEnd = {
+                                if (horizontal > 24f * density) {
+                                    moved = true
+                                    count += 1
+                                    onStep?.invoke(count)
+                                }
+                            },
+                        ) { change, amount ->
+                            change.consume()
+                            horizontal += amount.x
+                        }
+                    },
+                ) { Text("Drag drawing right", Modifier.padding(8.dp)) }
+                Button(onClick = { transformed = !transformed; count += 1; onStep?.invoke(count) }, modifier = Modifier.testTag("drawing-transform")) { Text("Transform drawing") }
+                Button(onClick = { count += 1000; onStep?.invoke(count) }, enabled = false, modifier = Modifier.testTag("drawing-disabled")) { Text("Disabled drawing") }
+                Button(onClick = { taps = 0; moved = false; transformed = false; count += 1; onStep?.invoke(count) }, modifier = Modifier.testTag("drawing-reset")) { Text("Reset drawing") }
+            }
+        }
+    }
+}

package/kotlin/fixtures/import-drawing/ImportDrawing.native.tsx

@@ -0,0 +1,18 @@
+import { useState } from 'react'
+import { Text, View, type ViewStyle } from 'react-native'
+import { Drawing } from './Drawing.kt'
+
+export default function Index() {
+  const [step, setStep] = useState(0)
+  const drawingProps = {
+    title: `Drawing step ${step}`,
+    onStep: setStep,
+    style: { width: '100%', height: 680 } satisfies ViewStyle,
+  }
+  return (
+    <View style={{ flex: 1, backgroundColor: '#fff' }}>
+      <Drawing {...drawingProps} />
+      <Text testID="drawing-react-step">React step: {step}</Text>
+    </View>
+  )
+}

package/kotlin/fixtures/import-drawing/README.md

@@ -0,0 +1,34 @@
+# Imported Compose drawing and pointer input
+
+RAN: unchanged Kotlin and React sources pass six real input states in One
+Android, Peach Android, then an actual signed-in Contrast project import.
+The sequence is initial, tap, rightward drag, transform, disabled and reset.
+Compose and React callback counts agree at 0, 1, 2, 3, 3 and 4.
+
+[Immutable three-host receipt](https://r2.sootsim.com/kotlin-evidence/import-drawing/5686486071b1f1f109acbf76b033362e401197f62eed6dee9badf1d1ca4e852f/proof.json) binds the source hashes, installed APK,
+compiled Kotlin artifact, paired runtime, full-density lossless WebP captures,
+trees, probes and eight rejected negative controls. Every uploaded object was
+read back and checked by SHA-256.
+
+Canvas rectangle, circle and path centroids and bounds match native after
+normalization, within one pixel from each capture density. Every active
+transition changes stage pixels. The disabled tap preserves transformed
+pixels and both counters; reset restores initial pixels. `graphicsLayer`
+rotation of 180 degrees and scale of 0.75 move and shrink the drawing.
+`detectTapGestures` and `detectDragGestures` reach Compose through real input.
+
+The live producer now plays the recorded picture at the requested display
+density while keeping native layout and pointer coordinates unchanged.
+Native stage crops are 630x378 at density 2.625; browser crops are 720x432 at
+density 3, captured without resizing. The prior cubic sampling and path-bound
+failure became exact sampling with passing native shape checks.
+
+One canary `2.0.0-0.canary.1791785147152` was verified from all 17 family
+tarballs and 11,723 installed files. Its main adoption, dev/prod compile
+catalog qualification and native runtime 105 delivery remain separate under
+the CI owner. Build Android through the normal remote Linux builder and use
+that adopting One family before re-prebuild.
+
+This receipt covers debug Android API 37 and settled drawing/input behavior.
+It makes no claim about nested scrolling, 3D projection, fonts, full-frame
+pixel fidelity, animation timing, release binaries or production deployment.

package/kotlin/fixtures/import-drawing/app/_layout.tsx

@@ -0,0 +1,4 @@
+import { Slot } from 'one'
+export default function Layout() {
+  return <Slot />
+}

package/kotlin/fixtures/import-drawing/app/index+spa.tsx

@@ -0,0 +1 @@
+export { default } from '../ImportDrawing.native'

package/kotlin/fixtures/import-drawing/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "peach-kotlin-import-drawing-fixture",
+  "private": true,
+  "type": "module",
+  "targets": [
+    "native"
+  ],
+  "dependencies": {
+    "@react-navigation/core": "catalog:",
+    "@react-navigation/native": "catalog:",
+    "one": "catalog:",
+    "react": "catalog:",
+    "react-native": "catalog:",
+    "react-native-reanimated": "catalog:",
+    "react-native-screens": "catalog:",
+    "react-native-worklets": "catalog:"
+  },
+  "devDependencies": {
+    "@react-native-community/template": "catalog:",
+    "peachsim": "workspace:*",
+    "vite": "catalog:"
+  }
+}

package/kotlin/fixtures/import-drawing/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "paths": {
+      "~/*": ["./*"]
+    },
+    "strict": true,
+    "allowArbitraryExtensions": true,
+    "rootDir": ".",
+    "module": "Preserve",
+    // allows react-native style imports without path extensions, for compat with platform-specific files
+    "moduleResolution": "Bundler",
+    "preserveSymlinks": true,
+    "skipLibCheck": true,
+    "jsx": "react-jsx",
+    "noImplicitAny": false,
+    "types": ["node", "react", "vite/client"],
+    "lib": ["dom", "esnext"]
+  },
+  "exclude": ["node_modules", "**/test", "**/dist", "**/types", "**/__tests__"]
+}

package/kotlin/fixtures/import-drawing/vite.config.ts

@@ -0,0 +1,20 @@
+import { one } from 'one/vite'
+import { peachPlugin } from 'peachsim/vite'
+export default {
+  root: import.meta.dirname,
+  plugins: [
+    one({
+      web: { defaultRenderMode: 'spa' },
+      native: {
+        bundler: 'vite',
+        app: {
+          name: 'KotlinDrawing',
+          scheme: 'kotlindrawing',
+          android: { applicationId: 'dev.contrast.kotlindrawing' },
+        },
+      },
+    }),
+    peachPlugin(),
+  ],
+  server: { host: '0.0.0.0' },
+}

package/kotlin/fixtures/import-scroll/ImportNested.native.tsx

@@ -0,0 +1,10 @@
+import { View } from 'react-native'
+import { Nested } from './Nested.kt'
+
+export default function Index() {
+  return (
+    <View style={{ flex: 1 }}>
+      <Nested />
+    </View>
+  )
+}

package/kotlin/fixtures/import-scroll/Nested.d.kt.ts

@@ -0,0 +1,4 @@
+// generated by one typegen; edits will be replaced
+import type { ReactElement } from 'react'
+
+export declare function Nested(props: {}): ReactElement

package/kotlin/fixtures/import-scroll/README.md

@@ -4,6 +4,21 @@ Run One in this fixture, then open its Android bundle in Peach on Pixel 8.
 Build the native Android target on a remote builder. Import the same files in
 Contrast with catalog versions materialized.
 
+Open `/nested` for the shared pure/imported nested-scroll fixture. Its upward
+drag collapses the 160 dp header before moving the vertical column, and a
+horizontal drag moves the row inside that column. The text reports physical
+header, column and row offsets.
+
+RAN, 2026-10-13: One Android API 37, Peach and a signed-in Contrast import
+match `420/0/0`, `0/84/0` and `0/84/504` after the same 24 delivered native
+MotionEvent samples. The [nested functional receipt](https://r2.sootsim.com/kotlin-evidence/import-nested/e7c3e61f0841e5dd99eae4b1a80f692d5eeec8056fee3d0dd48014f05cc55478/proof.json)
+binds the unchanged host, source, APK, compiled artifacts, input history and
+captures. Five saved-data controls reject changed offsets, missing samples,
+wrong engine/source identities and slow-animation settings. These bounded
+drags establish settled state, without fling, presentation timing or pixel
+fidelity. Contrast preview shell appearance and production delivery remain
+outside this receipt.
+
 Tap `scroll-step` to scroll all five containers through their official state
 APIs. The plain containers move to 180 and 80 physical pixels. LazyColumn,
 LazyRow and LazyVerticalGrid move to index/offset pairs 5/8, 4/4 and 8/6.

package/kotlin/fixtures/import-scroll/app/nested+spa.tsx

@@ -0,0 +1 @@
+export { default } from '../ImportNested.native'

package/kotlin/fixtures/import-values/ImportValues.native.tsx

@@ -7,6 +7,31 @@ const input = JSON.stringify({
   metadata: { source: 'One' },
 })
 
+async function processResults() {
+  const results = [
+    await Values.current(),
+    await Values.delayed('changed'),
+    await Values.current(),
+  ]
+  try {
+    await Values.throwing()
+    throw new Error('sync call unexpectedly succeeded')
+  } catch (reason) {
+    if (!String(reason).includes('sync failure')) throw reason
+    results.push('sync rejected')
+  }
+  results.push(await Values.current())
+  try {
+    await Values.delayedThrow()
+    throw new Error('suspended call unexpectedly succeeded')
+  } catch (reason) {
+    if (!String(reason).includes('suspend failure')) throw reason
+    results.push('suspend rejected')
+  }
+  results.push(await Values.delayed('recovered'), await Values.current())
+  return results
+}
+
 export default function Index() {
   const [result, setResult] = useState('running')
   const [error, setError] = useState('')
@@ -21,6 +46,7 @@ export default function Index() {
       Values.nullableList([]),
       Values.nullableMap({ first: [1, null, 3], empty: [] }),
       Values.nullableMap({}),
+      processResults(),
     ])
       .then((values) => setResult(JSON.stringify(values)))
       .catch((reason: unknown) => setError(String(reason)))

package/kotlin/fixtures/import-values/README.md

@@ -3,7 +3,7 @@
 This fixture exercises a real `OneModule` through the same `.kt` import on
 Android and in Peach. Its visible result contains nested map/list round trips,
 nullable strings and collection elements, 14 JSON reads and 17 expected Android
-JSON errors. The nine results include null elements, empty lists, nested nullable
+JSON errors. The ten results include null elements, empty lists, nested nullable
 map values and an empty map, so declaration errors cannot hide behind a scalar
 call that happens to work.
 
@@ -21,3 +21,8 @@ For Contrast, import these project files with their catalog dependency versions
 materialized. Its Android native bundle producer compiles `Values.kt`, publishes
 the generated Wasm and registers the module contract before calling methods.
 A successful bundle alone does not establish runtime acceptance.
+
+The final result checks retained module state across coroutine completion, synchronous
+and suspended rejection, and recovery. Its eight values are `initial`, `changed`,
+`changed`, `sync rejected`, `changed`, `suspend rejected`, `recovered`, `recovered`.
+The fixture asserts settled call behavior; it makes no timing or concurrency claim.

package/kotlin/fixtures/import-values/Values.d.kt.ts

@@ -1,5 +1,9 @@
 // generated by one typegen; edits will be replaced
 export declare const Values: {
+  current(): Promise<string>
+  delayed(value: string): Promise<string>
+  throwing(): Promise<string>
+  delayedThrow(): Promise<string>
   nested(values: Record<string, number[]>): Promise<Record<string, number[]>>
   nullable(value: string | null): Promise<string | null>
   nullableList(values: (string | null)[]): Promise<(string | null)[]>

package/kotlin/fixtures/import-values/Values.kt

@@ -1,11 +1,29 @@
 package dev.contrast.kotlinimports
 
 import dev.onejs.one.source.OneModule
+import kotlinx.coroutines.delay
 import org.json.JSONArray
 import org.json.JSONException
 import org.json.JSONObject
 
 object Values : OneModule {
+    private var processState = "initial"
+
+    fun current(): String = processState
+
+    suspend fun delayed(value: String): String {
+        delay(30)
+        processState = value
+        return processState
+    }
+
+    fun throwing(): String = throw IllegalStateException("sync failure")
+
+    suspend fun delayedThrow(): String {
+        delay(30)
+        throw IllegalArgumentException("suspend failure")
+    }
+
     fun nested(values: Map<String, List<Int>>): Map<String, List<Int>> = values
 
     fun nullable(value: String?): String? = value