@g9tm/lynxcontrols-native 1.4.3 → 1.4.5

package/README.md

@@ -1,12 +1,13 @@
 # @g9tm/lynxcontrols-native
 
-Android and iOS platform layer for G9: two Lynx native modules and one element (`<g9-video>`), linked into a host by
+Android and iOS platform layer for G9: three Lynx native modules and one element (`<g9-video>`), linked into a host by
 **Lynx Autolink** from `node_modules`, plus their JS adapters.
 
 | Module | JS adapter | Android (Kotlin) | iOS (Objective-C) |
 | --- | --- | --- | --- |
 | `G9SqliteModule` | `createNativeSqliteDriver()` | androidx.sqlite `BundledSQLiteDriver` 2.7.1 | system `sqlite3` (iOS 15+, serial queue per session, `sqlite3_interrupt`) |
 | `G9HostModule` | `createNativeHostServices()` | `SharedPreferences`, `moveTaskToBack`, `InputMethodManager`, haptics, insets, `appDataDirectory()` = `filesDir` | `NSUserDefaults` suite, `resignFirstResponder`, `UIImpactFeedbackGenerator`, safe-area insets, `appDataDirectory()` = `Library` |
+| `G9SpeechModule` | `createNativeSpeechToText()` → `services.speech` (dictation into fields) | `SpeechRecognizer` (main thread, partial results), the microphone asked through the host activity's `ActivityResultRegistry` | `SFSpeechRecognizer` over `AVAudioEngine`; register it on the host's `LynxConfig`; Info.plist `NSMicrophoneUsageDescription` + `NSSpeechRecognitionUsageDescription` |
 | `<g9-video>` element | `createNativeMediaProvider()` (`@g9tm/lynxcontrols-native/media`) | `G9VideoUI`: Media3 ExoPlayer 1.8.0 into a `TextureView` (opacity fades work); register `G9VideoBehaviors.create()` | `G9VideoUI`: `AVQueuePlayer` + `AVPlayerLooper` in an `AVPlayerLayer`; self-registers (`LYNX_REGISTER_UI`) |
 
 ```ts
@@ -21,6 +22,17 @@ const db = createG9Sqlite({ driver: createNativeSqliteDriver(), locator: singleF
 
 ## How it works
 
+- **Dictation** (`services.speech`, MAUI `IG9SpeechToText`). `createNativeSpeechToText()` returns `null` where
+  `G9SpeechModule` is not linked, so the fields hide their microphone. One session at a time natively; the adapter
+  numbers sessions, routes the `g9:speech` global event (`{"session","text"}`, interim hypotheses) to the session that
+  asked, turns an abort into `cancel(session)` and settles every `listen` once (`recognized` / `no-match` /
+  `cancelled` / `denied`; a recogniser fault rejects with a `G9Error`). Android: the manifest merges `RECORD_AUDIO` and
+  the `RecognitionService` query Android 11+ needs to see a recogniser; androidx.activity is compile-only (every host
+  has it; a host activity that is not an `ActivityResultRegistryOwner` gets the current permission state, never a
+  prompt).
+  `isAvailable(locale)` is "a recogniser exists" on Android (asking a locale needs a broadcast some recognisers never
+  answer; an unsupported language ends as `no-match`) and `SFSpeechRecognizer(locale).isAvailable` on iOS.
+
 - **Video** (the intro carousel's `services.media`). `<g9-video>` props: `src`, `paused`, `loop`, `muted`,
   `start-seconds`, `near-end-seconds`, `object-fit`; events `ready`, `nearend`, `looped`, `error`. The provider's
   player renders it with reactive props (no UI-method calls) and unmounts it on `dispose()`, which releases the native
@@ -54,13 +66,16 @@ android/src/main/java/com/g9lynx/g9native/
   sqlite/core/      pure Kotlin: G9SqliteCore, G9SqliteService (executors), G9SqliteTransport, values/errors
   sqlite/androidx/  AndroidxSqlEngine (BundledSQLiteDriver)
   host/core/        G9PreferencesCore
-  G9SqliteModule.kt, G9HostModule.kt, G9Bridge.kt   Lynx modules (kapt + lynx-processor → LynxLibraryProviderImpl)
+  G9SqliteModule.kt, G9HostModule.kt, G9SpeechModule.kt, G9Bridge.kt   Lynx modules (kapt + lynx-processor →
+                    LynxLibraryProviderImpl)
 android/src/test/   JVM tests: contract runner, core, service, transport golden, preferences
 ios/src/core/       portable Objective-C (Foundation + sqlite3): G9SqliteCore, G9SqliteTransport, G9PreferencesCore
-ios/src/            G9SqliteModule.m, G9HostModule.m (dispatch queues, UIKit); register them on the host's LynxConfig
+ios/src/            G9SqliteModule.m, G9HostModule.m, G9SpeechModule.m (dispatch queues, UIKit, Speech); register them
+                    on the host's LynxConfig
 ios/Tests/          G9NativeTestSuite (XCTest on a simulator; Linux harness in Tests/linux)
 jvm/                JVM-only Gradle build of the core + tests (no Android SDK needed)
-android-check/      cloud compile check of module + reference host against the published Lynx 4.1.0 classes, and
+android-check/      cloud compile check of module + reference host against the published Lynx 4.1.0 classes (Media3,
+                    androidx.sqlite and androidx.activity as compile-only stubs under stubs/), and
                     LynxBridgeSignatureTest: every @LynxMethod through Lynx's own LynxMethodWrapper
 ```
 

