peachsim 0.1.665 → 0.1.667

package/kotlin/ComposeSources/PeachComposeHost.kt

@@ -9,9 +9,13 @@ import androidx.compose.runtime.setValue
 import androidx.compose.runtime.snapshots.Snapshot
 import androidx.compose.ui.LocalSystemTheme
 import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
 import androidx.compose.ui.graphics.asComposeCanvas
 import androidx.compose.ui.input.InputMode
 import androidx.compose.ui.input.InputModeManager
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEvent
+import androidx.compose.ui.input.key.KeyEventType
 import androidx.compose.ui.input.pointer.PointerEventType
 import androidx.compose.ui.input.pointer.PointerType
 import androidx.compose.ui.platform.FrameRecomposer
@@ -19,6 +23,7 @@ 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.PlatformTextInputMethodRequest
 import androidx.compose.ui.platform.WindowInfo
 import androidx.compose.ui.platform.registerSkikoComposeImplementation
 import androidx.compose.ui.scene.CanvasLayersComposeScene
@@ -34,6 +39,19 @@ 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.input.BackspaceCommand
+import androidx.compose.ui.text.input.CommitTextCommand
+import androidx.compose.ui.text.input.EditCommand
+import androidx.compose.ui.text.input.FinishComposingTextCommand
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.ImeOptions
+import androidx.compose.ui.text.input.KeyboardCapitalization
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.text.input.PlatformTextInputService
+import androidx.compose.ui.text.input.SetComposingRegionCommand
+import androidx.compose.ui.text.input.SetComposingTextCommand
+import androidx.compose.ui.text.input.SetSelectionCommand
+import androidx.compose.ui.text.input.TextFieldValue
 import androidx.compose.ui.text.intl.LocaleList
 import androidx.compose.ui.text.intl.setPlatformLocaleProvider
 import androidx.compose.ui.text.platform.Font
@@ -45,6 +63,7 @@ import androidx.compose.ui.unit.LayoutDirection
 import dev.onejs.one.OneNativeSourceViewDispatch
 import kotlin.io.encoding.Base64
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.awaitCancellation
 import org.jetbrains.skiko.SystemTheme
 import org.jetbrains.skia.BackendRenderTarget
 import org.jetbrains.skia.Bitmap
