react-native-webgpu 0.6.0 → 0.6.2

package/README.md

@@ -8,20 +8,6 @@ WebGPU for React Native, powered by Dawn.
 
 [Installation instructions](https://wcandillon.github.io/react-native-webgpu/docs/getting-started/installation)
 
-## Expo config plugin
-
-The package ships with an Expo config plugin that disables Metal API validation in the iOS Xcode scheme, which is required to run WebGPU on the iOS Simulator (Metal API validation reports false positives for Dawn that do not occur on device). Because the plugin is part of the package, plugin and package versions are always aligned.
-
-```json
-{
-  "expo": {
-    "plugins": ["react-native-webgpu"]
-  }
-}
-```
-
-See the [Expo guide](https://wcandillon.github.io/react-native-webgpu/docs/getting-started/expo#config-plugin) for details.
-
 ## Contributing
 
-For detailed information on library development, building, testing, and contributing guidelines, please see [CONTRIBUTING.md](packages/webgpu/CONTRIBUTING.md).
+For detailed information on library development, building, testing, and contributing guidelines, please see [CONTRIBUTING.md](packages/webgpu/CONTRIBUTING.md).

package/android/cpp/cpp-adapter.cpp

@@ -25,8 +25,7 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUModule_initializeNative(
   auto jsCallInvoker{
       facebook::jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>{
           reinterpret_cast<facebook::react::CallInvokerHolder::javaobject>(
-              jsCallInvokerHolder)} -> cthis()
-          ->getCallInvoker()};
+              jsCallInvokerHolder)} -> cthis()->getCallInvoker()};
   auto platformContext =
       std::make_shared<rnwgpu::AndroidPlatformContext>(globalBlobModule);
   manager = std::make_shared<rnwgpu::RNWebGPUManager>(runtime, jsCallInvoker,
@@ -37,35 +36,58 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceChanged(
     JNIEnv *env, jobject thiz, jobject surface, jint contextId, jfloat width,
     jfloat height) {
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
-  registry.getSurfaceInfo(contextId)->resize(static_cast<int>(width),
-                                             static_cast<int>(height));
+  if (auto info = registry.getSurfaceInfo(contextId)) {
+    info->resize(static_cast<int>(width), static_cast<int>(height));
+  }
 }
 
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceCreate(
     JNIEnv *env, jobject thiz, jobject jSurface, jint contextId, jfloat width,
     jfloat height) {
+  if (manager == nullptr) {
+    return;
+  }
+  // ANativeWindow_fromSurface acquires a reference; SurfaceInfo releases it
+  // (via the releaser below) once it is done with the window.
   auto window = ANativeWindow_fromSurface(env, jSurface);
-  // ANativeWindow_acquire(window);
+  if (window == nullptr) {
+    return;
+  }
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   auto gpu = manager->_gpu;
   auto surface = manager->_platformContext->makeSurface(
       gpu, window, static_cast<int>(width), static_cast<int>(height));
-  registry
-      .getSurfaceInfoOrCreate(contextId, gpu, static_cast<int>(width),
-                              static_cast<int>(height))
-      ->switchToOnscreen(window, surface);
+  // Find-or-create + attach runs atomically under the registry lock so a
+  // concurrent destroyContext cannot orphan this surface.
+  auto info = registry.attachSurface(
+      contextId, gpu, static_cast<int>(width), static_cast<int>(height), window,
+      surface, [](void *nativeSurface) {
+        ANativeWindow_release(static_cast<ANativeWindow *>(nativeSurface));
+      });
+  // The attach is adopted at the next frame boundary by the rendering thread;
+  // schedule a flush so contexts that are not currently rendering still pick
+  // it up (and present their last offscreen frame).
+  manager->flushPendingSurfaceTransition(info);
 }
 
 extern "C" JNIEXPORT void JNICALL
 Java_com_webgpu_WebGPUView_switchToOffscreenSurface(JNIEnv *env, jobject thiz,
                                                     jint contextId) {
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
-  auto nativeSurface = registry.getSurfaceInfo(contextId)->switchToOffscreen();
-  // ANativeWindow_release(reinterpret_cast<ANativeWindow *>(nativeSurface));
+  if (auto info = registry.getSurfaceInfo(contextId)) {
+    info->switchToOffscreen();
+  }
 }
 
-extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceDestroy(
+extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onViewDestroyed(
     JNIEnv *env, jobject thiz, jint contextId) {
+  // The view dies with its Canvas (contextIds are never reused), so view
+  // teardown retires the registry entry. The JS-side cleanup
+  // (RNWebGPU.destroyContext) only handles entries that never had a native
+  // surface; see RNWebGPU::destroyContext for the ownership split.
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+  if (auto info = registry.getSurfaceInfo(contextId)) {
+    info->detachSurface();
+  }
   registry.removeSurfaceInfo(contextId);
-}
+}

package/android/src/main/java/com/webgpu/WebGPUAHBView.java

@@ -254,9 +254,9 @@ public class WebGPUAHBView extends View implements ImageReader.OnImageAvailableL
   protected void onDetachedFromWindow() {
     super.onDetachedFromWindow();
 
-    // Notify WebGPU that surface is being destroyed
+    // Detach: rendering falls back to the offscreen texture until reattach.
     if (mSurfaceCreated) {
-      mApi.surfaceDestroyed();
+      mApi.surfaceOffscreen();
       mSurfaceCreated = false;
     }
 

package/android/src/main/java/com/webgpu/WebGPUAPI.java

@@ -4,6 +4,13 @@ import android.view.Surface;
 
 import com.facebook.proguard.annotations.DoNotStrip;
 
+/**
+ * Surface lifecycle events a WebGPU child view reports. The registry entry
+ * itself is owned by the JS Canvas component (created lazily, removed via
+ * RNWebGPU.destroyContext on unmount); views only attach and detach surfaces.
+ * A detached context keeps rendering into an offscreen texture whose content
+ * is blitted onto the next attached surface.
+ */
 public interface WebGPUAPI {
 
   void surfaceCreated(
@@ -14,7 +21,5 @@ public interface WebGPUAPI {
     Surface surface
   );
 
-  void surfaceDestroyed();
-
   void surfaceOffscreen();
 }

package/android/src/main/java/com/webgpu/WebGPUSurfaceView.java

@@ -21,7 +21,9 @@ public class WebGPUSurfaceView extends SurfaceView implements SurfaceHolder.Call
   @Override
   protected void onDetachedFromWindow() {
     super.onDetachedFromWindow();
-    mApi.surfaceDestroyed();
+    // surfaceDestroyed() normally fires during detach as well; going offscreen
+    // is idempotent, so this is just a safety net for paths where it does not.
+    mApi.surfaceOffscreen();
   }
 
   @Override

package/android/src/main/java/com/webgpu/WebGPUTextureView.java

@@ -7,12 +7,11 @@ import android.view.Surface;
 import android.view.TextureView;
 import androidx.annotation.NonNull;
 
-import org.w3c.dom.Text;
-
 @SuppressLint("ViewConstructor")
 public class WebGPUTextureView extends TextureView implements TextureView.SurfaceTextureListener {
 
   WebGPUAPI mApi;
+  private Surface mSurface;
 
   public WebGPUTextureView(Context context, WebGPUAPI api) {
     super(context);
@@ -23,19 +22,24 @@ public class WebGPUTextureView extends TextureView implements TextureView.Surfac
 
   @Override
   public void onSurfaceTextureAvailable(@NonNull SurfaceTexture surfaceTexture, int width, int height) {
-    Surface surface = new Surface(surfaceTexture);
-    mApi.surfaceCreated(surface);
+    mSurface = new Surface(surfaceTexture);
+    mApi.surfaceCreated(mSurface);
   }
 
   @Override
   public void onSurfaceTextureSizeChanged(@NonNull SurfaceTexture surfaceTexture, int width, int height) {
-    Surface surface = new Surface(surfaceTexture);
-    mApi.surfaceChanged(surface);
+    mApi.surfaceChanged(mSurface);
   }
 
   @Override
   public boolean onSurfaceTextureDestroyed(@NonNull SurfaceTexture surfaceTexture) {
-    mApi.surfaceDestroyed();
+    // Detach first (synchronous through JNI) so the native side has dropped
+    // its window reference before we release ours.
+    mApi.surfaceOffscreen();
+    if (mSurface != null) {
+      mSurface.release();
+      mSurface = null;
+    }
     return true;
   }
 

package/android/src/main/java/com/webgpu/WebGPUView.java

@@ -73,16 +73,19 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
     onSurfaceChanged(surface, mContextId, width, height);
   }
 
-  @Override
-  public void surfaceDestroyed() {
-    onSurfaceDestroy(mContextId);
-  }
-
   @Override
   public void surfaceOffscreen() {
     switchToOffscreenSurface(mContextId);
   }
 
+  /**
+   * Called from WebGPUViewManager.onDropViewInstance when React removes this
+   * view: the view dies with its Canvas, so it retires the registry entry.
+   */
+  public void destroy() {
+    onViewDestroyed(mContextId);
+  }
+
   @DoNotStrip
   private native void onSurfaceCreate(
     Surface surface,
@@ -100,9 +103,9 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
   );
 
   @DoNotStrip
-  private native void onSurfaceDestroy(int contextId);
+  private native void switchToOffscreenSurface(int contextId);
 
   @DoNotStrip
-  private native void switchToOffscreenSurface(int contextId);
+  private native void onViewDestroyed(int contextId);
 
 }

package/android/src/main/java/com/webgpu/WebGPUViewManager.java

@@ -24,6 +24,12 @@ public class WebGPUViewManager extends WebGPUViewManagerSpec<WebGPUView> {
     return new WebGPUView(context);
   }
 
+  @Override
+  public void onDropViewInstance(@NonNull WebGPUView view) {
+    super.onDropViewInstance(view);
+    view.destroy();
+  }
+
   @Override
   @ReactProp(name = "transparent")
   public void setTransparent(WebGPUView view, boolean value) {

package/apple/MetalView.mm

@@ -23,27 +23,52 @@
 - (void)configure {
   auto size = self.frame.size;
   std::shared_ptr<rnwgpu::RNWebGPUManager> manager = [WebGPUModule getManager];
-  void *nativeSurface = (__bridge void *)self.layer;
+  if (manager == nullptr) {
+    return;
+  }
+  // Retain the layer for as long as SurfaceInfo holds the pointer: the
+  // latched attach (and the flush lambda that adopts it) can outlive this
+  // view, e.g. across a dev reload where the registry is cleared before
+  // dealloc runs. Balanced by the releaser below.
+  void *nativeSurface = (void *)CFBridgingRetain(self.layer);
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   auto gpu = manager->_gpu;
   auto surface = manager->_platformContext->makeSurface(
       gpu, nativeSurface, size.width, size.height);
-  registry
-      .getSurfaceInfoOrCreate([_contextId intValue], gpu, size.width,
-                              size.height)
-      ->switchToOnscreen(nativeSurface, surface);
+  // Find-or-create + attach runs atomically under the registry lock so a
+  // concurrent destroyContext cannot orphan this surface.
+  auto info = registry.attachSurface(
+      [_contextId intValue], gpu, size.width, size.height, nativeSurface,
+      surface, [](void *layer) {
+        // The releaser can run on the rendering thread; CALayer teardown
+        // belongs on the main thread.
+        dispatch_async(dispatch_get_main_queue(), ^{
+          CFBridgingRelease(layer);
+        });
+      });
+  // The attach is adopted at the next frame boundary by the rendering thread;
+  // schedule a flush so contexts that are not currently rendering still pick
+  // it up (and present their last offscreen frame).
+  manager->flushPendingSurfaceTransition(info);
 }
 
 - (void)update {
   auto size = self.frame.size;
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
-  registry.getSurfaceInfo([_contextId intValue])
-      ->resize(size.width, size.height);
+  if (auto info = registry.getSurfaceInfo([_contextId intValue])) {
+    info->resize(size.width, size.height);
+  }
 }
 
 - (void)dealloc {
+  // The view dies with its Canvas (contextIds are never reused), so view
+  // teardown retires the registry entry. The JS-side cleanup
+  // (RNWebGPU.destroyContext) only handles entries that never had a native
+  // surface; see RNWebGPU::destroyContext for the ownership split.
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
-  // Remove the surface info from the registry
+  if (auto info = registry.getSurfaceInfo([_contextId intValue])) {
+    info->detachSurface();
+  }
   registry.removeSurfaceInfo([_contextId intValue]);
 }
 

package/cpp/jsi/NativeObject.h

@@ -9,6 +9,7 @@
 #include <memory>
 #include <mutex>
 #include <optional>
+#include <stdexcept>
 #include <string>
 #include <type_traits>
 #include <unordered_map>
@@ -48,6 +49,12 @@ public:
 
   void registerInstaller(const std::string &brand, InstallerFunc installer) {
     std::lock_guard<std::mutex> lock(_mutex);
+    if (_installers.count(brand) != 0) {
+      // The brand is the key unbox() uses to rebuild objects on worklet
+      // runtimes - a duplicate would let one class hijack another's unboxing.
+      throw std::runtime_error("Duplicate native object brand registered: " +
+                               brand);
+    }
     _installers[brand] = std::move(installer);
   }
 
@@ -235,6 +242,10 @@ public:
    * Each NativeObject<Derived> type has its own static cache.
    * Uses StaticRuntimeAwareCache to properly handle runtime lifecycle
    * and hot reload (where the main runtime is destroyed and recreated).
+   *
+   * Callers must hold getPrototypeCacheMutex(): the cache is reached
+   * concurrently from the main JS thread (create()) and from worklet
+   * runtime threads (BoxedWebGPUObject::unbox() -> installPrototype()).
    */
   static RuntimeAwareCache<PrototypeCacheEntry> &
   getPrototypeCache(jsi::Runtime &runtime) {
@@ -242,11 +253,22 @@ public:
     return cache.get(runtime);
   }
 
+  /**
+   * Per-class mutex guarding getPrototypeCache() and prototype
+   * installation. Serializes the StaticRuntimeAwareCache pointer swap
+   * (hot reload) and the per-runtime cache lookups.
+   */
+  static std::mutex &getPrototypeCacheMutex() {
+    static std::mutex mutex;
+    return mutex;
+  }
+
   /**
    * Ensure the prototype is installed for this runtime.
    * Called automatically by create(), but can be called manually.
    */
   static void installPrototype(jsi::Runtime &runtime) {
+    std::lock_guard<std::mutex> lock(getPrototypeCacheMutex());
     auto &entry = getPrototypeCache(runtime).get(runtime);
     if (entry.prototype.has_value()) {
       return; // Already installed
@@ -278,6 +300,49 @@ public:
       defineProperty.call(runtime, prototype, toStringTag, descriptor);
     }
 
+    // Install a generic toJSON so JSON.stringify works: data properties live
+    // as getters on this shared prototype, and JSON.stringify only serializes
+    // own enumerable properties (so it would otherwise produce {}).
+    auto toJSON = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "toJSON"), 0,
+        [](jsi::Runtime &rt, const jsi::Value &thisVal,
+           const jsi::Value * /*args*/, size_t /*count*/) -> jsi::Value {
+          auto thisObj = thisVal.getObject(rt);
+          auto objectCtor = rt.global().getPropertyAsObject(rt, "Object");
+          auto getPrototypeOf =
+              objectCtor.getPropertyAsFunction(rt, "getPrototypeOf");
+          auto proto = getPrototypeOf.call(rt, thisObj);
+          jsi::Object result(rt);
+          if (!proto.isObject()) {
+            return std::move(result);
+          }
+          auto getOwnPropertyNames =
+              objectCtor.getPropertyAsFunction(rt, "getOwnPropertyNames");
+          auto names =
+              getOwnPropertyNames.call(rt, proto).getObject(rt).getArray(rt);
+          size_t length = names.size(rt);
+          for (size_t i = 0; i < length; i++) {
+            auto nameValue = names.getValueAtIndex(rt, i);
+            if (!nameValue.isString()) {
+              continue;
+            }
+            auto name = nameValue.getString(rt).utf8(rt);
+            if (name == "constructor" || name == "toJSON") {
+              continue;
+            }
+            // Read off `this` so prototype getters evaluate against the
+            // object's native state. Getters that throw keep throwing.
+            auto value = thisObj.getProperty(rt, name.c_str());
+            if (value.isObject() && value.getObject(rt).isFunction(rt)) {
+              // Skip methods - JSON.stringify would drop them anyway
+              continue;
+            }
+            result.setProperty(rt, name.c_str(), value);
+          }
+          return std::move(result);
+        });
+    prototype.setProperty(runtime, "toJSON", toJSON);
+
     // Cache the prototype
     entry.prototype = std::move(prototype);
   }
@@ -303,6 +368,7 @@ public:
 
     installPrototype(runtime);
 
+    std::lock_guard<std::mutex> lock(getPrototypeCacheMutex());
     auto &entry = getPrototypeCache(runtime).get(runtime);
     if (!entry.prototype.has_value()) {
       return;
@@ -346,14 +412,17 @@ public:
     obj.setNativeState(runtime, instance);
 
     // Set prototype
-    auto &entry = getPrototypeCache(runtime).get(runtime);
-    if (entry.prototype.has_value()) {
-      // Use Object.setPrototypeOf to set the prototype
-      auto objectCtor =
-          runtime.global().getPropertyAsObject(runtime, "Object");
-      auto setPrototypeOf =
-          objectCtor.getPropertyAsFunction(runtime, "setPrototypeOf");
-      setPrototypeOf.call(runtime, obj, *entry.prototype);
+    {
+      std::lock_guard<std::mutex> lock(getPrototypeCacheMutex());
+      auto &entry = getPrototypeCache(runtime).get(runtime);
+      if (entry.prototype.has_value()) {
+        // Use Object.setPrototypeOf to set the prototype
+        auto objectCtor =
+            runtime.global().getPropertyAsObject(runtime, "Object");
+        auto setPrototypeOf =
+            objectCtor.getPropertyAsFunction(runtime, "setPrototypeOf");
+        setPrototypeOf.call(runtime, obj, *entry.prototype);
+      }
     }
 
     // Set memory pressure hint for GC

package/cpp/jsi/RuntimeAwareCache.cpp

@@ -2,6 +2,6 @@
 
 namespace rnwgpu {
 
-jsi::Runtime *BaseRuntimeAwareCache::_mainRuntime = nullptr;
+std::atomic<jsi::Runtime *> BaseRuntimeAwareCache::_mainRuntime{nullptr};
 
 } // namespace rnwgpu

package/cpp/jsi/RuntimeAwareCache.h

@@ -2,8 +2,10 @@
 
 #include <jsi/jsi.h>
 
+#include <atomic>
 #include <cassert>
 #include <memory>
+#include <mutex>
 #include <unordered_map>
 #include <utility>
 
@@ -15,17 +17,22 @@ namespace jsi = facebook::jsi;
 
 class BaseRuntimeAwareCache {
 public:
-  static void setMainJsRuntime(jsi::Runtime *rt) { _mainRuntime = rt; }
+  static void setMainJsRuntime(jsi::Runtime *rt) {
+    // Atomic: hot reload rewrites this from the JS thread while worklet
+    // runtime threads read it concurrently.
+    _mainRuntime.store(rt, std::memory_order_release);
+  }
   static jsi::Runtime *getMainJsRuntime() {
-    assert(_mainRuntime != nullptr &&
+    auto *rt = _mainRuntime.load(std::memory_order_acquire);
+    assert(rt != nullptr &&
            "Expected main Javascript runtime to be set in the "
            "BaseRuntimeAwareCache class.");
 
-    return _mainRuntime;
+    return rt;
   }
 
 private:
-  static jsi::Runtime *_mainRuntime;
+  static std::atomic<jsi::Runtime *> _mainRuntime;
 };
 
 /**
@@ -56,7 +63,10 @@ class RuntimeAwareCache : public BaseRuntimeAwareCache,
 public:
   void onRuntimeDestroyed(jsi::Runtime *rt) override {
     if (getMainJsRuntime() != rt) {
-      // We are removing a secondary runtime
+      // We are removing a secondary runtime. This is invoked by
+      // RuntimeLifecycleMonitor on the destroyed runtime's thread, which may
+      // run concurrently with get() on another runtime's thread.
+      std::lock_guard<std::mutex> lock(_secondaryCachesMutex);
       _secondaryRuntimeCaches.erase(rt);
     }
   }
@@ -75,6 +85,14 @@ public:
     if (getMainJsRuntime() == &rt) {
       return _primaryCache;
     } else {
+      // Guard the secondary map: it can be mutated concurrently by get()
+      // on a worklet runtime's thread and by onRuntimeDestroyed() when
+      // another secondary runtime is torn down. The main-runtime path above
+      // stays lock-free. References into the map remain valid after the
+      // lock is released (unordered_map never invalidates references on
+      // insert/erase of other keys, and this runtime's entry can only be
+      // erased from this runtime's own thread).
+      std::lock_guard<std::mutex> lock(_secondaryCachesMutex);
       if (_secondaryRuntimeCaches.count(&rt) == 0) {
         // we only add listener when the secondary runtime is used, this assumes
         // that the secondary runtime is terminated first. This lets us avoid
@@ -88,11 +106,12 @@ public:
         T cache;
         _secondaryRuntimeCaches.emplace(&rt, std::move(cache));
       }
+      return _secondaryRuntimeCaches.at(&rt);
     }
-    return _secondaryRuntimeCaches.at(&rt);
   }
 
 private:
+  std::mutex _secondaryCachesMutex;
   std::unordered_map<void *, T> _secondaryRuntimeCaches;
   T _primaryCache;
 };

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -31,9 +31,9 @@
 #include "GPURenderPassEncoder.h"
 #include "GPURenderPipeline.h"
 #include "GPUSampler.h"
+#include "GPUShaderModule.h"
 #include "GPUSharedFence.h"
 #include "GPUSharedTextureMemory.h"
-#include "GPUShaderModule.h"
 #include "GPUSupportedLimits.h"
 #include "GPUTexture.h"
 #include "GPUTextureView.h"
@@ -237,7 +237,20 @@ void RNWebGPUManager::installWebGPUWorkletHelpers(jsi::Runtime &runtime) {
   runtime.global().setProperty(runtime, "__webgpuBox", std::move(boxFunc));
 }
 
+void RNWebGPUManager::flushPendingSurfaceTransition(
+    std::shared_ptr<SurfaceInfo> info) {
+  if (info == nullptr || _jsCallInvoker == nullptr) {
+    return;
+  }
+  _jsCallInvoker->invokeAsync(
+      [info = std::move(info)] { info->applyPendingAttach(); });
+}
+
 RNWebGPUManager::~RNWebGPUManager() {
+  // Drop all canvas registry entries: after a reload the JS side restarts its
+  // contextId counter, and stale entries would alias new canvases onto dead
+  // surfaces.
+  SurfaceRegistry::getInstance().clear();
   _jsRuntime = nullptr;
   _jsCallInvoker = nullptr;
 }

package/cpp/rnwgpu/RNWebGPUManager.h

@@ -34,6 +34,15 @@ public:
    */
   static void installWebGPUWorkletHelpers(jsi::Runtime &runtime);
 
+  /**
+   * Applies a surface attach latched by the platform UI thread (see
+   * SurfaceInfo::applyPendingAttach) from the JS thread. Surface attaches are
+   * normally adopted at the next frame boundary by whichever thread renders;
+   * this flush covers contexts that are not actively rendering (static
+   * content), so the last offscreen frame still makes it on screen.
+   */
+  void flushPendingSurfaceTransition(std::shared_ptr<SurfaceInfo> info);
+
 private:
   jsi::Runtime *_jsRuntime;
   std::shared_ptr<facebook::react::CallInvoker> _jsCallInvoker;