package/android/build.gradle.kts

@@ -34,6 +34,14 @@ dependencies {
   // The generated specs import androidx.annotation and lynx-processor's output uses @Keep, but Lynx's POMs declare it
   // at runtime scope only: without this line kapt depends on androidx.sqlite / media3 bringing it in transitively.
   compileOnly("androidx.annotation:annotation:1.9.1")
+  // G9InputBehaviors (input/G9InputUI.kt) extends xelement-input's input and textarea; a host that registers them
+  // already depends on it.
+  compileOnly("org.lynxsdk.lynx:xelement-input:$lynx")
+  // Its EditText derives from AppCompatEditText, which xelement-input's POM lists at runtime scope only.
+  compileOnly("androidx.appcompat:appcompat:1.7.0")
+  // G9SpeechModule asks for the microphone through the host activity's ActivityResultRegistry: compile-only, as every
+  // host of these libraries ships androidx.activity (a host without it gets the current state, never a prompt).
+  compileOnly("androidx.activity:activity:1.10.1")
   implementation("androidx.sqlite:sqlite-bundled:2.7.1")
   // <g9-video> (video/G9VideoUI.kt): ExoPlayer drawing into a TextureView. Google Maven only.
   implementation("androidx.media3:media3-exoplayer:1.8.0")

package/android/src/main/AndroidManifest.xml

@@ -1,5 +1,12 @@
 <manifest
   xmlns:android="http://schemas.android.com/apk/res/android"
   package="com.g9lynx.g9native">
+  <!-- G9SpeechModule: dictation records the microphone, and Android 11+ only sees a recogniser it declares a query for. -->
+  <uses-permission android:name="android.permission.RECORD_AUDIO" />
+  <queries>
+    <intent>
+      <action android:name="android.speech.RecognitionService" />
+    </intent>
+  </queries>
   <application />
 </manifest>

package/android/src/main/java/com/g9lynx/g9native/G9HostModule.kt

@@ -13,6 +13,7 @@ import android.view.inputmethod.InputMethodManager
 import com.g9lynx.g9native.generated.G9HostModuleSpec
 import com.g9lynx.g9native.host.core.G9PreferenceBackend
 import com.g9lynx.g9native.host.core.G9PreferencesCore
+import com.g9lynx.g9native.host.core.G9SafeAreaCore
 import com.lynx.jsbridge.LynxMethod
 import com.lynx.jsbridge.LynxNativeModule
 import com.lynx.react.bridge.Callback
@@ -86,7 +87,7 @@ class G9HostModule(private val lynxContext: LynxContext) : G9HostModuleSpec(lynx
       val density = activity.resources.displayMetrics.density
       val insets = activity.window.decorView.rootWindowInsets
       val rtl = activity.window.decorView.layoutDirection == View.LAYOUT_DIRECTION_RTL
-      val px = safeInsetsPx(insets)
+      val px = safeInsetsPx(insets, activity.window.decorView)
       val left = px[0] / density
       val right = px[2] / density
       val value =
@@ -160,13 +161,38 @@ class G9HostModule(private val lynxContext: LynxContext) : G9HostModuleSpec(lynx
    * by type, so the soft keyboard never counts (the deprecated `systemWindowInset*` added the IME height when the
    * keyboard was up) and a host that hides the bars (immersive, as the AgriPad MAUI app) gets the cutout only.
    */
-  private fun safeInsetsPx(insets: android.view.WindowInsets?): IntArray {
+  /** The cutout plus each system bar only while it shows (G9SafeAreaCore): an immersive host's hidden bars count zero. */
+  private fun safeInsetsPx(insets: android.view.WindowInsets?, decor: View): IntArray {
     if (insets == null) return intArrayOf(0, 0, 0, 0)
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-      val i = insets.getInsets(android.view.WindowInsets.Type.systemBars() or android.view.WindowInsets.Type.displayCutout())
-      return intArrayOf(i.left, i.top, i.right, i.bottom)
+      fun px(i: android.graphics.Insets) = intArrayOf(i.left, i.top, i.right, i.bottom)
+      val status = android.view.WindowInsets.Type.statusBars()
+      val navigation = android.view.WindowInsets.Type.navigationBars()
+      return G9SafeAreaCore.compute(
+        px(insets.getInsets(android.view.WindowInsets.Type.displayCutout())),
+        px(insets.getInsets(status)),
+        insets.isVisible(status),
+        px(insets.getInsets(navigation)),
+        insets.isVisible(navigation),
+      )
     }
+    // Android 10 and older: systemWindowInsets keep a hidden bar's size (LAYOUT_STABLE); the decor view's flags say
+    // whether it is hidden. The status bar is the top inset, the navigation bar the others.
+    @Suppress("DEPRECATION")
+    val flags = decor.systemUiVisibility
+    val cutout =
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+        insets.displayCutout?.let { intArrayOf(it.safeInsetLeft, it.safeInsetTop, it.safeInsetRight, it.safeInsetBottom) }
+      } else {
+        null
+      } ?: intArrayOf(0, 0, 0, 0)
     @Suppress("DEPRECATION")
-    return intArrayOf(insets.systemWindowInsetLeft, insets.systemWindowInsetTop, insets.systemWindowInsetRight, insets.systemWindowInsetBottom)
+    return G9SafeAreaCore.compute(
+      cutout,
+      intArrayOf(0, insets.systemWindowInsetTop, 0, 0),
+      flags and View.SYSTEM_UI_FLAG_FULLSCREEN == 0,
+      intArrayOf(insets.systemWindowInsetLeft, 0, insets.systemWindowInsetRight, insets.systemWindowInsetBottom),
+      flags and View.SYSTEM_UI_FLAG_HIDE_NAVIGATION == 0,
+    )
   }
 }

package/android/src/main/java/com/g9lynx/g9native/G9SpeechModule.kt

@@ -0,0 +1,206 @@
+package com.g9lynx.g9native
+
+import android.Manifest
+import android.app.Activity
+import android.content.Context
+import android.content.ContextWrapper
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.speech.RecognitionListener
+import android.speech.RecognizerIntent
+import android.speech.SpeechRecognizer
+import androidx.activity.result.ActivityResultLauncher
+import androidx.activity.result.ActivityResultRegistryOwner
+import androidx.activity.result.contract.ActivityResultContracts
+import com.g9lynx.g9native.generated.G9SpeechModuleSpec
+import com.lynx.jsbridge.LynxMethod
+import com.lynx.jsbridge.LynxNativeModule
+import com.lynx.react.bridge.Callback
+import com.lynx.react.bridge.JavaOnlyArray
+import com.lynx.tasm.behavior.LynxContext
+import org.json.JSONObject
+import java.util.concurrent.atomic.AtomicInteger
+
+/**
+ * `NativeModules.G9SpeechModule` (`G9SpeechToText`, MAUI `IG9SpeechToText`): Android's `SpeechRecognizer`, one session at
+ * a time, on the main thread (the recogniser demands it). Partial hypotheses go out as the global event `g9:speech`
+ * (`{"session","text"}`); the `listen` reply settles once. The microphone permission is asked through the activity's
+ * `ActivityResultRegistry` — the host's activity must be an `ActivityResultRegistryOwner` (every `ComponentActivity`;
+ * androidx.activity is compile-only here, every host of these libraries has it); another activity answers with the
+ * current state instead of a prompt.
+ * TWIN: ios/src/G9SpeechModule.m.
+ */
+@LynxNativeModule(name = "G9SpeechModule")
+class G9SpeechModule(private val lynxContext: LynxContext) : G9SpeechModuleSpec(lynxContext) {
+  private val main = Handler(Looper.getMainLooper())
+
+  private class Session(val id: String, val recognizer: SpeechRecognizer, val callback: Callback?) {
+    var settled = false
+  }
+
+  private var current: Session? = null
+
+  private fun activity(): Activity? {
+    var context: Context? = lynxContext
+    while (context is ContextWrapper) {
+      if (context is Activity) return context
+      context = context.baseContext
+    }
+    return null
+  }
+
+  private fun ok(callback: Callback?, value: Any?) = G9Bridge.reply(callback, mapOf("ok" to true, "value" to value))
+
+  private fun fail(callback: Callback?, code: String, message: String) =
+    G9Bridge.reply(callback, mapOf("ok" to false, "error" to mapOf("code" to code, "message" to message)))
+
+  private fun micGranted(): Boolean =
+    lynxContext.checkSelfPermission(Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
+
+  @LynxMethod
+  override fun isAvailable(locale: String?, callback: Callback?) {
+    // The locale cannot be asked without starting a session (RecognizerIntent.ACTION_GET_LANGUAGE_DETAILS needs a
+    // broadcast round-trip that some recognisers never answer): a recogniser that exists is "available"; an unsupported
+    // language then ends its session as no-match.
+    main.post { ok(callback, SpeechRecognizer.isRecognitionAvailable(lynxContext)) }
+  }
+
+  @LynxMethod
+  override fun requestPermission(callback: Callback?) {
+    if (micGranted()) return ok(callback, "granted")
+    main.post {
+      val host = activity()
+      try {
+        if (host !is ActivityResultRegistryOwner || host.isFinishing) return@post ok(callback, "denied")
+        var launcher: ActivityResultLauncher<String>? = null
+        launcher =
+          host.activityResultRegistry.register("g9.speech.mic." + nextKey.incrementAndGet(), ActivityResultContracts.RequestPermission()) { granted ->
+            launcher?.unregister()
+            ok(callback, if (granted) "granted" else "denied")
+          }
+        launcher.launch(Manifest.permission.RECORD_AUDIO)
+      } catch (t: Throwable) {
+        // No androidx.activity in this host, or the registry refused: say what is true now rather than fail.
+        ok(callback, if (micGranted()) "granted" else "denied")
+      }
+    }
+  }
+
+  @LynxMethod
+  override fun listen(session: String?, locale: String?, callback: Callback?) {
+    val id = session ?: ""
+    main.post {
+      if (!micGranted()) return@post ok(callback, mapOf("status" to "denied"))
+      if (!SpeechRecognizer.isRecognitionAvailable(lynxContext)) return@post fail(callback, "speech-unavailable", "No speech recogniser on this device.")
+      current?.let { finish(it, mapOf("status" to "cancelled")) }
+      val recognizer =
+        try {
+          SpeechRecognizer.createSpeechRecognizer(lynxContext)
+        } catch (t: Throwable) {
+          return@post fail(callback, "speech-recognition", t.message ?: "The recogniser could not start.")
+        }
+      val s = Session(id, recognizer, callback)
+      current = s
+      recognizer.setRecognitionListener(listener(s))
+      val intent =
+        Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply {
+          putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM)
+          putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true)
+          putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, 1)
+          if (!locale.isNullOrBlank()) {
+            putExtra(RecognizerIntent.EXTRA_LANGUAGE, locale)
+            putExtra(RecognizerIntent.EXTRA_LANGUAGE_PREFERENCE, locale)
+          }
+          putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE, lynxContext.packageName)
+        }
+      try {
+        recognizer.startListening(intent)
+      } catch (t: Throwable) {
+        finishWithError(s, "speech-recognition", t.message ?: "The recogniser could not start.")
+      }
+    }
+  }
+
+  @LynxMethod
+  override fun cancel(session: String?) {
+    main.post {
+      val s = current ?: return@post
+      if (s.id != session) return@post
+      try {
+        s.recognizer.cancel()
+      } catch (_: Throwable) {
+      }
+      finish(s, mapOf("status" to "cancelled"))
+    }
+  }
+
+  private fun listener(s: Session) =
+    object : RecognitionListener {
+      override fun onReadyForSpeech(params: Bundle?) {}
+
+      override fun onBeginningOfSpeech() {}
+
+      override fun onRmsChanged(rmsdB: Float) {}
+
+      override fun onBufferReceived(buffer: ByteArray?) {}
+
+      override fun onEndOfSpeech() {}
+
+      override fun onEvent(eventType: Int, params: Bundle?) {}
+
+      override fun onPartialResults(partialResults: Bundle?) {
+        val text = best(partialResults) ?: return
+        if (s.settled || text.isEmpty()) return
+        val args = JavaOnlyArray().apply { pushString(JSONObject(mapOf("session" to s.id, "text" to text)).toString()) }
+        try {
+          lynxContext.sendGlobalEvent("g9:speech", args)
+        } catch (_: Throwable) {
+        }
+      }
+
+      override fun onResults(results: Bundle?) {
+        val text = best(results)?.trim().orEmpty()
+        finish(s, if (text.isEmpty()) mapOf("status" to "no-match") else mapOf("status" to "recognized", "text" to text))
+      }
+
+      override fun onError(error: Int) {
+        when (error) {
+          SpeechRecognizer.ERROR_NO_MATCH, SpeechRecognizer.ERROR_SPEECH_TIMEOUT -> finish(s, mapOf("status" to "no-match"))
+          SpeechRecognizer.ERROR_INSUFFICIENT_PERMISSIONS -> finish(s, mapOf("status" to "denied"))
+          SpeechRecognizer.ERROR_CLIENT -> finish(s, mapOf("status" to "cancelled"))
+          else -> finishWithError(s, "speech-recognition", "Speech recognition failed (SpeechRecognizer error $error).")
+        }
+      }
+    }
+
+  private fun best(bundle: Bundle?): String? = bundle?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)?.firstOrNull()
+
+  private fun finish(s: Session, value: Map<String, Any?>) {
+    if (s.settled) return
+    s.settled = true
+    release(s)
+    ok(s.callback, value)
+  }
+
+  private fun finishWithError(s: Session, code: String, message: String) {
+    if (s.settled) return
+    s.settled = true
+    release(s)
+    fail(s.callback, code, message)
+  }
+
+  private fun release(s: Session) {
+    if (current === s) current = null
+    try {
+      s.recognizer.destroy()
+    } catch (_: Throwable) {
+    }
+  }
+
+  private companion object {
+    val nextKey = AtomicInteger()
+  }
+}