@@ -94,6 +113,129 @@ internal class PeachComposePlatform(
     override fun onSemanticsOwnerRemoved(semanticsOwner: SemanticsOwner) { owners.remove(semanticsOwner) }
     override fun onSemanticsChange(semanticsOwner: SemanticsOwner) = Unit
     override fun onLayoutChange(semanticsOwner: SemanticsOwner, semanticsNodeId: Int) = Unit
+
+    // the input method session the focused text field holds, android's
+    // InputConnection. each session gets a new token, so the host can tell a
+    // late close from the session that replaced it
+    var input: PeachInputSession? = null
+        private set
+    var onInputChange: () -> Unit = {}
+    private var nextInput = 1
+
+    override suspend fun startInputMethod(request: PlatformTextInputMethodRequest): Nothing {
+        val session = PeachInputSession(nextInput++, request)
+        input = session
+        onInputChange()
+        try { awaitCancellation() }
+        finally {
+            if (input === session) input = null
+            onInputChange()
+        }
+    }
+
+    // compose's keyboard controller: show and hide move the keyboard and keep
+    // the session, as Done does on android. a session opens with the keyboard
+    // up, as android's legacy text input service shows it on startInput
+    @Suppress("DEPRECATION")
+    override val textInputService: PlatformTextInputService = object : PlatformTextInputService {
+        override fun startInput(value: TextFieldValue, imeOptions: ImeOptions,
+            onEditCommand: (List<EditCommand>) -> Unit, onImeActionPerformed: (ImeAction) -> Unit) = Unit
+        override fun stopInput() = Unit
+        override fun showSoftwareKeyboard() { input?.request(true); onInputChange() }
+        override fun hideSoftwareKeyboard() { input?.request(false); onInputChange() }
+        override fun updateState(oldValue: TextFieldValue?, newValue: TextFieldValue) = Unit
+    }
+}
+
+internal class PeachInputSession(val token: Int, val request: PlatformTextInputMethodRequest) {
+    var keyboard = true
+        private set
+    // each show or hide compose asks for, so a repeat still reaches the keyboard
+    private var keyboardRequest = 0
+    private val options get() = request.imeOptions
+
+    // EditorInfo.android.kt: a single line field's default action is Done; a
+    // multi line field's default has no enter action, so enter types a newline
+    private val action: ImeAction? get() = when (options.imeAction) {
+        ImeAction.Default -> if (options.singleLine) ImeAction.Done else null
+        ImeAction.None -> null
+        else -> options.imeAction
+    }
+
+    fun request(visible: Boolean) {
+        keyboard = visible
+        keyboardRequest++
+    }
+
+    private fun rect(rect: Rect?) = rect?.let { JSONArray().put(it.left).put(it.top).put(it.right).put(it.bottom) }
+
+    fun state(): JSONObject {
+        val value = request.value()
+        return JSONObject().put("token", token).put("keyboard", keyboard).put("keyboardRequest", keyboardRequest)
+            .put("value", value.text).put("selectionStart", value.selection.start).put("selectionEnd", value.selection.end)
+            .put("singleLine", options.singleLine).put("enterInsertsNewline", action == null && !options.singleLine)
+            .put("keyboardType", when (options.keyboardType) {
+                KeyboardType.Number -> "number"
+                KeyboardType.Phone -> "phone"
+                KeyboardType.Uri -> "uri"
+                KeyboardType.Email -> "email"
+                KeyboardType.Password -> "password"
+                KeyboardType.NumberPassword -> "number-password"
+                KeyboardType.Decimal -> "decimal"
+                KeyboardType.Ascii -> "ascii"
+                else -> "text"
+            })
+            .put("imeAction", when (action) {
+                ImeAction.Done -> "done"
+                ImeAction.Go -> "go"
+                ImeAction.Search -> "search"
+                ImeAction.Send -> "send"
+                ImeAction.Next -> "next"
+                ImeAction.Previous -> "previous"
+                else -> "default"
+            })
+            .put("capitalization", when (options.capitalization) {
+                KeyboardCapitalization.Characters -> "characters"
+                KeyboardCapitalization.Words -> "words"
+                KeyboardCapitalization.Sentences -> "sentences"
+                else -> "none"
+            })
+            .put("autoCorrect", options.autoCorrect)
+            .put("field", rect(request.textFieldRectInRoot()))
+            .put("caret", rect(request.focusedRectInRoot()))
+    }
+
+    // one keyboard edit, applied as one batch the way RecordingInputConnection
+    // ends a batch edit. typed text commits as an IME's commitText does; a
+    // composition replaces its own region, else the edit's range
+    fun edit(command: JSONObject): Boolean {
+        val value = request.value()
+        val start = command.optInt("start")
+        val end = command.optInt("end")
+        val composing = value.composition?.let { it.start == start && it.end == end } == true
+        val commands: List<EditCommand> = when (command.getString("kind")) {
+            "text" -> listOf(CommitTextCommand(command.getString("text"), 1))
+            "backspace" -> listOf(BackspaceCommand())
+            "enter" -> {
+                val performed = action
+                if (performed != null) {
+                    request.onImeAction?.invoke(performed)
+                    return true
+                }
+                if (options.singleLine) return false
+                listOf(CommitTextCommand("\n", 1))
+            }
+            "compositionStart" -> if (start == end) return true else listOf(SetComposingRegionCommand(start, end))
+            "replace" -> {
+                val text = command.getString("text")
+                val place = if (composing) emptyList() else listOf(FinishComposingTextCommand(), SetSelectionCommand(start, end))
+                place + if (command.getString("composition") == "update") SetComposingTextCommand(text, 1) else CommitTextCommand(text, 1)
+            }
+            else -> error("unknown input edit ${command.getString("kind")}")
+        }
+        request.onEditCommand(commands)
+        return true
+    }
 }
 
 // android's default and sans-serif families use the same device font bytes as
@@ -150,12 +292,16 @@ internal class PeachComposeMount(
         recomposer, platform.density, LayoutDirection.Ltr, null, platform,
         invalidateLayout = { needsMeasure = true; invalidate(true) }, invalidateDraw = { invalidate(false) },
     )
+    // the session's state as last reported; a change reports it again
+    private var reportedInput: String? = null
     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
 
