peachsim 0.1.648 → 0.1.650

package/kotlin/ComposeSources/PeachComposeHost.kt

@@ -0,0 +1,316 @@
+@file:OptIn(androidx.compose.ui.ExperimentalComposeUiApi::class, androidx.compose.ui.InternalComposeUiApi::class, androidx.compose.ui.text.ExperimentalTextApi::class, kotlin.js.ExperimentalJsExport::class, kotlin.js.ExperimentalWasmJsInterop::class)
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.snapshots.Snapshot
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.asComposeCanvas
+import androidx.compose.ui.input.InputMode
+import androidx.compose.ui.input.InputModeManager
+import androidx.compose.ui.input.pointer.PointerEventType
+import androidx.compose.ui.input.pointer.PointerType
+import androidx.compose.ui.platform.FrameRecomposer
+import androidx.compose.ui.platform.LocalFontFamilyResolver
+import androidx.compose.ui.platform.PlatformArchitectureComponentsOwner
+import androidx.compose.ui.platform.PlatformWindowInsets
+import androidx.compose.ui.platform.PlatformContext
+import androidx.compose.ui.platform.WindowInfo
+import androidx.compose.ui.platform.registerSkikoComposeImplementation
+import androidx.compose.ui.scene.CanvasLayersComposeScene
+import androidx.compose.ui.scene.hasInvalidations
+import androidx.compose.ui.semantics.SemanticsNode
+import androidx.compose.ui.semantics.SemanticsOwner
+import androidx.compose.ui.semantics.SemanticsProperties
+import androidx.compose.ui.semantics.getOrNull
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.text.font.FontSynthesis
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.font.PlatformTypefacesLoader
+import androidx.compose.ui.text.font.createPlatformFontFamilyResolver
+import androidx.compose.ui.text.font.platformTypefacesLoader
+import androidx.compose.ui.text.intl.LocaleList
+import androidx.compose.ui.text.intl.setPlatformLocaleProvider
+import androidx.compose.ui.text.platform.Font
+import androidx.compose.ui.unit.Constraints
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.DpSize
+import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.LayoutDirection
+import dev.onejs.one.OneNativeSourceViewDispatch
+import kotlin.io.encoding.Base64
+import kotlinx.coroutines.Dispatchers
+import org.jetbrains.skia.BackendRenderTarget
+import org.jetbrains.skia.Bitmap
+import org.jetbrains.skia.Color
+import org.jetbrains.skia.ColorAlphaType
+import org.jetbrains.skia.ColorSpace
+import org.jetbrains.skia.ColorType
+import org.jetbrains.skia.DirectContext
+import org.jetbrains.skia.ImageInfo
+import org.jetbrains.skia.Surface
+import org.jetbrains.skia.SurfaceColorFormat
+import org.jetbrains.skia.SurfaceOrigin
+import org.jetbrains.skia.SurfaceProps
+import org.jetbrains.skiko.OS
+import org.jetbrains.skiko.setHostOsProvider
+import org.json.JSONArray
+import org.json.JSONObject
+
+// owners and window insets come from the hosting window: an activity's
+// ComposeView passes the activity and the insets its window delivers; an
+// imported composable keeps the empty defaults.
+internal class PeachComposePlatform(
+    val density: Density,
+    override val localeList: LocaleList,
+    var size: IntSize,
+    owners: PlatformArchitectureComponentsOwner?,
+    insets: PlatformWindowInsets?,
+    base: PlatformContext = PlatformContext.Empty(),
+) : PlatformContext by base, PlatformContext.SemanticsOwnerListener {
+    override val architectureComponentsOwner: PlatformArchitectureComponentsOwner = owners ?: base.architectureComponentsOwner
+    override val windowInsets: PlatformWindowInsets = insets ?: base.windowInsets
+    val owners = mutableSetOf<SemanticsOwner>()
+    override val windowInfo: WindowInfo = object : WindowInfo {
+        override val isWindowFocused: Boolean get() = true
+        override val containerSize: IntSize get() = size
+        override val containerDpSize: DpSize get() = with(density) { DpSize(size.width.toDp(), size.height.toDp()) }
+    }
+    override val inputModeManager: InputModeManager = object : InputModeManager {
+        override var inputMode: InputMode by mutableStateOf(InputMode.Touch)
+        override fun requestInputMode(inputMode: InputMode): Boolean {
+            this.inputMode = inputMode
+            return true
+        }
+    }
+    override val semanticsOwnerListener: PlatformContext.SemanticsOwnerListener get() = this
+    override fun onSemanticsOwnerAppended(semanticsOwner: SemanticsOwner) { owners.add(semanticsOwner) }
+    override fun onSemanticsOwnerRemoved(semanticsOwner: SemanticsOwner) { owners.remove(semanticsOwner) }
+    override fun onSemanticsChange(semanticsOwner: SemanticsOwner) = Unit
+    override fun onLayoutChange(semanticsOwner: SemanticsOwner, semanticsNodeId: Int) = Unit
+}
+
+// android's default and sans-serif families use the same device font bytes as
+// peach's react native renderer. compose owns shaping and all other families.
+@Composable
+internal fun PeachAndroidFonts(roboto: FontFamily, content: @Composable () -> Unit) {
+    val parent = LocalFontFamilyResolver.current
+    val resolver = remember(parent, roboto) {
+        val backend = checkNotNull(parent.platformTypefacesLoader())
+        createPlatformFontFamilyResolver(object : PlatformTypefacesLoader by backend {
+            override val cacheKey: Any get() = this
+            override fun loadPlatformTypes(fontFamily: FontFamily, fontWeight: FontWeight, fontStyle: FontStyle): Any =
+                if (fontFamily == FontFamily.Default || fontFamily == FontFamily.SansSerif)
+                    parent.resolve(roboto, fontWeight, fontStyle, FontSynthesis.All).value
+                else backend.loadPlatformTypes(fontFamily, fontWeight, fontStyle)
+        })
+    }
+    CompositionLocalProvider(LocalFontFamilyResolver provides resolver, content = content)
+}
+
+// one compose scene presented by the tenant canvas. the frame clock runs only
+// while clockRunning answers true, as Android's window recomposer pauses its
+// clock below STARTED.
+internal class PeachComposeMount(
+    density: Float,
+    fontScale: Float,
+    locale: String,
+    private val gpu: Boolean,
+    private val stencilBits: Int,
+    private val fonts: FontFamily,
+    val invalidate: (Boolean) -> Unit,
+    owners: PlatformArchitectureComponentsOwner? = null,
+    insets: PlatformWindowInsets? = null,
+    private val clockRunning: () -> Boolean = { true },
+) : AutoCloseable {
+    var props by mutableStateOf("")
+    var constraints = Constraints()
+        set(value) { if (field != value) { field = value; needsMeasure = true } }
+    private val events = mutableListOf<JSONObject>()
+    private val platform = PeachComposePlatform(Density(density, fontScale), LocaleList(locale), IntSize.Zero, owners, insets)
+    private val recomposer = FrameRecomposer(Dispatchers.Main) { invalidate(false) }
+    private var needsMeasure = true
+    private var measuredSize = IntSize.Zero
+    private val scene = CanvasLayersComposeScene(
+        recomposer, platform.density, LayoutDirection.Ltr, null, platform,
+        invalidateLayout = { needsMeasure = true; invalidate(true) }, invalidateDraw = { invalidate(false) },
+    )
+    private var surface: Surface? = null
+    private var context: DirectContext? = null
+    private var target: BackendRenderTarget? = null
+    private var pixels: Bitmap? = null
+    private var size = IntSize.Zero
+
+    fun setContent(content: @Composable () -> Unit) {
+        try {
+            scene.setContent { PeachAndroidFonts(fonts, content) }
+        } catch (failure: Throwable) {
+            close()
+            throw failure
+        }
+    }
+
+    fun emit(name: String, args: Any?) {
+        events.add(JSONObject().put("name", name).put("args", args))
+        invalidate(false)
+    }
+
+    fun measure(): IntSize {
+        val measured = scene.measureContent(constraints)
+        scene.size = measured
+        platform.size = measured
+        measuredSize = measured
+        needsMeasure = false
+        return measured
+    }
+
+    fun frame(nanos: Long): String {
+        Snapshot.sendApplyNotifications()
+        if (clockRunning()) recomposer.performFrame(nanos)
+        val measured = if (needsMeasure) measure() else measuredSize
+        // a zero-size composition still runs its effects and reports its size;
+        // its backing surface uses one pixel until layout gives it real bounds.
+        val backing = IntSize(measured.width.coerceAtLeast(1), measured.height.coerceAtLeast(1))
+        if (backing != size) {
+            releaseSurface()
+            size = backing
+            platform.size = measured
+            scene.size = measured
+            if (gpu) {
+                context = DirectContext.makeGL()
+                target = BackendRenderTarget.makeGL(size.width, size.height, 1, stencilBits, 0, 0x8058)
+                surface = checkNotNull(Surface.makeFromBackendRenderTarget(
+                    checkNotNull(context), checkNotNull(target), SurfaceOrigin.BOTTOM_LEFT,
+                    SurfaceColorFormat.RGBA_8888, ColorSpace.sRGB, SurfaceProps(),
+                )) { "Skiko GPU surface creation failed" }
+            } else {
+                surface = Surface.makeRasterN32Premul(size.width, size.height)
+                pixels = Bitmap().also { check(it.allocPixels(ImageInfo(size.width, size.height, ColorType.RGBA_8888, ColorAlphaType.PREMUL, ColorSpace.sRGB))) }
+            }
+        }
+        scene.measureAndLayout()
+        val canvas = checkNotNull(surface).canvas
+        canvas.clear(Color.TRANSPARENT)
+        scene.draw(canvas.asComposeCanvas())
+        val reply = JSONObject().put("width", measured.width).put("height", measured.height)
+            .put("pending", recomposer.hasPendingWork() || scene.hasInvalidations())
+            .put("events", JSONArray(events))
+        events.clear()
+        if (gpu) checkNotNull(surface).flushAndSubmit()
+        else {
+            check(checkNotNull(surface).readPixels(checkNotNull(pixels), 0, 0))
+            val map = checkNotNull(checkNotNull(pixels).peekPixels())
+            try { reply.put("pointer", map.addr).put("length", size.width * size.height * 4) }
+            finally { map.close() }
+        }
+        return reply.toString()
+    }
+
+    fun pointer(phase: String, x: Float, y: Float, millis: Long) {
+        if (phase == "cancel") scene.cancelPointerInput()
+        else scene.sendPointerEvent(
+            when (phase) {
+                "press" -> PointerEventType.Press
+                "release" -> PointerEventType.Release
+                "move" -> PointerEventType.Move
+                else -> error("unknown pointer phase $phase")
+            }, Offset(x, y), timeMillis = millis, type = PointerType.Touch,
+        )
+        invalidate(false)
+    }
+
+    fun semantics(): String {
+        val nodes = JSONArray()
+        fun collect(node: SemanticsNode) {
+            val bounds = node.boundsInRoot
+            nodes.put(JSONObject().put("text", node.config.getOrNull(SemanticsProperties.Text)?.joinToString { it.text })
+                .put("tag", node.config.getOrNull(SemanticsProperties.TestTag))
+                .put("left", bounds.left).put("top", bounds.top).put("right", bounds.right).put("bottom", bounds.bottom))
+            node.children.forEach { collect(it) }
+        }
+        platform.owners.forEach { collect(it.unmergedRootSemanticsNode) }
+        return nodes.toString()
+    }
+
+    private fun releaseSurface() {
+        pixels?.close(); pixels = null
+        surface?.close(); surface = null
+        target?.close(); target = null
+        context?.close(); context = null
+    }
+
+    override fun close() {
+        try { scene.close() }
+        finally {
+            try { recomposer.close() }
+            finally { releaseSurface() }
+        }
+    }
+}
+
+internal val mounts = mutableMapOf<Int, PeachComposeMount>()
+private var nextMount = 1
+private var deviceLocale: String? = null
+
+internal fun addMount(mount: PeachComposeMount): Int = nextMount++.also { mounts[it] = mount }
+
+// the process-wide device setup every scene shares: skiko's platform, the
+// host OS and the device locale, fixed for the life of the process.
+internal fun preparePeachDevice(locale: String) {
+    registerSkikoComposeImplementation()
+    if (deviceLocale == null) {
+        setHostOsProvider { OS.Android }
+        val locales = LocaleList(locale)
+        setPlatformLocaleProvider { locales }
+        deviceLocale = locale
+    }
+    require(deviceLocale == locale) { "device locale changes require a new Kotlin process" }
+}
+
+internal fun robotoFamily(regular: String, medium: String, bold: String) = FontFamily(
+    Font("Roboto-400", Base64.decode(regular), FontWeight.Normal),
+    Font("Roboto-500", Base64.decode(medium), FontWeight.Medium),
+    Font("Roboto-700", Base64.decode(bold), FontWeight.Bold),
+)
+
+@JsExport
+fun peachViewMount(source: String, view: String, hash: String, props: String,
+    density: Float, fontScale: Float, locale: String, backend: String, stencilBits: Int,
+    regular: String, medium: String, bold: String, invalidate: (Boolean) -> Unit): String {
+    try {
+        val dispatch = peachViewDispatcher(source)
+        if (dispatch.contractHash != hash) return JSONObject().put("ok", false).put("code", "E_NATIVE_SOURCE_REBUILD")
+            .put("error", "composable source $source changed; rebuild the app").toString()
+        require(backend == "graphite" || backend == "raster")
+        preparePeachDevice(locale)
+        val mount = PeachComposeMount(density, fontScale, locale, backend == "graphite", stencilBits, robotoFamily(regular, medium, bold), invalidate)
+        mount.props = props
+        mount.setContent { dispatch.Content(view, mount.props, mount::emit) }
+        return JSONObject().put("ok", true).put("id", addMount(mount)).toString()
+    } catch (error: Throwable) {
+        return JSONObject().put("ok", false).put("code", "E_NATIVE_SOURCE").put("error", "$source.$view: ${error.message}").toString()
+    }
+}
+
+@JsExport fun peachViewUpdate(id: Int, props: String) { checkNotNull(mounts[id]).props = props }
+@JsExport fun peachViewConstraints(id: Int, minWidth: Int, maxWidth: Int, minHeight: Int, maxHeight: Int) {
+    checkNotNull(mounts[id]).also {
+        it.constraints = Constraints(minWidth, maxWidth, minHeight, maxHeight)
+        it.invalidate(false)
+    }
+}
+@JsExport fun peachViewFrame(id: Int, millis: Double): String = checkNotNull(mounts[id]).frame((millis * 1_000_000).toLong())
+@JsExport fun peachViewPointer(id: Int, phase: String, x: Float, y: Float, millis: Double) = checkNotNull(mounts[id]).pointer(phase, x, y, millis.toLong())
+@JsExport fun peachViewSemantics(id: Int): String = checkNotNull(mounts[id]).semantics()
+@JsExport fun peachViewDispose(id: Int) { mounts.remove(id)?.close() }
+
+@JsExport fun peachViewMeasure(id: Int, minWidth: Int, maxWidth: Int, minHeight: Int, maxHeight: Int): String {
+    val mount = checkNotNull(mounts[id])
+    mount.constraints = Constraints(minWidth, maxWidth, minHeight, maxHeight)
+    val size = mount.measure()
+    return JSONObject().put("width", size.width).put("height", size.height).toString()
+}