package/android/src/main/java/com/g9lynx/g9native/generated/G9SpeechModuleSpec.java

@@ -0,0 +1,27 @@
+// Generated by @lynx-js/autolink-codegen. Do not edit.
+// Parameter types: scripts/android-bridge-types.mjs --fix (Lynx's bridge rejects the generator's Object).
+package com.g9lynx.g9native.generated;
+
+import androidx.annotation.Nullable;
+import com.lynx.jsbridge.LynxContextModule;
+import com.lynx.jsbridge.LynxMethod;
+import com.lynx.react.bridge.Callback;
+import com.lynx.tasm.behavior.LynxContext;
+
+public abstract class G9SpeechModuleSpec extends LynxContextModule {
+  public G9SpeechModuleSpec(LynxContext context) {
+    super(context);
+  }
+
+  @LynxMethod
+  public abstract void isAvailable(String locale, Callback callback);
+
+  @LynxMethod
+  public abstract void requestPermission(Callback callback);
+
+  @LynxMethod
+  public abstract void listen(String session, String locale, Callback callback);
+
+  @LynxMethod
+  public abstract void cancel(String session);
+}

package/android/src/main/java/com/g9lynx/g9native/host/core/G9SafeAreaCore.kt

@@ -0,0 +1,19 @@
+package com.g9lynx.g9native.host.core
+
+/**
+ * The safe area `G9HostModule.safeInsets` reports, as `[left, top, right, bottom]` px: the display cutout, plus a system bar
+ * only while it SHOWS. A host that hides its bars (immersive: they slide in transiently over the page) gets the cutout
+ * alone — the bars' own inset is reported whether or not they are hidden on Android 10 and older (`systemWindowInsets`
+ * under `SYSTEM_UI_FLAG_LAYOUT_STABLE`), and counting it put every bottom bar and sheet 48 dp above a navigation bar that
+ * was not there (AgriPad Lynx on a DOOGEE S96Pro, Android 10, 2026-11-02).
+ */
+object G9SafeAreaCore {
+  fun compute(cutout: IntArray, status: IntArray, statusShown: Boolean, navigation: IntArray, navigationShown: Boolean): IntArray {
+    val out = cutout.copyOf(4)
+    for (side in 0 until 4) {
+      if (statusShown) out[side] = maxOf(out[side], status.getOrElse(side) { 0 })
+      if (navigationShown) out[side] = maxOf(out[side], navigation.getOrElse(side) { 0 })
+    }
+    return out
+  }
+}