+    init { platform.onInputChange = { invalidate(false) } }
+
     fun setContent(content: @Composable () -> Unit) {
         try {
             scene.setContent {
@@ -221,6 +367,11 @@ internal class PeachComposeMount(
         for ((name, args) in frameState) events.add(JSONObject().put("name", name).put("args", args()))
         frameState.clear()
         reply.put("events", JSONArray(events))
+        val input = platform.input?.state()?.toString()
+        if (input != reportedInput) {
+            reportedInput = input
+            reply.put("input", input?.let { JSONObject(it) } ?: JSONObject.NULL)
+        }
         events.clear()
         if (gpu) checkNotNull(surface).flushAndSubmit()
         else {
@@ -245,6 +396,37 @@ internal class PeachComposeMount(
         invalidate(false)
     }
 
+    private fun session(token: Int) = platform.input?.takeIf { it.token == token }
+
+    fun inputEdit(token: Int, command: String): Boolean {
+        val session = session(token) ?: return false
+        return session.edit(JSONObject(command)).also { invalidate(false) }
+    }
+
+    // a hardware key, pressed and released, through compose's key input as an
+    // android view dispatches it; true when compose consumed the press
+    fun inputKey(token: Int, name: String, ctrl: Boolean, shift: Boolean, alt: Boolean): Boolean {
+        if (session(token) == null) return false
+        val key = hardwareKeys[name] ?: name.singleOrNull()?.lowercaseChar()?.let { letterKeys["$it"] } ?: return false
+        val codePoint = name.singleOrNull()?.code ?: 0
+        fun send(type: KeyEventType) = scene.sendKeyEvent(KeyEvent(key, type, codePoint,
+            isCtrlPressed = ctrl, isAltPressed = alt, isShiftPressed = shift))
+        val consumed = send(KeyEventType.KeyDown)
+        send(KeyEventType.KeyUp)
+        invalidate(false)
+        return consumed
+    }
+
+    fun inputState(token: Int): String = session(token)?.state()?.toString() ?: ""
+
+    // the host gave focus to another input: the view loses focus, as
+    // View.clearFocus does, and compose closes the session itself
+    fun inputBlur(token: Int) {
+        if (session(token) == null) return
+        scene.focusManager.releaseFocus()
+        invalidate(false)
+    }
+
     fun semantics(): String {
         val nodes = JSONArray()
         fun collect(node: SemanticsNode) {
@@ -274,6 +456,19 @@ internal class PeachComposeMount(
     }
 }
 
+// the keys a hardware keyboard sends, by their DOM names
+private val hardwareKeys = mapOf(
+    "ArrowLeft" to Key.DirectionLeft, "ArrowRight" to Key.DirectionRight,
+    "ArrowUp" to Key.DirectionUp, "ArrowDown" to Key.DirectionDown,
+    "Home" to Key.MoveHome, "End" to Key.MoveEnd, "PageUp" to Key.PageUp, "PageDown" to Key.PageDown,
+    "Tab" to Key.Tab, "Delete" to Key.Delete, "Backspace" to Key.Backspace,
+    "Enter" to Key.Enter, "Escape" to Key.Escape,
+)
+private val letterKeys = listOf(
+    Key.A, Key.B, Key.C, Key.D, Key.E, Key.F, Key.G, Key.H, Key.I, Key.J, Key.K, Key.L, Key.M,
+    Key.N, Key.O, Key.P, Key.Q, Key.R, Key.S, Key.T, Key.U, Key.V, Key.W, Key.X, Key.Y, Key.Z,
+).mapIndexed { index, key -> "${'a' + index}" to key }.toMap()
+
 internal val mounts = mutableMapOf<Int, PeachComposeMount>()
 private var nextMount = 1
 private var deviceLocale: String? = null
@@ -330,6 +525,11 @@ fun peachViewMount(source: String, view: String, hash: String, props: String,
 }
 @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 peachViewInputEdit(id: Int, token: Int, command: String): Boolean = checkNotNull(mounts[id]).inputEdit(token, command)
+@JsExport fun peachViewInputKey(id: Int, token: Int, key: String, ctrl: Boolean, shift: Boolean, alt: Boolean): Boolean =
+    checkNotNull(mounts[id]).inputKey(token, key, ctrl, shift, alt)
+@JsExport fun peachViewInputState(id: Int, token: Int): String = checkNotNull(mounts[id]).inputState(token)
+@JsExport fun peachViewInputBlur(id: Int, token: Int) = checkNotNull(mounts[id]).inputBlur(token)
 @JsExport fun peachViewSemantics(id: Int): String = checkNotNull(mounts[id]).semantics()
 @JsExport fun peachViewDispose(id: Int) { mounts.remove(id)?.close() }
 

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

@@ -207,6 +207,19 @@ class JSONObject() {
         return this
     }
 
+    // android's coercions: any value reads as its string; a number or a
+    // numeric string reads as an int, anything else as the fallback
+    fun getString(name: String): String = when (val value = get(name)) {
+        is String -> value
+        else -> value.toString()
+    }
+
+    fun optInt(name: String, fallback: Int = 0): Int = when (val value = opt(name)) {
+        is Number -> value.toInt()
+        is String -> value.toDoubleOrNull()?.toInt() ?: fallback
+        else -> fallback
+    }
+
     fun optBoolean(name: String): Boolean = when (val value = opt(name)) {
         is Boolean -> value
         is String -> value.equals("true", ignoreCase = true)

package/kotlin/fixtures/kotlin-app-variants/Anim.kt

@@ -0,0 +1,62 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.animateColorAsState
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.foundation.background
+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.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.foundation.layout.width
+import androidx.compose.material3.Button
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.withFrameNanos
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import kotlin.math.roundToInt
+
+// a tap flips one state that AnimatedVisibility, animateDpAsState and
+// animateColorAsState each animate on the frame clock; the label reads the
+// animated width, so it settles only when the animation has finished. took
+// is the frame clock time and frame count from the flip to the width's arrival
+@Composable
+fun Anim() {
+    var on by remember { mutableStateOf(false) }
+    var flips by remember { mutableStateOf(0) }
+    var took by remember { mutableStateOf("none") }
+    val target = if (on) 240.dp else 80.dp
+    val width by animateDpAsState(target, label = "width")
+    LaunchedEffect(flips) {
+        if (flips == 0) return@LaunchedEffect
+        val start = withFrameNanos { it }
+        var count = 0
+        var end = start
+        while (width != target) end = withFrameNanos { count += 1; it }
+        took = "${(end - start) / 1_000_000}ms $count frames"
+    }
+    val color by animateColorAsState(if (on) Color(0xFF3F51B5) else Color(0xFFE91E63), label = "color")
+    Column(
+        Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        Text("Anim: $on width ${if (width == target) "${target.value.roundToInt()}" else "moving"}")
+        Button(onClick = { on = !on; flips += 1 }) { Text("Animate") }
+        Text("Took: $took")
+        Box(Modifier.width(width).height(48.dp).background(color))
+        AnimatedVisibility(on) {
+            Text("Panel", Modifier.fillMaxWidth().background(Color(0xFF009688)).padding(24.dp), color = Color.White)
+        }
+    }
+}

package/kotlin/fixtures/kotlin-app-variants/Form.kt

@@ -0,0 +1,47 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.unit.dp
+
+// a single line field a tap focuses, typing fills and Done finishes, keeping
+// its focus as android does
+@Composable
+fun Form() {
+    var name by remember { mutableStateOf("") }
+    var focused by remember { mutableStateOf(false) }
+    var done by remember { mutableStateOf(0) }
+    Column(
+        Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        Text("Name: ${name.ifEmpty { "empty" }} focus $focused done $done")
+        OutlinedTextField(
+            value = name,
+            onValueChange = { name = it },
+            label = { Text("Name") },
+            singleLine = true,
+            keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
+            keyboardActions = KeyboardActions(onDone = { done += 1; defaultKeyboardAction(ImeAction.Done) }),
+            modifier = Modifier.fillMaxWidth().onFocusChanged { focused = it.isFocused },
+        )
+    }
+}

package/kotlin/fixtures/kotlin-app-variants/Ime.kt

@@ -0,0 +1,51 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.ime
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.dp
+
+// safe drawing padding holds a bottom bar above the keyboard, which the IME
+// inset moves as the keyboard opens and closes. a window that fits system
+// windows takes no IME inset, and lifted reports whether its content shrank
+@Composable
+fun Ime() {
+    var note by remember { mutableStateOf("") }
+    var height by remember { mutableStateOf(0) }
+    var tallest by remember { mutableStateOf(0) }
+    val shown = WindowInsets.ime.getBottom(LocalDensity.current) > 0
+    Column(
+        Modifier.fillMaxSize()
+            .onSizeChanged { height = it.height; tallest = maxOf(tallest, it.height) }
+            .background(Color(0xFFE8EEF8))
+            .safeDrawingPadding()
+            .padding(16.dp),
+    ) {
+        Text("Ime: ${if (shown) "shown" else "hidden"} lifted ${height < tallest}")
+        OutlinedTextField(
+            value = note,
+            onValueChange = { note = it },
+            label = { Text("Note") },
+            modifier = Modifier.fillMaxWidth().padding(top = 12.dp),
+        )
+        Spacer(Modifier.weight(1f))
+        Text("Bottom bar", Modifier.fillMaxWidth().background(Color(0xFF3F51B5)).padding(16.dp), color = Color.White)
+    }
+}

package/kotlin/fixtures/kotlin-app-variants/Note.kt

@@ -0,0 +1,40 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+
+// a multi line field with default keyboard options: enter inserts a newline
+// and delete removes what it typed
+@Composable
+fun Note() {
+    var note by remember { mutableStateOf("") }
+    var focused by remember { mutableStateOf(false) }
+    Column(
+        Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        Text("Note: ${note.ifEmpty { "empty" }.replace('\n', '|')} focus $focused")
+        OutlinedTextField(
+            value = note,
+            onValueChange = { note = it },
+            label = { Text("Note") },
+            modifier = Modifier.fillMaxWidth().onFocusChanged { focused = it.isFocused },
+        )
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peachsim",
-  "version": "0.1.665",
+  "version": "0.1.667",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for peach.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",

package/src/assetCatalogContract.ts

@@ -7,6 +7,27 @@ export interface SwiftImageSource {
 // an app catalog color resolves by appearance or names a system color.
 export type AppCatalogColor = { light: string; dark: string } | { system: string }
 
+// UIImage's ordered monochrome layers and unrounded content bearings.
+export interface SfSymbolImageDrawing {
+  referencePointSize: number
+  basePointSize: number
+  referenceCanvasSize: readonly [number, number]
+  insets: readonly [number, number, number, number]
+  layers: readonly { d: string; opacity: number; eraser: boolean }[]
+}
+
+export interface SfSymbolImageMetadata extends Omit<SfSymbolImageDrawing, 'layers'> {
+  layers: readonly { opacity: number; eraser: boolean }[]
+}
+
+// roundtrip Float64 decimal coordinates with shared svg verb programs.
+export interface SfSymbolPathEncoding {
+  format: 'float64-table'
+  coordinates: string
+  programs: readonly string[]
+  paths: readonly (readonly [number, string])[]
+}
+
 export interface SfSymbolVector {
   viewBox: '0 0 24 24'
   advance: number
@@ -17,6 +38,8 @@ export interface SfSymbolVector {
   uiImageBox?: readonly [number, number, number, number]
   controlBoxes?: Record<string, readonly [number, number, number]>
   layers: readonly { d: string; color?: string }[]
+  image?: SfSymbolImageDrawing
+  imageAliases?: Readonly<Record<string, SfSymbolImageDrawing>>
 }
 
 // the three symbol scales. the symbol font draws each as its own glyph

package/src/kotlin-host.ts

@@ -401,6 +401,9 @@ export async function kotlinAppArtifact(
       '@JsExport',
       'fun peachAppNight(night: Boolean) = dev.peach.app.peachAppNight(night)',
       '',
+      '@JsExport',
+      'fun peachAppIme(bottom: Int) = dev.peach.app.peachAppIme(bottom)',
+      '',
     ].join('\n')
   const generated: Record<string, string> = {
     'PeachEntry.kt': entrySource([]),

package/src/skills/builtin/a11y-review.ts

@@ -31,7 +31,9 @@ export const skill: RNXSkill = {
 
         try {
           await page.goto(context.url, { waitUntil: 'networkidle' })
-          await page.waitForFunction('window.__sootsimTest', { timeout: 10000 })
+          await page.waitForFunction('window.__sootsimTest', undefined, {
+            timeout: 10000,
+          })
           await page.waitForTimeout(2000)
 
           // get accessibility tree

package/src/skills/builtin/perf-profile.ts

@@ -44,9 +44,11 @@ export const skill: RNXSkill = {
 
         try {
           await page.goto(context.url, { waitUntil: 'networkidle' })
-          await page.waitForFunction('window.__sootsimTest && window.__sootsimA11y', {
-            timeout: 10000,
-          })
+          await page.waitForFunction(
+            'window.__sootsimTest && window.__sootsimA11y',
+            undefined,
+            { timeout: 10000 },
+          )
           await page.waitForTimeout(1000)
 
           // reset profiler