package/kotlin/Sources/dev/onejs/one/OneNativeSourceViewDispatch.kt

@@ -0,0 +1,13 @@
+package dev.onejs.one
+
+import androidx.compose.runtime.Composable
+
+// generated per .kt source that declares public @Composable functions: renders
+// one of them from the host's json props. a callback reports its arguments
+// through emit as a json array.
+interface OneNativeSourceViewDispatch {
+    val contractHash: String
+
+    @Composable
+    fun Content(view: String, propsJson: String, emit: (String, String) -> Unit)
+}

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

@@ -207,6 +207,12 @@ class JSONObject() {
         return this
     }
 
+    fun optBoolean(name: String): Boolean = when (val value = opt(name)) {
+        is Boolean -> value
+        is String -> value.equals("true", ignoreCase = true)
+        else -> false
+    }
+
     fun keys(): Iterator<String> = fields.keys.iterator()
 
     internal fun writeTo(out: StringBuilder) {

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

@@ -0,0 +1,16 @@
+// generated by one typegen; edits will be replaced
+export declare const Counter: {
+  read(): Promise<number>
+  increment(): Promise<number>
+  reset(): Promise<number>
+  delayedRead(ms: number): Promise<number>
+}
+
+export declare const CounterEffects: {
+  recordLocale(current: string, composition: string): Promise<void>
+  locales(): Promise<string[]>
+  enter(): Promise<void>
+  dispose(): Promise<void>
+  cancel(): Promise<void>
+  read(): Promise<number[]>
+}

package/kotlin/fixtures/counter/Counter.kt

@@ -24,3 +24,21 @@ object Counter : OneModule {
         return count
     }
 }