package/android/src/main/java/com/g9lynx/g9native/input/G9InputUI.kt

@@ -0,0 +1,118 @@
+package com.g9lynx.g9native.input
+
+import android.text.method.PasswordTransformationMethod
+import android.text.method.ReplacementTransformationMethod
+import android.text.method.SingleLineTransformationMethod
+import android.text.method.TransformationMethod
+import com.g9lynx.g9native.input.core.G9DigitsCore
+import com.lynx.tasm.behavior.Behavior
+import com.lynx.tasm.behavior.LynxContext
+import com.lynx.tasm.behavior.LynxProp
+import com.lynx.tasm.behavior.StylesDiffMap
+import com.lynx.tasm.behavior.shadow.ShadowNode
+import com.lynx.tasm.behavior.ui.LynxUI
+import com.lynx.xelement.input.LynxEditTextView
+import com.lynx.xelement.input.LynxUIInput
+import com.lynx.xelement.input.LynxUIInputShadowNode
+import com.lynx.xelement.input.LynxUITextArea
+import com.lynx.xelement.input.LynxUITextAreaShadowNode
+
+/** Draws the field's ASCII digits in the culture's digits (G9DigitsCore); the text itself is never changed. */
+internal class G9DigitsTransformation(private val pairs: Pair<CharArray, CharArray>) : ReplacementTransformationMethod() {
+  val key: String = String(pairs.first) + String(pairs.second)
+
+  override fun getOriginal(): CharArray = pairs.first
+
+  override fun getReplacement(): CharArray = pairs.second
+}
+
+/** The digits state of one field: the props it was given and the transformation it applies. */
+internal class G9FieldDigits(private val singleLine: Boolean) {
+  var system: String? = null
+  var decimalSeparator: String? = null
+
+  /**
+   * Puts the digit transformation on `view` after xelement-input's own props ran (it sets SingleLine / Password there).
+   * A password keeps its mask; a latin field gets back what xelement-input would have set.
+   */
+  fun apply(view: LynxEditTextView) {
+    val current: TransformationMethod? = view.transformationMethod
+    if (current is PasswordTransformationMethod) return
+    val pairs = G9DigitsCore.pairs(system, decimalSeparator, singleLine)
+    val wanted: TransformationMethod? =
+      when {
+        pairs != null -> {
+          if (current is G9DigitsTransformation && current.key == G9DigitsTransformation(pairs).key) return
+          G9DigitsTransformation(pairs)
+        }
+        current is G9DigitsTransformation -> if (singleLine) SingleLineTransformationMethod.getInstance() else null
+        else -> return
+      }
+    val start = view.selectionStart
+    val end = view.selectionEnd
+    view.transformationMethod = wanted
+    val length = view.text?.length ?: 0
+    if (start in 0..length && end in 0..length) view.setSelection(start, end)
+  }
+}
+
+/** xelement-input's `<input>` with `g9-digits` / `g9-decimal-separator` (`@g9tm/lynxcontrols` G9TextEntry sets them). */
+class G9UIInput(context: LynxContext) : LynxUIInput(context) {
+  private val digits = G9FieldDigits(singleLine = true)
+
+  @LynxProp(name = "g9-digits")
+  fun setG9Digits(value: String?) {
+    digits.system = value
+  }
+
+  @LynxProp(name = "g9-decimal-separator")
+  fun setG9DecimalSeparator(value: String?) {
+    digits.decimalSeparator = value
+  }
+
+  override fun afterPropsUpdated(props: StylesDiffMap?) {
+    super.afterPropsUpdated(props)
+    digits.apply(view)
+  }
+}
+
+/** xelement-input's `<textarea>` with the same digit props (G9Editor). */
+class G9UITextArea(context: LynxContext) : LynxUITextArea(context) {
+  private val digits = G9FieldDigits(singleLine = false)
+
+  @LynxProp(name = "g9-digits")
+  fun setG9Digits(value: String?) {
+    digits.system = value
+  }
+
+  @LynxProp(name = "g9-decimal-separator")
+  fun setG9DecimalSeparator(value: String?) {
+    digits.decimalSeparator = value
+  }
+
+  override fun afterPropsUpdated(props: StylesDiffMap?) {
+    super.afterPropsUpdated(props)
+    digits.apply(view)
+  }
+}
+
+/**
+ * `input` and `textarea` for a host that registers xelement-input itself (an unregistered tag breaks the page, so a
+ * host registers exactly one of each): use these instead of `LynxUIInput` / `LynxUITextArea` and the fields draw the
+ * culture's digits. The host must still depend on `org.lynxsdk.lynx:xelement-input`.
+ */
+object G9InputBehaviors {
+  fun create(): List<Behavior> =
+    listOf(
+      object : Behavior("input", false, false, false) {
+        override fun createUI(context: LynxContext): LynxUI<*> = G9UIInput(context)
+
+        override fun createShadowNode(): ShadowNode = LynxUIInputShadowNode()
+      },
+      object : Behavior("textarea", false, false, false) {
+        override fun createUI(context: LynxContext): LynxUI<*> = G9UITextArea(context)
+
+        override fun createShadowNode(): ShadowNode = LynxUITextAreaShadowNode()
+      },
+    )
+}

