fix(hooks): reset during render on source change; main-hop legacy Android getViewModelInstance

Two fixes from the second cold review:

- The loading reset moved from the effect into render (adjust-state-
  during-render): the effect-time reset let React commit one frame
  pairing the new source with the previous instance at isLoading:
  false — a mismatch consumer guards can't catch (e.g. <RiveView
  file={fileB} dataBind={instanceA}/> reaching native) — and then
  disposed that instance while still committed. New unit test captures
  committed frames on a source flip and fails on the old behavior
  (26 mismatched frames).

- Legacy Android's HybridRiveView.getViewModelInstance() read
  controller.stateMachines on the JS thread while the main thread
  mutates it during startup (issue #297 race class; iOS already hops
  via MainThread.run). Now reads under
  runBlocking(Dispatchers.Main.immediate). No deterministic test is
  possible for the race; the ref-source e2e tests exercise this path
  on the android-legacy CI job.

Author: mfazekas

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

@@ -12,6 +12,7 @@ import app.rive.runtime.kotlin.core.Alignment as RiveAlignment
 import app.rive.runtime.kotlin.core.errors.*
 import android.util.Log
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withContext
 
 fun Variant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName?.toBindData(): BindData {
@@ -115,7 +116,13 @@ class HybridRiveView(val context: ThemedReactContext) : HybridRiveViewSpec() {
     }
 
   override fun getViewModelInstance(): HybridViewModelInstanceSpec? {
-    val viewModelInstance = view.getViewModelInstance() ?: return null
+    // Read on the main thread: the controller's state-machine list is mutated
+    // there during startup and the legacy runtime has no internal
+    // synchronization (issue #297 race class). Mirrors iOS's MainThread.run;
+    // `immediate` avoids a deadlock when already called on main.
+    val viewModelInstance =
+      runBlocking(Dispatchers.Main.immediate) { view.getViewModelInstance() }
+        ?: return null
     return HybridViewModelInstance(viewModelInstance)
   }
 

src/hooks/__tests__/useViewModelInstance.async.test.tsx

@@ -533,6 +533,55 @@ describe('useViewModelInstance async - disposal', () => {
     expect(defaultInstance.dispose).toHaveBeenCalled();
   });
 
+  it('never commits a frame pairing the new source with the old instance', async () => {
+    // On source change the reset must happen during render, not in the
+    // effect: otherwise React commits one frame of
+    // <RiveView file={fileB} dataBind={instanceA} /> (isLoading false, so
+    // consumer guards can't catch it) and then disposes instanceA while it
+    // is still the committed dataBind.
+    const instanceA = createMockViewModelInstance('A');
+    const fileA = createMockRiveFile({
+      defaultViewModel: createMockViewModel({ defaultInstance: instanceA }),
+    });
+    const instanceB = createMockViewModelInstance('B');
+    const fileB = createMockRiveFile({
+      defaultViewModel: createMockViewModel({ defaultInstance: instanceB }),
+    });
+
+    const frames: Array<{
+      file: RiveFile;
+      instance: ViewModelInstance | null | undefined;
+      isLoading: boolean;
+    }> = [];
+    function Probe({ file }: { file: RiveFile }) {
+      const { instance, isLoading } = useViewModelInstance(file, {
+        async: true,
+      });
+      React.useEffect(() => {
+        frames.push({ file, instance, isLoading });
+      });
+      return null;
+    }
+
+    const view = render(<Probe file={fileA} />);
+    await waitFor(() =>
+      expect(frames.some((f) => f.instance === instanceA)).toBe(true)
+    );
+
+    await act(async () => {
+      view.rerender(<Probe file={fileB} />);
+      await Promise.resolve();
+    });
+    await waitFor(() =>
+      expect(frames.some((f) => f.instance === instanceB)).toBe(true)
+    );
+
+    const mismatched = frames.filter(
+      (f) => f.file === fileB && f.instance === instanceA
+    );
+    expect(mismatched).toEqual([]);
+  });
+
   it('disposes the previous instance when the source changes', async () => {
     const instanceA = createMockViewModelInstance('A');
     const fileA = createMockRiveFile({

src/hooks/useViewModelInstanceAsync.ts

@@ -331,6 +331,25 @@ export function useViewModelInstanceAsync(
   const [result, setResult] =
     useState<UseViewModelInstanceAsyncResult>(LOADING_RESULT);
 
+  // Reset to the loading state during render (not in the effect) when the
+  // inputs change: an effect-time reset would let React commit one frame
+  // pairing the new source with the previous (about-to-be-disposed) instance
+  // at isLoading: false — a mismatch consumer guards cannot catch, and the
+  // old instance would be disposed while still committed as e.g. a view's
+  // dataBind. Resetting mid-render makes React re-render before committing.
+  const [prevDeps, setPrevDeps] = useState<readonly unknown[]>([
+    source,
+    instanceName,
+    artboardName,
+    viewModelName,
+    useNew,
+  ]);
+  const deps = [source, instanceName, artboardName, viewModelName, useNew];
+  if (deps.some((d, i) => d !== prevDeps[i])) {
+    setPrevDeps(deps);
+    setResult((prev) => (prev.isLoading ? prev : LOADING_RESULT));
+  }
+
   useEffect(() => {
     if (source === null) {
       // Source resolved to absent/failed rather than pending. `useRiveFile`
@@ -342,10 +361,6 @@ export function useViewModelInstanceAsync(
       return;
     }
 
-    // Reset to the loading state whenever the inputs change so we never expose a
-    // stale (and about-to-be-disposed) instance from a previous resolution.
-    setResult((prev) => (prev.isLoading ? prev : LOADING_RESULT));
-
     if (!source) {
       // `undefined`: not resolved yet (e.g. the file is still loading).
       return;