+
+// lifecycle counters let the mount probe observe effect cleanup after removal.
+object CounterEffects : OneModule {
+    private var entered = 0
+    private var disposed = 0
+    private var cancelled = 0
+    private var compositionLocale = ""
+    private var currentLocale = ""
+    internal fun recordLocale(current: String, composition: String) {
+        currentLocale = current
+        compositionLocale = composition
+    }
+    fun locales(): List<String> = listOf(currentLocale, compositionLocale)
+    fun enter() { entered += 1 }
+    fun dispose() { disposed += 1 }
+    fun cancel() { cancelled += 1 }
+    fun read(): List<Int> = listOf(entered, disposed, cancelled)
+}

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

@@ -0,0 +1,34 @@
+import { useEffect, useState } from 'react'
+import { Pressable, Text, View } from 'react-native'
+import { CounterEffects } from './Counter.kt'
+import { CounterScreen } from './CounterScreen.kt'
+
+export default function Index() {
+  const [title, setTitle] = useState('Kotlin counter')
+  const [mounted, setMounted] = useState(true)
+  const [callback, setCallback] = useState(0)
+  const [effects, setEffects] = useState<number[]>([])
+  const [locales, setLocales] = useState<string[]>([])
+  useEffect(() => {
+    if (callback > 0) void CounterEffects.locales().then(setLocales)
+  }, [callback])
+  useEffect(() => {
+    if (!mounted) void CounterEffects.read().then(setEffects)
+  }, [mounted])
+  return (
+    <View style={{ flex: 1 }}>
+      {mounted && <CounterScreen title={title} onTap={setCallback} />}
+      <View style={{ position: 'absolute', bottom: 40, left: 24 }}>
+        <Text testID={`callback-${callback}`}>Callback: {callback}</Text>
+        <Text testID={`effects-${effects.join('-')}`}>Effects: {effects.join(',')}</Text>
+        <Text testID={`locales-${locales.join('-')}`}>Locales: {locales.join(',')}</Text>
+        <Pressable testID="edit-title" onPress={() => setTitle('Edited title')}>
+          <Text>Edit title</Text>
+        </Pressable>
+        <Pressable testID="unmount" onPress={() => setMounted(false)}>
+          <Text>Unmount</Text>
+        </Pressable>
+      </View>
+    </View>
+  )
+}

