react-native-webgpu 0.9.0 → 0.10.0

package/Package.swift

@@ -0,0 +1,191 @@
+// swift-tools-version: 5.9
+// Generated by scripts/generate-package-swift.ts — do not edit by hand.
+// Re-run that script after a new Dawn release to update the URL/checksum below.
+import Foundation
+import PackageDescription
+
+// Integration model: a local Swift package next to a CocoaPods install.
+//
+// This manifest targets React Native 0.81+ (the package's peer range), where
+// React Native's own headers and the RNWgpuViewSpec codegen output only exist
+// inside the consuming app's CocoaPods install. Add this package as a local
+// Swift Package dependency in place of the react-native-webgpu pod (export
+// RNWGPU_USE_SPM=1 for `pod install`) and keep running `pod install` for
+// everything else. The header search paths below point into that Pods
+// directory. They can only be expressed as `unsafeFlags`, and SwiftPM rejects
+// unsafeFlags in anything but a path dependency, so this package can only be
+// consumed locally, never by URL and version.
+//
+// React Native 0.87 added SwiftPM autolinking. There, a dependency shipping
+// its own Package.swift is treated as self-managed and referenced directly,
+// and it consumes React Native's headers as SwiftPM products (ReactHeaders,
+// ReactNativeHeaders, ReactNativeDependenciesHeaders, plus ReactAppHeaders
+// from the app's generated codegen package) with no CocoaPods at all. This
+// manifest does not implement that model yet: on a 0.87+ app that has opted
+// into SwiftPM autolinking it is picked up as self-managed but cannot find
+// React Native's headers. Keep CocoaPods for React Native on those apps.
+
+// Absolute location of this package. Xcode may hand over a symlink (React
+// Native 0.87's autolinker does), so resolve it before deriving sibling paths.
+let packageRoot = URL(fileURLWithPath: Context.packageDirectory)
+  .resolvingSymlinksInPath().path
+let sibling = { (relative: String) -> String in
+  URL(fileURLWithPath: "\(packageRoot)/\(relative)").standardized.path
+}
+
+// Where the consuming app's Pods live. PODS_ROOT is exported by Xcode.app for
+// a real build, but never by plain `xcodebuild`, and never while Xcode indexes
+// the manifest before a first build. SwiftPM also caches manifest evaluations,
+// so an evaluation that ran without it would otherwise be cached with an empty
+// include list and surface later as header-not-found errors. Fall back to
+// where Pods sit relative to this package for every standard app layout, so
+// the result is the same with or without the environment variable.
+let podsRootCandidates = [
+  sibling("../../ios/Pods"), // consumer: <app>/node_modules/react-native-webgpu
+  sibling("../../apps/spm-example/ios/Pods"), // this monorepo
+]
+let podsRoot =
+  ProcessInfo.processInfo.environment["PODS_ROOT"]
+  ?? podsRootCandidates.first { FileManager.default.fileExists(atPath: $0) }
+  ?? podsRootCandidates[0]
+
+// Skia Graphite and WebGPU must link the exact same Dawn, or the pair links
+// fine and crashes at runtime. react-native-skia's podspec enforces this at
+// `pod install` time by comparing its libs/.dawn-version against this
+// package's `dawn` field. A Swift package has no install hook, so the same
+// check runs here, at manifest evaluation. SwiftPM caches evaluations, so
+// after changing either package's Dawn version reset the package caches
+// (File > Packages > Reset Package Caches) if this does not re-run.
+let dawnReleaseTag = "dawn-chrome-m154"
+let skiaCandidates = [
+  sibling("../@shopify/react-native-skia"), // consumer: sibling in node_modules
+  sibling("../../node_modules/@shopify/react-native-skia"), // this monorepo
+]
+for skia in skiaCandidates {
+  // Only Graphite builds of react-native-skia write this marker (Ganesh
+  // builds do not link Dawn and impose no constraint).
+  guard let data = FileManager.default.contents(atPath: "\(skia)/libs/.dawn-version"),
+    let skiaDawn = String(data: data, encoding: .utf8)?
+      .trimmingCharacters(in: .whitespacesAndNewlines)
+  else { continue }
+  if skiaDawn != dawnReleaseTag {
+    fatalError(
+      """
+      react-native-webgpu: Dawn version mismatch. This package links \(dawnReleaseTag) \
+      but the @shopify/react-native-skia Graphite build at \(skia) links \(skiaDawn). \
+      Align the two packages so the app contains exactly one Dawn.
+      """)
+  }
+  break
+}
+
+// Static-library Pods layout. With `use_frameworks!` CocoaPods keeps headers
+// inside each framework instead and none of these paths exist; the podspec
+// refuses RNWGPU_USE_SPM in that mode.
+let publicHeaders = "\(podsRoot)/Headers/Public"
+let privateHeaders = "\(podsRoot)/Headers/Private"
+let headerSearchPaths = [
+  publicHeaders,
+  // Yoga's headers are CocoaPods-private (apps aren't meant to use Yoga's
+  // C++ API directly), but React-Fabric's view props headers include them
+  // transitively.
+  "\(privateHeaders)/Yoga",
+  "\(publicHeaders)/React-Core",
+  "\(publicHeaders)/React-jsi",
+  "\(publicHeaders)/React-callinvoker",
+  "\(publicHeaders)/React-NativeModulesApple",
+  "\(publicHeaders)/React-RCTFabric",
+  "\(publicHeaders)/ReactCodegen",
+  "\(publicHeaders)/RCT-Folly",
+  "\(publicHeaders)/RCTRequired",
+  "\(publicHeaders)/RCTTypeSafety",
+  "\(publicHeaders)/FBLazyVector",
+  "\(publicHeaders)/ReactCommon",
+  "\(publicHeaders)/React-Fabric",
+  "\(publicHeaders)/React-graphics",
+  "\(publicHeaders)/React-utils",
+  "\(publicHeaders)/React-featureflags",
+  "\(publicHeaders)/React-rendererdebug",
+  "\(publicHeaders)/React-debug",
+  "\(publicHeaders)/React-timing",
+  "\(publicHeaders)/React-runtimescheduler",
+  "\(publicHeaders)/React-rendererconsistency",
+  "\(publicHeaders)/React-performancetimeline",
+  "\(publicHeaders)/React-runtimeexecutor",
+  "\(publicHeaders)/React-cxxreact",
+  "\(publicHeaders)/hermes-engine",
+  "\(publicHeaders)/glog",
+  "\(publicHeaders)/DoubleConversion",
+  "\(publicHeaders)/fmt",
+  "\(publicHeaders)/fast_float",
+]
+// The only unsafe flags left: .headerSearchPath cannot escape the target
+// path, and these live in the app's Pods directory.
+let cFamilyIncludeFlags = headerSearchPaths.map { "-I\($0)" }
+let follyDefines: [(name: String, value: String?)] = [
+  ("FOLLY_NO_CONFIG", nil),
+  ("FOLLY_MOBILE", "1"),
+  ("FOLLY_USE_LIBCPP", "1"),
+  ("FOLLY_CFG_NO_COROUTINES", "1"),
+  ("FOLLY_HAVE_CLOCK_GETTIME", "1"),
+]
+
+// Unlike a native Xcode target, SwiftPM doesn't generate an implicit
+// per-target header map, so quoted includes only resolve within the
+// including file's own directory. The sources use bare cross-directory
+// includes (e.g. apple/WebGPUModule.h includes "RNWebGPUManager.h" from
+// cpp/rnwgpu), so every directory that's the target of one of those bare
+// includes has to be listed explicitly here.
+let internalHeaderDirs = [
+  "apple",
+  // "cpp" itself resolves the "webgpu/..." and "dawn/..." namespaced
+  // includes. Those two directories are only present locally when built via
+  // `yarn install-dawn` (without the xcframework's embedded headers); a
+  // remote binaryTarget's xcframework embeds them instead (see
+  // build-dawn.yml's `-headers` flag), so "cpp" not containing them there
+  // is fine — the xcframework's own headers cover it.
+  "cpp",
+  "cpp/jsi",
+  "cpp/rnwgpu",
+  "cpp/rnwgpu/api",
+  "cpp/rnwgpu/api/descriptors",
+  "cpp/rnwgpu/async",
+]
+
+let package = Package(
+  name: "react-native-webgpu",
+  platforms: [.iOS("15.1"), .macOS("11.0")],
+  products: [
+    .library(name: "react-native-webgpu", targets: ["react-native-webgpu"])
+  ],
+  targets: [
+    // Dawn's compiled WebGPU implementation. The xcframework embeds the
+    // `webgpu/` and `dawn/` C headers per-slice (built via `-headers` in
+    // build-dawn.yml), so SPM exposes them to dependents automatically.
+    .binaryTarget(
+      name: "WebGPUDawn",
+      url: "https://github.com/wcandillon/react-native-webgpu/releases/download/dawn-chrome-m154/dawn-apple-dawn-chrome-m154.xcframework.zip",
+      checksum: "896575ffbc99610198a83d061f8c5a2789139b7f16c669fbf3a9f7a7ac9be123"
+    ),
+    .target(
+      name: "react-native-webgpu",
+      dependencies: ["WebGPUDawn"],
+      path: ".",
+      sources: ["apple", "cpp/jsi", "cpp/rnwgpu"],
+      publicHeadersPath: "apple",
+      cSettings: internalHeaderDirs.map { CSetting.headerSearchPath($0) }
+        + follyDefines.map { CSetting.define($0.name, to: $0.value) }
+        + [.unsafeFlags(cFamilyIncludeFlags)],
+      cxxSettings: internalHeaderDirs.map { CXXSetting.headerSearchPath($0) }
+        + follyDefines.map { CXXSetting.define($0.name, to: $0.value) }
+        + [.unsafeFlags(cFamilyIncludeFlags)],
+      linkerSettings: [
+        .linkedFramework("AVFoundation"),
+        .linkedFramework("CoreMedia"),
+        .linkedFramework("CoreVideo"),
+        .linkedFramework("ImageIO"),
+      ]
+    ),
+  ],
+  cxxLanguageStandard: .cxx20
+)

