fix(legacy): run *Async file/ViewModel lookups on the main thread

The legacy backends implemented the *Async lookup APIs as
Promise.async { sync impl }, which moves Rive runtime access onto
Nitro's background pool (Swift concurrency executor / Dispatchers.
Default) — concurrent with the attached views rendering the same
RiveFile on the main thread, with no synchronization in the legacy
runtime. That is the race class TSan confirmed for issue #297, and
useViewModelInstance({ async: true }) routes all instance setup
through these paths.

iOS already main-hopped instance creation (Promise.onMain in
HybridViewModel); this applies the same policy to the file/ViewModel
lookups and to Android, where creation also ran on the pool. Android
uses a shared, never-cancelled main scope: a Promise launched on a
cancelled scope would never settle, so a lookup racing dispose() must
still resolve (the bodies null-guard the disposed file).

On the legacy backend "async" thus means "doesn't block the JS
thread", never "parallel with rendering". Not covered here (same
race class, pre-existing via useRiveList/useRiveProperty): the legacy
list-property operations and iOS legacy property setters still run on
the pool — follow-up.

Author: mfazekas

android/src/legacy/java/com/margelo/nitro/rive/HybridRiveFile.kt

@@ -86,8 +86,13 @@ class HybridRiveFile : HybridRiveFileSpec() {
     }
   }
 
+  // The *Async lookups run on the main thread (via [riveMainScope], not Nitro's
+  // Dispatchers.Default pool): they walk the same RiveFile the attached views
+  // render on the main thread, and the legacy runtime has no internal
+  // synchronization — off-main access is the race class of issue #297.
+  // "Async" here means "doesn't block the JS thread".
   override fun getViewModelNamesAsync(): Promise<Array<String>> {
-    return Promise.async {
+    return Promise.async(riveMainScope) {
       val file = riveFile ?: return@async emptyArray()
       val count = file.viewModelCount
       val names = mutableListOf<String>()
@@ -103,19 +108,19 @@ class HybridRiveFile : HybridRiveFileSpec() {
   }
 
   override fun viewModelByNameAsync(name: String, validate: Boolean?): Promise<HybridViewModelSpec?> {
-    return Promise.async { viewModelByName(name) }
+    return Promise.async(riveMainScope) { viewModelByName(name) }
   }
 
   override fun defaultArtboardViewModelAsync(artboardBy: ArtboardBy?): Promise<HybridViewModelSpec?> {
-    return Promise.async { defaultArtboardViewModel(artboardBy) }
+    return Promise.async(riveMainScope) { defaultArtboardViewModel(artboardBy) }
   }
 
   override fun getArtboardCountAsync(): Promise<Double> {
-    return Promise.async { artboardCount }
+    return Promise.async(riveMainScope) { artboardCount }
   }
 
   override fun getArtboardNamesAsync(): Promise<Array<String>> {
-    return Promise.async { artboardNames }
+    return Promise.async(riveMainScope) { artboardNames }
   }
 
   override fun updateReferencedAssets(referencedAssets: ReferencedAssetsType) {
@@ -140,7 +145,7 @@ class HybridRiveFile : HybridRiveFileSpec() {
 
   override fun getEnums(): Promise<Array<RiveEnumDefinition>> {
     val file = riveFile ?: return Promise.resolved(emptyArray())
-    return Promise.async {
+    return Promise.async(riveMainScope) {
       try {
         file.enums
           .map { enum ->

android/src/legacy/java/com/margelo/nitro/rive/HybridViewModel.kt

@@ -57,23 +57,25 @@ class HybridViewModel(private val viewModel: ViewModel) : HybridViewModelSpec()
     return Promise.rejected(UnsupportedOperationException("getPropertiesAsync is not supported on the legacy backend"))
   }
 
+  // Main-hopped like HybridRiveFile's lookups — the legacy runtime is only
+  // safe to touch on the main thread (see riveMainScope).
   override fun getPropertyCountAsync(): Promise<Double> {
-    return Promise.async { propertyCount }
+    return Promise.async(riveMainScope) { propertyCount }
   }
 
   override fun getInstanceCountAsync(): Promise<Double> {
-    return Promise.async { instanceCount }
+    return Promise.async(riveMainScope) { instanceCount }
   }
 
   override fun createInstanceByNameAsync(name: String): Promise<HybridViewModelInstanceSpec?> {
-    return Promise.async { createInstanceByName(name) }
+    return Promise.async(riveMainScope) { createInstanceByName(name) }
   }
 
   override fun createDefaultInstanceAsync(): Promise<HybridViewModelInstanceSpec?> {
-    return Promise.async { createDefaultInstance() }
+    return Promise.async(riveMainScope) { createDefaultInstance() }
   }
 
   override fun createBlankInstanceAsync(): Promise<HybridViewModelInstanceSpec?> {
-    return Promise.async { createInstance() }
+    return Promise.async(riveMainScope) { createInstance() }
   }
 }

android/src/legacy/java/com/margelo/nitro/rive/RiveMainScope.kt

@@ -0,0 +1,13 @@
+package com.margelo.nitro.rive
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+
+// Legacy runtime objects are only safe to touch on the main thread: the
+// attached views render there and rive-android's legacy API has no internal
+// synchronization (off-main access is the race class of issue #297). This
+// scope hops *Async calls onto main. It is intentionally never cancelled —
+// a Promise launched on a cancelled scope would never settle, so bodies
+// guard on disposed state instead.
+internal val riveMainScope = CoroutineScope(Dispatchers.Main + SupervisorJob())

ios/legacy/HybridRiveFile.swift

@@ -90,8 +90,13 @@ class HybridRiveFile: HybridRiveFileSpec, RiveViewSource {
     return HybridBindableArtboard(bindableArtboard: bindable)
   }
 
+  // The *Async lookups run on the main thread (not Nitro's pool): they walk
+  // the same RiveFile the attached views render on the main thread, and the
+  // legacy runtime has no internal synchronization — off-main access is the
+  // race class of issue #297. "Async" here means "doesn't block the JS
+  // thread", matching HybridViewModel's create*InstanceAsync.
   func getViewModelNamesAsync() throws -> Promise<[String]> {
-    return Promise.async {
+    return Promise.onMain {
       guard let file = self.riveFile else { return [] }
       let count = file.viewModelCount
       var names: [String] = []
@@ -105,19 +110,19 @@ class HybridRiveFile: HybridRiveFileSpec, RiveViewSource {
   }
 
   func viewModelByNameAsync(name: String, validate: Bool?) throws -> Promise<(any HybridViewModelSpec)?> {
-    return Promise.async { try self.viewModelByName(name: name) }
+    return Promise.onMain { try self.viewModelByName(name: name) }
   }
 
   func defaultArtboardViewModelAsync(artboardBy: ArtboardBy?) throws -> Promise<(any HybridViewModelSpec)?> {
-    return Promise.async { try self.defaultArtboardViewModel(artboardBy: artboardBy) }
+    return Promise.onMain { try self.defaultArtboardViewModel(artboardBy: artboardBy) }
   }
 
   func getArtboardCountAsync() throws -> Promise<Double> {
-    return Promise.async { self.artboardCount }
+    return Promise.onMain { self.artboardCount }
   }
 
   func getArtboardNamesAsync() throws -> Promise<[String]> {
-    return Promise.async { self.artboardNames }
+    return Promise.onMain { self.artboardNames }
   }
 
   func updateReferencedAssets(referencedAssets: ReferencedAssetsType) {