package/kotlin/fixtures/counter/CounterApp.tsx

@@ -0,0 +1,3 @@
+export default function CounterApp() {
+  throw new Error('the imported Kotlin counter fixture requires an Android device')
+}

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

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

package/kotlin/fixtures/counter/CounterScreen.kt

@@ -8,6 +8,12 @@ import androidx.compose.material3.Button
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.SideEffect
+import androidx.compose.ui.platform.LocalLocaleList
+import androidx.compose.ui.text.intl.Locale
+import kotlinx.coroutines.awaitCancellation
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -20,7 +26,16 @@ import androidx.compose.material3.Surface
 import androidx.compose.material3.lightColorScheme
 
 @Composable
-fun CounterScreen() {
+fun CounterScreen(title: String? = null, onTap: ((Int) -> Unit)? = null) {
+    val locales = LocalLocaleList.current
+    SideEffect { CounterEffects.recordLocale(Locale.current.toLanguageTag(), locales.joinToString(",") { it.toLanguageTag() }) }
+    DisposableEffect(Unit) {
+        CounterEffects.enter()
+        onDispose { CounterEffects.dispose() }
+    }
+    LaunchedEffect(Unit) {
+        try { awaitCancellation() } finally { CounterEffects.cancel() }
+    }
     var count by remember { mutableStateOf(Counter.read()) }
     MaterialTheme(colorScheme = lightColorScheme(primary = Color(0xFF6750A4))) {
         Surface(modifier = Modifier.fillMaxSize()) {
@@ -28,10 +43,10 @@ fun CounterScreen() {
                 modifier = Modifier.fillMaxSize().padding(24.dp),
                 verticalArrangement = Arrangement.spacedBy(16.dp),
             ) {
-                Text("Kotlin counter", style = MaterialTheme.typography.headlineSmall)
+                Text(title ?: "Kotlin counter", style = MaterialTheme.typography.headlineSmall)
                 Text("Count: $count", modifier = Modifier.testTag("counter-value"))
                 Button(
-                    onClick = { count = Counter.increment() },
+                    onClick = { count = Counter.increment(); onTap?.invoke(count) },
                     modifier = Modifier.testTag("counter-increment"),
                 ) { Text("Increment") }
             }

package/kotlin/fixtures/counter/app/_layout.tsx

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

package/kotlin/fixtures/counter/app/index+spa.tsx

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

package/kotlin/fixtures/counter/app/routes.d.ts

@@ -0,0 +1,18 @@
+// deno-lint-ignore-file
+/* eslint-disable */
+// biome-ignore: needed import
+import type { OneRouter } from 'one'
+
+declare module 'one' {
+  export namespace OneRouter {
+    export interface __routes<T extends string = string> extends Record<string, unknown> {
+      StaticRoutes:
+        | `/`
+        | `/_sitemap`
+      DynamicRoutes: never
+      DynamicRouteTemplate: never
+      IsTyped: true
+
+    }
+  }
+}

package/kotlin/fixtures/counter/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "peach-kotlin-counter-fixture",
+  "private": true,
+  "type": "module",
+  "dependencies": { "one": "catalog:", "react": "catalog:", "react-native": "catalog:" },
+  "devDependencies": { "peachsim": "workspace:*", "vite": "catalog:" }
+}

package/kotlin/fixtures/counter/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "paths": {
+      "~/*": ["./*"]
+    },
+    "strict": 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/counter/vite.config.ts

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

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

@@ -33,6 +33,9 @@ import androidx.compose.ui.text.font.PlatformTypefacesLoader
 import androidx.compose.ui.text.font.createPlatformFontFamilyResolver
 import androidx.compose.ui.text.font.platformTypefacesLoader
 import androidx.compose.ui.text.intl.LocaleList
+import androidx.compose.ui.text.intl.setPlatformLocaleProvider
+import org.jetbrains.skiko.OS
+import org.jetbrains.skiko.setHostOsProvider
 import androidx.compose.ui.text.platform.Font
 import androidx.compose.ui.unit.Density
 import androidx.compose.ui.unit.DpSize
@@ -85,7 +88,9 @@ private class DeviceScene(locale: String, content: @Composable () -> Unit) : Aut
     private val size = IntSize(1080, 2400)
     private val density = Density(420f / 160f)
     init {
+        setHostOsProvider { OS.Android }
         registerSkikoComposeImplementation()
+        setPlatformLocaleProvider { LocaleList(locale) }
     }
     val context = PeachPlatformContext(size, density, LocaleList(locale))
     private val recomposer = FrameRecomposer(Dispatchers.Unconfined)

package/kotlin/fixtures/kotlin-app/app/build.gradle.kts

@@ -0,0 +1,30 @@
+plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.android")
+    id("org.jetbrains.kotlin.plugin.compose")
+}
+
+android {
+    namespace = "dev.contrast.kotlinapp"
+    compileSdk = 37
+    defaultConfig {
+        applicationId = "dev.contrast.kotlinapp"
+        minSdk = 24
+        targetSdk = 37
+        versionCode = 1
+        versionName = "1"
+    }
+    buildFeatures { compose = true }
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+    kotlinOptions { jvmTarget = "17" }
+}
+
+dependencies {
+    implementation("androidx.activity:activity-compose:1.9.3")
+    implementation("androidx.compose.ui:ui:1.13.0-alpha02")
+    implementation("androidx.compose.foundation:foundation:1.13.0-alpha02")
+    implementation("androidx.compose.material3:material3:1.5.0-alpha27")
+}

package/kotlin/fixtures/kotlin-app/app/src/main/AndroidManifest.xml

@@ -0,0 +1,13 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <application
+        android:name=".ProbeApplication"
+        android:label="Kotlin app"
+        android:theme="@android:style/Theme.Material.Light.NoActionBar">
+        <activity android:name=".MainActivity" android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>