package/android/src/main/java/com/g9lynx/g9native/input/core/G9DigitsCore.kt

@@ -0,0 +1,56 @@
+package com.g9lynx.g9native.input.core
+
+/**
+ * What a field DRAWS for the ASCII digits it holds (MAUI: the FaNum font draws «15» as «۱۵»; AgriPad owner 2026-11-02:
+ * «Lynx shows Persian too, but what is recorded is ASCII»). Pure, so the JVM suite tests it: the native input applies the
+ * pairs as a `ReplacementTransformationMethod`, which changes only what is drawn — the text, the value events and the
+ * selection keep the ASCII characters one for one.
+ */
+object G9DigitsCore {
+  /** `g9-digits` values (the culture's numbering system, foundation `G9NumberingSystem`). */
+  const val LATIN = "latin"
+  const val PERSIAN = "persian"
+  const val ARABIC_INDIC = "arabicIndic"
+
+  /** The zero of `system`, or `null` when the field draws ASCII (latin, empty, unknown). */
+  fun zeroOf(system: String?): Char? =
+    when (system) {
+      PERSIAN -> '۰'
+      ARABIC_INDIC -> '٠'
+      else -> null
+    }
+
+  /**
+   * The characters to replace and their replacements (same length), or `null` when nothing is replaced.
+   * `singleLine` keeps what `SingleLineTransformationMethod` does (newline → space, CR → U+FEFF), since this method
+   * replaces it on a single-line input; `decimalSeparator` (one character, e.g. «٫») is drawn for the ASCII '.'.
+   */
+  fun pairs(system: String?, decimalSeparator: String?, singleLine: Boolean): Pair<CharArray, CharArray>? {
+    val zero = zeroOf(system) ?: return null
+    val from = StringBuilder("0123456789")
+    val to = StringBuilder()
+    for (d in 0..9) to.append(zero + d)
+    val separator = decimalSeparator?.takeIf { it.length == 1 && it != "." }
+    if (separator != null) {
+      from.append('.')
+      to.append(separator)
+    }
+    if (singleLine) {
+      from.append('\n').append('\r')
+      to.append(' ').append('')
+    }
+    return from.toString().toCharArray() to to.toString().toCharArray()
+  }
+
+  /** What `pairs` draws for `text` (the tests' view of the transformation). */
+  fun draw(text: String, pairs: Pair<CharArray, CharArray>?): String {
+    if (pairs == null) return text
+    val (from, to) = pairs
+    val out = StringBuilder(text.length)
+    for (c in text) {
+      val i = from.indexOf(c)
+      out.append(if (i >= 0) to[i] else c)
+    }
+    return out.toString()
+  }
+}