package/android/CMakeLists.txt

@@ -49,8 +49,7 @@ add_library(${PACKAGE_NAME} SHARED
     ../cpp/rnwgpu/api/GPUCanvasContext.cpp
     ../cpp/rnwgpu/RNWebGPUManager.cpp
     ../cpp/jsi/Promise.cpp
-    ../cpp/jsi/RuntimeLifecycleMonitor.cpp
-    ../cpp/jsi/RuntimeAwareCache.cpp
+    ../cpp/jsi/JSICache.cpp
     ../cpp/rnwgpu/async/RuntimeContext.cpp
     ../cpp/rnwgpu/async/AsyncTaskHandle.cpp
 )

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

@@ -2,6 +2,7 @@ package com.webgpu;
 
 import android.annotation.SuppressLint;
 import android.content.Context;
+import android.graphics.PixelFormat;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 
@@ -12,12 +13,20 @@ public class WebGPUSurfaceView extends SurfaceView implements SurfaceHolder.Call
 
   WebGPUAPI mApi;
 
-  public WebGPUSurfaceView(Context context, WebGPUAPI api) {
+  public WebGPUSurfaceView(Context context, WebGPUAPI api, boolean zOrderOnTop, boolean opaque) {
     super(context);
     mApi = api;
+    setZOrderOnTop(zOrderOnTop);
+    setOpaque(opaque);
     getHolder().addCallback(this);
   }
 
+  // The format drives the compositor's opaque flag for this layer. It can
+  // change on a live surface: SurfaceView reports it through surfaceChanged.
+  public void setOpaque(boolean opaque) {
+    getHolder().setFormat(opaque ? PixelFormat.OPAQUE : PixelFormat.TRANSLUCENT);
+  }
+
   @Override
   protected void onDetachedFromWindow() {
     super.onDetachedFromWindow();

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

@@ -13,10 +13,10 @@ public class WebGPUTextureView extends TextureView implements TextureView.Surfac
   WebGPUAPI mApi;
   private Surface mSurface;
 
-  public WebGPUTextureView(Context context, WebGPUAPI api) {
+  public WebGPUTextureView(Context context, WebGPUAPI api, boolean opaque) {
     super(context);
     mApi = api;
-    setOpaque(false);
+    setOpaque(opaque);
     setSurfaceTextureListener(this);
   }
 

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

@@ -1,7 +1,6 @@
 package com.webgpu;
 
 import android.content.Context;
-import android.os.Build;
 import android.view.Surface;
 import android.view.View;
 
@@ -13,7 +12,11 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
 
 
   private int mContextId;
-  private boolean mTransparent = false;
+  private boolean mOpaque = true;
+  private String mSurfaceType = "auto";
+  private boolean mZOrderOnTop = false;
+  private boolean mAppliedTextureView;
+  private boolean mAppliedZOrderOnTop;
   private WebGPUModule mModule;
   private View mView = null;
 
@@ -31,30 +34,59 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
     mContextId = contextId;
   }
 
-  public void setTransparent(boolean value) {
-    Context ctx = getContext();
-    if (value != mTransparent || mView == null) {
+  public void setOpaque(boolean value) {
+    mOpaque = value;
+  }
+
+  public void setSurfaceType(String value) {
+    mSurfaceType = value;
+  }
+
+  public void setZOrderOnTop(boolean value) {
+    mZOrderOnTop = value;
+  }
+
+  // Apply the complete prop transaction once, after contextId and all rendering
+  // options have arrived. Only a change of backing view (or of zOrderOnTop,
+  // which a SurfaceView must know before it attaches) replaces the child;
+  // opacity is applied in place.
+  public void updateView() {
+    boolean textureView = "TextureView".equals(mSurfaceType)
+      || (!"SurfaceView".equals(mSurfaceType) && !mOpaque);
+    boolean zOrderOnTop = !textureView && mZOrderOnTop;
+    if (mView == null || textureView != mAppliedTextureView
+        || zOrderOnTop != mAppliedZOrderOnTop) {
       if (mView != null) {
         removeView(mView);
       }
-      mTransparent = value;
-      if (mTransparent) {
-//        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-//          mView = new WebGPUAHBView(ctx, this);
-//        } else {
-          mView = new WebGPUTextureView(ctx, this);
-//        }
-      } else {
-        mView = new WebGPUSurfaceView(ctx, this);
-      }
+      mAppliedTextureView = textureView;
+      mAppliedZOrderOnTop = zOrderOnTop;
+      Context ctx = getContext();
+      mView = textureView
+        ? new WebGPUTextureView(ctx, this, mOpaque)
+        : new WebGPUSurfaceView(ctx, this, zOrderOnTop, mOpaque);
       addView(mView);
+      // ReactViewGroup.requestLayout() is a deliberate no-op, so addView outside
+      // the layout pass never lays the child out; do it by hand or the new view
+      // stays 0x0 and never gets a surface.
+      layoutChild();
+    } else if (textureView) {
+      ((WebGPUTextureView) mView).setOpaque(mOpaque);
+    } else {
+      ((WebGPUSurfaceView) mView).setOpaque(mOpaque);
     }
   }
 
+  private void layoutChild() {
+    mView.layout(0, 0, getMeasuredWidth(), getMeasuredHeight());
+  }
+
   @Override
   protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
     super.onLayout(changed, left, top, right, bottom);
-    mView.layout(0, 0, this.getMeasuredWidth(), this.getMeasuredHeight());
+    if (mView != null) {
+      layoutChild();
+    }
   }
 
   @Override

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

@@ -1,7 +1,6 @@
 package com.webgpu;
 
 import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
 
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.uimanager.ThemedReactContext;
@@ -31,9 +30,27 @@ public class WebGPUViewManager extends WebGPUViewManagerSpec<WebGPUView> {
   }
 
   @Override
-  @ReactProp(name = "transparent")
-  public void setTransparent(WebGPUView view, boolean value) {
-    view.setTransparent(value);
+  @ReactProp(name = "opaque", defaultBoolean = true)
+  public void setOpaque(WebGPUView view, boolean value) {
+    view.setOpaque(value);
+  }
+
+  @Override
+  @ReactProp(name = "androidSurfaceType")
+  public void setAndroidSurfaceType(WebGPUView view, String value) {
+    view.setSurfaceType(value);
+  }
+
+  @Override
+  @ReactProp(name = "androidZOrderOnTop")
+  public void setAndroidZOrderOnTop(WebGPUView view, boolean value) {
+    view.setZOrderOnTop(value);
+  }
+
+  @Override
+  protected void onAfterUpdateTransaction(@NonNull WebGPUView view) {
+    super.onAfterUpdateTransaction(view);
+    view.updateView();
   }
 
   @Override

package/cpp/jsi/JSICache.cpp

@@ -0,0 +1,97 @@
+#include "JSICache.h"
+
+#include <iterator>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+namespace rnwgpu {
+
+namespace {
+// Hidden global holding the per-runtime cache object. Named so it is
+// obviously ours if it ever shows up in a debugger or heap snapshot.
+constexpr const char *kGlobalName = "__rnwgpuJsiCache";
+} // namespace
+
+std::mutex JSICache::_registryMutex;
+std::unordered_map<jsi::Runtime *, std::weak_ptr<JSICache>> JSICache::_registry;
+
+JSICache &JSICache::get(jsi::Runtime &runtime) {
+  {
+    std::lock_guard<std::mutex> lock(_registryMutex);
+    auto it = _registry.find(&runtime);
+    if (it != _registry.end()) {
+      if (auto cache = it->second.lock()) {
+        // The cache is kept alive by `runtime`'s global, so the raw
+        // reference stays valid for as long as the caller may legally use
+        // `runtime` on this thread.
+        return *cache;
+      }
+      // Expired: the runtime that owned this entry is gone and `&runtime` is
+      // a new runtime reusing the address. Fall through and recreate.
+    }
+  }
+  auto cache = getOrCreateOnGlobal(runtime);
+  {
+    std::lock_guard<std::mutex> lock(_registryMutex);
+    // Drop entries of runtimes that are gone so the map does not grow by one
+    // stale pointer per reload / worklet runtime.
+    for (auto it = _registry.begin(); it != _registry.end();) {
+      it = it->second.expired() ? _registry.erase(it) : std::next(it);
+    }
+    _registry[&runtime] = cache;
+  }
+  return *cache;
+}
+
+std::shared_ptr<JSICache> JSICache::getOrCreateOnGlobal(jsi::Runtime &runtime) {
+  auto global = runtime.global();
+  auto existing = global.getProperty(runtime, kGlobalName);
+  if (existing.isObject()) {
+    auto obj = existing.getObject(runtime);
+    if (obj.hasNativeState<JSICache>(runtime)) {
+      return obj.getNativeState<JSICache>(runtime);
+    }
+  }
+  if (!existing.isUndefined()) {
+    // Something else already claimed our global. The most likely cause is two
+    // copies of react-native-webgpu loaded in one process (each has its own
+    // JSICache type, so the NativeState check above fails). Say so instead of
+    // letting Object.defineProperty throw a bare TypeError on the
+    // non-configurable property.
+    throw std::runtime_error(
+        std::string("react-native-webgpu: global.") + kGlobalName +
+        " already exists but is not our JSICache. Is react-native-webgpu "
+        "linked twice, or is another module using this global?");
+  }
+  auto cache = std::make_shared<JSICache>();
+  jsi::Object holder(runtime);
+  holder.setNativeState(runtime, cache);
+  // Non-enumerable, non-writable, non-configurable: JS code must not be able
+  // to drop the holder (which would finalize the cache under our feet).
+  auto objectCtor = global.getPropertyAsObject(runtime, "Object");
+  auto defineProperty =
+      objectCtor.getPropertyAsFunction(runtime, "defineProperty");
+  jsi::Object descriptor(runtime);
+  descriptor.setProperty(runtime, "value", std::move(holder));
+  descriptor.setProperty(runtime, "writable", false);
+  descriptor.setProperty(runtime, "enumerable", false);
+  descriptor.setProperty(runtime, "configurable", false);
+  defineProperty.call(runtime, global,
+                      jsi::String::createFromAscii(runtime, kGlobalName),
+                      descriptor);
+  return cache;
+}
+
+jsi::Object *JSICache::getPrototype(PrototypeKey key) {
+  auto it = _prototypes.find(key);
+  return it == _prototypes.end() ? nullptr : &it->second;
+}
+
+jsi::Object &JSICache::setPrototype(PrototypeKey key, jsi::Object prototype) {
+  auto [it, inserted] = _prototypes.insert_or_assign(key, std::move(prototype));
+  (void)inserted;
+  return it->second;
+}
+
+} // namespace rnwgpu

package/cpp/jsi/JSICache.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <mutex>
+#include <typeindex>
+#include <unordered_map>
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+/**
+ * Per-runtime store for JSI values that native code wants to keep across
+ * calls (currently: the prototype object of every NativeObject class).
+ *
+ * Ownership model (borrowed from react-native-nitro-modules' JSICache):
+ *
+ * - One JSICache exists per jsi::Runtime. It is attached as the NativeState
+ *   of a hidden object stored on that runtime's `global`, so the RUNTIME owns
+ *   the cache. When the runtime is destroyed the engine finalizes the object,
+ *   ~JSICache runs while the runtime is still alive, and every cached
+ *   jsi::Object is released correctly. Nothing outlives its runtime and
+ *   nothing has to be leaked.
+ *
+ * - Native code reaches the cache through JSICache::get(runtime). A static
+ *   map of std::weak_ptr, keyed by jsi::Runtime*, makes the lookup cheap; the
+ *   pointer is only a map key, never proof that a runtime is alive. If the
+ *   weak_ptr is expired (the runtime that owned it is gone) the entry is
+ *   recreated on the runtime asking for it. This is what makes an in-process
+ *   runtime recreate (expo-updates OTA apply, DevSettings.reload) safe even
+ *   when the new runtime is allocated at the address of the freed one: the
+ *   old cache was destroyed with the old runtime, so the reused address can
+ *   only ever resolve to a fresh cache.
+ *
+ * - The cache itself is not locked: a jsi::Runtime is single-threaded, and
+ *   the cache is only ever touched from its runtime's thread. Only the static
+ *   runtime -> cache map is guarded.
+ *
+ * The same mechanism works for worklet runtimes (Reanimated UI runtime,
+ * createWorkletRuntime, ...); each gets its own JSICache.
+ */
+class JSICache final : public jsi::NativeState {
+public:
+  /**
+   * Key identifying one cached prototype: the C++ type of the NativeObject
+   * subclass (std::type_index(typeid(Derived))), as in Nitro. It prints as
+   * the class name in a debugger.
+   */
+  using PrototypeKey = std::type_index;
+
+  /**
+   * Returns the cache owned by `runtime`, creating it on first use. Must be
+   * called on the runtime's thread.
+   */
+  static JSICache &get(jsi::Runtime &runtime);
+
+  /**
+   * Returns the cached prototype for `key` or nullptr if none was stored.
+   *
+   * The pointer points into `_prototypes`. std::unordered_map never
+   * invalidates pointers/references to elements on insert or rehash (only on
+   * erase of that element, which we never do), so it stays valid for as long
+   * as the runtime does. Do not swap the container for one without that
+   * guarantee (std::vector, absl::flat_hash_map, ...).
+   */
+  jsi::Object *getPrototype(PrototypeKey key);
+
+  /**
+   * Stores (or replaces) the prototype for `key` and returns it.
+   */
+  jsi::Object &setPrototype(PrototypeKey key, jsi::Object prototype);
+
+  JSICache() = default;
+  ~JSICache() override = default;
+  JSICache(const JSICache &) = delete;
+  JSICache &operator=(const JSICache &) = delete;
+
+private:
+  static std::shared_ptr<JSICache> getOrCreateOnGlobal(jsi::Runtime &runtime);
+
+  std::unordered_map<PrototypeKey, jsi::Object> _prototypes;
+
+  // Runtime -> cache. Weak on purpose: the runtime's global owns the cache.
+  static std::mutex _registryMutex;
+  static std::unordered_map<jsi::Runtime *, std::weak_ptr<JSICache>> _registry;
+};
+
+} // namespace rnwgpu