react-native-wgpu 0.5.13 → 0.5.14

package/cpp/jsi/RuntimeAwareCache.h

@@ -1,100 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include <cassert>
-#include <memory>
-#include <unordered_map>
-#include <utility>
-
-#include "RuntimeLifecycleMonitor.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class BaseRuntimeAwareCache {
-public:
-  static void setMainJsRuntime(jsi::Runtime *rt) { _mainRuntime = rt; }
-  static jsi::Runtime *getMainJsRuntime() {
-    assert(_mainRuntime != nullptr &&
-           "Expected main Javascript runtime to be set in the "
-           "BaseRuntimeAwareCache class.");
-
-    return _mainRuntime;
-  }
-
-private:
-  static jsi::Runtime *_mainRuntime;
-};
-
-/**
- * Provides a way to keep data specific to a jsi::Runtime instance that gets
- * cleaned up when that runtime is destroyed. This is necessary because JSI does
- * not allow for its associated objects to be retained past the runtime
- * lifetime. If an object (e.g. jsi::Values or jsi::Function instances) is kept
- * after the runtime is torn down, its destructor (once it is destroyed
- * eventually) will result in a crash (JSI objects keep a pointer to memory
- * managed by the runtime, accessing that portion of the memory after runtime is
- * deleted is the root cause of that crash).
- *
- * In order to provide an efficient implementation that does not add an overhead
- * for the cases when only a single runtime is used, which is the primary
- * usecase, the following assumption has been made: Only for secondary runtimes
- * we track destruction and clean up the store associated with that runtime. For
- * the first runtime we assume that the object holding the store is destroyed
- * prior to the destruction of that runtime.
- *
- * The above assumption makes it work without any overhead when only single
- * runtime is in use. Specifically, we don't perform any additional operations
- * related to tracking runtime lifecycle when only a single runtime is used.
- */
-template <typename T>
-class RuntimeAwareCache : public BaseRuntimeAwareCache,
-                          public RuntimeLifecycleListener {
-
-public:
-  void onRuntimeDestroyed(jsi::Runtime *rt) override {
-    if (getMainJsRuntime() != rt) {
-      // We are removing a secondary runtime
-      _secondaryRuntimeCaches.erase(rt);
-    }
-  }
-
-  ~RuntimeAwareCache() {
-    for (auto &cache : _secondaryRuntimeCaches) {
-      RuntimeLifecycleMonitor::removeListener(
-          *static_cast<jsi::Runtime *>(cache.first), this);
-    }
-  }
-
-  T &get(jsi::Runtime &rt) {
-    // We check if we're accessing the main runtime - this is the happy path
-    // to avoid us having to lookup by runtime for caches that only has a single
-    // runtime
-    if (getMainJsRuntime() == &rt) {
-      return _primaryCache;
-    } else {
-      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
-        // additional complexity for the majority of cases when objects are not
-        // shared between runtimes. Otherwise we'd have to register all objecrts
-        // with the RuntimeMonitor as opposed to only registering ones that are
-        // used in secondary runtime. Note that we can't register listener here
-        // with the primary runtime as it may run on a separate thread.
-        RuntimeLifecycleMonitor::addListener(rt, this);
-
-        T cache;
-        _secondaryRuntimeCaches.emplace(&rt, std::move(cache));
-      }
-    }
-    return _secondaryRuntimeCaches.at(&rt);
-  }
-
-private:
-  std::unordered_map<void *, T> _secondaryRuntimeCaches;
-  T _primaryCache;
-};
-
-} // namespace rnwgpu

package/cpp/jsi/RuntimeLifecycleMonitor.cpp

@@ -1,72 +0,0 @@
-#include "RuntimeLifecycleMonitor.h"
-
-#include <mutex>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-
-namespace rnwgpu {
-
-static std::unordered_map<jsi::Runtime *,
-                          std::unordered_set<RuntimeLifecycleListener *>>
-    listeners;
-static std::mutex listenersMutex;
-
-struct RuntimeLifecycleMonitorObject : public jsi::HostObject {
-  jsi::Runtime *_rt;
-  explicit RuntimeLifecycleMonitorObject(jsi::Runtime *rt) : _rt(rt) {}
-  ~RuntimeLifecycleMonitorObject() {
-    std::unordered_set<RuntimeLifecycleListener *> listenersCopy;
-    {
-      std::lock_guard<std::mutex> lock(listenersMutex);
-      auto listenersSet = listeners.find(_rt);
-      if (listenersSet != listeners.end()) {
-        listenersCopy = listenersSet->second;
-        listeners.erase(listenersSet);
-      }
-    }
-    for (auto listener : listenersCopy) {
-      listener->onRuntimeDestroyed(_rt);
-    }
-  }
-};
-
-void RuntimeLifecycleMonitor::addListener(jsi::Runtime &rt,
-                                          RuntimeLifecycleListener *listener) {
-  bool shouldInstallMonitor = false;
-  {
-    std::lock_guard<std::mutex> lock(listenersMutex);
-    auto listenersSet = listeners.find(&rt);
-    if (listenersSet == listeners.end()) {
-      std::unordered_set<RuntimeLifecycleListener *> newSet;
-      newSet.insert(listener);
-      listeners.emplace(&rt, std::move(newSet));
-      shouldInstallMonitor = true;
-    } else {
-      listenersSet->second.insert(listener);
-    }
-  }
-  if (shouldInstallMonitor) {
-    // We install a global host object in the provided runtime, this way we can
-    // use that host object destructor to get notified when the runtime is being
-    // terminated. We use a unique name for the object as it gets saved with the
-    // runtime's global object.
-    rt.global().setProperty(
-        rt, "__rnwgpu_rt_lifecycle_monitor",
-        jsi::Object::createFromHostObject(
-            rt, std::make_shared<RuntimeLifecycleMonitorObject>(&rt)));
-  }
-}
-
-void RuntimeLifecycleMonitor::removeListener(
-    jsi::Runtime &rt, RuntimeLifecycleListener *listener) {
-  std::lock_guard<std::mutex> lock(listenersMutex);
-  auto listenersSet = listeners.find(&rt);
-  if (listenersSet == listeners.end()) {
-    // nothing to do here
-  } else {
-    listenersSet->second.erase(listener);
-  }
-}
-
-} // namespace rnwgpu

package/cpp/jsi/RuntimeLifecycleMonitor.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include <memory>
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-/**
- * Listener interface that allows for getting notified when a jsi::Runtime
- * instance is destroyed.
- */
-struct RuntimeLifecycleListener {
-  virtual ~RuntimeLifecycleListener() {}
-  virtual void onRuntimeDestroyed(jsi::Runtime *) = 0;
-};
-
-/**
- * This class provides an API via static methods for registering and
- * unregistering runtime lifecycle listeners. The listeners can be used to
- * cleanup any data that references a given jsi::Runtime instance before it gets
- * destroyed.
- */
-struct RuntimeLifecycleMonitor {
-  static void addListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener);
-  static void removeListener(jsi::Runtime &rt,
-                             RuntimeLifecycleListener *listener);
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/ArrayBuffer.h

@@ -1,117 +0,0 @@
-#pragma once
-#include <jsi/jsi.h>
-
-#include <cmath>
-#include <cstdint>
-#include <memory>
-
-#include "JSIConverter.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-struct ArrayBuffer : jsi::MutableBuffer {
-  ArrayBuffer(void *data, size_t size, size_t bytesPerElement)
-      : _data(data), _size(size), _bytesPerElement(bytesPerElement) {}
-
-  ~ArrayBuffer() override {}
-
-  size_t size() const override { return _size; }
-
-  uint8_t *data() override { return static_cast<uint8_t *>(_data); }
-
-  void *_data;
-  size_t _size;
-  size_t _bytesPerElement;
-};
-
-static std::shared_ptr<ArrayBuffer>
-createArrayBufferFromJSI(jsi::Runtime &runtime,
-                         const jsi::ArrayBuffer &arrayBuffer,
-                         size_t bytesPerElement) {
-  auto size = arrayBuffer.size(runtime);
-  return std::make_shared<ArrayBuffer>(arrayBuffer.data(runtime), size,
-                                       bytesPerElement);
-}
-
-template <> struct JSIConverter<std::shared_ptr<ArrayBuffer>> {
-  static std::shared_ptr<ArrayBuffer>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBound) {
-    if (arg.isObject()) {
-      auto obj = arg.getObject(runtime);
-      if (obj.isArrayBuffer(runtime)) {
-        return createArrayBufferFromJSI(runtime, obj.getArrayBuffer(runtime),
-                                        1);
-      }
-      if (obj.hasProperty(runtime, "buffer")) {
-        auto bufferProp = obj.getProperty(runtime, "buffer");
-        if (bufferProp.isObject() &&
-            bufferProp.getObject(runtime).isArrayBuffer(runtime)) {
-          auto buff = bufferProp.getObject(runtime);
-          auto arrayBuffer = buff.getArrayBuffer(runtime);
-          const size_t bufferSize = arrayBuffer.size(runtime);
-
-          // byteOffset / byteLength are user-readable JS properties, not values
-          // the engine guarantees (unlike Dawn's node binding, which reads them
-          // off the engine's typed-array view). Read them as doubles so we can
-          // reject negative, non-integral, NaN/Inf, or oversized values before
-          // they wrap around when cast to size_t.
-          const double byteOffsetValue =
-              obj.getProperty(runtime, "byteOffset").asNumber();
-          const double byteLengthValue =
-              obj.getProperty(runtime, "byteLength").asNumber();
-
-          auto isValidByteIndex = [](double value) {
-            return std::isfinite(value) && value >= 0.0 &&
-                   value <= static_cast<double>(SIZE_MAX) &&
-                   std::floor(value) == value;
-          };
-          if (!isValidByteIndex(byteOffsetValue) ||
-              !isValidByteIndex(byteLengthValue)) {
-            throw std::runtime_error(
-                "ArrayBuffer::fromJSI: invalid byteOffset/byteLength");
-          }
-
-          const size_t byteOffset = static_cast<size_t>(byteOffsetValue);
-          const size_t byteLength = static_cast<size_t>(byteLengthValue);
-
-          // Overflow-safe bounds check: byteOffset + byteLength <= bufferSize.
-          if (byteOffset > bufferSize ||
-              byteLength > bufferSize - byteOffset) {
-            throw std::runtime_error(
-                "ArrayBuffer::fromJSI: view bounds [byteOffset, byteOffset + "
-                "byteLength) exceed the backing ArrayBuffer size");
-          }
-
-          // BYTES_PER_ELEMENT is absent on a DataView; default to 1. A spoofed
-          // object could report 0 (or a negative/NaN value), so clamp to a
-          // minimum of 1 to avoid a later division by zero in writeBuffer.
-          size_t bytesPerElements = 1;
-          if (obj.hasProperty(runtime, "BYTES_PER_ELEMENT")) {
-            auto bpe = obj.getProperty(runtime, "BYTES_PER_ELEMENT");
-            if (bpe.isNumber()) {
-              const double value = bpe.asNumber();
-              if (std::isfinite(value) && value >= 1.0) {
-                bytesPerElements = static_cast<size_t>(value);
-              }
-            }
-          }
-
-          return std::make_shared<ArrayBuffer>(
-              arrayBuffer.data(runtime) + byteOffset, byteLength,
-              bytesPerElements);
-        }
-      }
-    }
-    throw std::runtime_error("ArrayBuffer::fromJSI: argument is not an object "
-                             "with an ArrayBuffer 'buffer' property");
-  }
-
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<ArrayBuffer> arg) {
-    return jsi::ArrayBuffer(runtime, arg);
-  }
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/PlatformContext.h

@@ -1,127 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <memory>
-#include <span>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-struct ImageData {
-  std::vector<uint8_t> data;
-  size_t width;
-  size_t height;
-  wgpu::TextureFormat format;
-};
-
-// Pixel layout of a VideoFrame. Determines whether the underlying surface is
-// a single RGBA plane or a biplanar Y / CbCr pair.
-enum class VideoPixelFormat {
-  // Single-plane 8-bit BGRA (default; what RGBA-style sampling expects).
-  BGRA8,
-  // Biplanar 4:2:0 8-bit Y + interleaved CbCr (NV12). Used for the
-  // importExternalTexture path; needs the YUV→RGB conversion matrix below.
-  NV12,
-};
-
-// A native handle to a video frame that can be imported into a
-// GPUSharedTextureMemory.
-//
-//   - handle is an IOSurfaceRef on Apple platforms
-//   - handle is an AHardwareBuffer* on Android
-//
-// The deleter is responsible for releasing the underlying backing object
-// (CVPixelBuffer / AHardwareBuffer) and must be called exactly once. The
-// VideoFrame JS wrapper handles this on destruction.
-struct VideoFrameHandle {
-  void *handle = nullptr;
-  uint32_t width = 0;
-  uint32_t height = 0;
-  VideoPixelFormat pixelFormat = VideoPixelFormat::BGRA8;
-  // 3x4 row-major matrix mapping [Y, U, V, 1] → linear [R, G, B]. Pre-computed
-  // at decode time from CVPixelBuffer attachments (kCVImageBufferYCbCrMatrixKey
-  // + range), with a BT.709 limited-range default. Only meaningful when
-  // pixelFormat == NV12.
-  float yuvToRgbMatrix[12] = {};
-  std::function<void()> deleter;
-};
-
-// Platform-implemented video source that hands out fresh IOSurface /
-// AHardwareBuffer-backed frames as a video plays.
-class IVideoPlayer {
-public:
-  virtual ~IVideoPlayer() = default;
-
-  // Returns the latest decoded frame, or an empty handle (handle == nullptr)
-  // when no new frame is ready yet. Each non-empty return retains its backing
-  // surface; the VideoFrame wrapper releases it on destruction.
-  virtual VideoFrameHandle copyLatestFrame() = 0;
-
-  virtual void play() = 0;
-  virtual void pause() = 0;
-};
-
-class PlatformContext {
-public:
-  PlatformContext() = default;
-  virtual ~PlatformContext() = default;
-
-  virtual wgpu::Surface makeSurface(wgpu::Instance instance, void *surface,
-                                    int width, int height) = 0;
-  virtual ImageData createImageBitmap(std::string blobId, double offset,
-                                      double size) = 0;
-
-  // Async version that performs image decoding on a background thread
-  virtual void
-  createImageBitmapAsync(std::string blobId, double offset, double size,
-                         std::function<void(ImageData)> onSuccess,
-                         std::function<void(std::string)> onError) = 0;
-
-  // Create ImageBitmap from raw encoded image bytes (PNG/JPEG/etc.)
-  virtual ImageData
-  createImageBitmapFromData(std::span<const uint8_t> data) = 0;
-
-  virtual void
-  createImageBitmapFromDataAsync(std::span<const uint8_t> data,
-                                 std::function<void(ImageData)> onSuccess,
-                                 std::function<void(std::string)> onError) = 0;
-
-  // Decode the first video frame of `path` (a local file path) into a
-  // native, GPU-shareable surface. Used by the SharedTextureMemory example;
-  // not intended as a long-term media-loading API.
-  virtual VideoFrameHandle loadVideoFrame(const std::string &path) = 0;
-
-  // Create a synthetic, GPU-shareable IOSurface/AHardwareBuffer filled with a
-  // generated test pattern. Avoids the need to bundle a video asset for the
-  // SharedTextureMemory example.
-  virtual VideoFrameHandle createTestVideoFrame(uint32_t width,
-                                                uint32_t height) = 0;
-
-  // Open a video file at `path` for playback. The returned player yields
-  // IOSurface / AHardwareBuffer-backed frames via copyLatestFrame().
-  //
-  // `format` selects the requested pixel layout. BGRA8 is the easiest target
-  // for a regular sampled GPUTexture; NV12 is the right shape for the
-  // importExternalTexture path (zero-copy biplanar YUV).
-  virtual std::unique_ptr<IVideoPlayer>
-  createVideoPlayer(const std::string &path, VideoPixelFormat format) = 0;
-
-  // Wrap a CVPixelBufferRef (Apple) or AHardwareBuffer* (Android) pointer
-  // obtained from another library (typically VisionCamera's
-  // Frame.getNativeBuffer().pointer) as one of our VideoFrame handles.
-  //
-  // We CFRetain / AHardwareBuffer_acquire on the way in, so callers can
-  // safely release their own reference immediately after.
-  virtual VideoFrameHandle wrapNativeBuffer(void *pointer) = 0;
-
-  // Write a small procedurally-generated test video to a temporary location
-  // and return its absolute path. Lets the SharedTextureMemory example play
-  // a real decoded video without bundling an asset.
-  virtual std::string writeTestVideoFile() = 0;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -1,237 +0,0 @@
-#include "RNWebGPUManager.h"
-
-#include "GPU.h"
-#include "NativeObject.h"
-#include "RNWebGPU.h"
-
-// GPU API classes (for instanceof support)
-#include "GPUAdapter.h"
-#include "GPUAdapterInfo.h"
-#include "GPUBindGroup.h"
-#include "GPUBindGroupLayout.h"
-#include "GPUBuffer.h"
-#include "GPUCanvasContext.h"
-#include "GPUCommandBuffer.h"
-#include "GPUCommandEncoder.h"
-#include "GPUCompilationInfo.h"
-#include "GPUCompilationMessage.h"
-#include "GPUComputePassEncoder.h"
-#include "GPUComputePipeline.h"
-#include "GPUDevice.h"
-#include "GPUDeviceLostInfo.h"
-#include "GPUError.h"
-#include "GPUExternalTexture.h"
-#include "GPUInternalError.h"
-#include "GPUOutOfMemoryError.h"
-#include "GPUPipelineLayout.h"
-#include "GPUQuerySet.h"
-#include "GPUQueue.h"
-#include "GPURenderBundle.h"
-#include "GPURenderBundleEncoder.h"
-#include "GPURenderPassEncoder.h"
-#include "GPURenderPipeline.h"
-#include "GPUSampler.h"
-#include "GPUSharedTextureMemory.h"
-#include "GPUShaderModule.h"
-#include "GPUSupportedLimits.h"
-#include "GPUTexture.h"
-#include "GPUTextureView.h"
-#include "GPUUncapturedErrorEvent.h"
-#include "GPUValidationError.h"
-#include "VideoFrame.h"
-#include "VideoPlayer.h"
-
-// Enums
-#include "GPUBufferUsage.h"
-#include "GPUColorWrite.h"
-#include "GPUMapMode.h"
-#include "GPUShaderStage.h"
-#include "GPUTextureUsage.h"
-
-#include <memory>
-#include <utility>
-
-namespace rnwgpu {
-
-RNWebGPUManager::RNWebGPUManager(
-    jsi::Runtime *jsRuntime,
-    std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker,
-    std::shared_ptr<PlatformContext> platformContext)
-    : _jsRuntime(jsRuntime), _jsCallInvoker(jsCallInvoker),
-      _platformContext(platformContext) {
-
-  // Register main runtime for RuntimeAwareCache
-  BaseRuntimeAwareCache::setMainJsRuntime(_jsRuntime);
-
-  auto gpu = std::make_shared<GPU>(*_jsRuntime);
-  auto rnWebGPU =
-      std::make_shared<RNWebGPU>(gpu, _platformContext, _jsCallInvoker);
-  _gpu = gpu->get();
-
-  // RNWebGPU needs its brand registered in NativeObjectRegistry so the boxing
-  // path can install the prototype on worklet runtimes. installConstructor
-  // does that registration but also sets globalThis.RNWebGPU = ctor, so we
-  // call it FIRST and then overwrite the global with the actual instance.
-  RNWebGPU::installConstructor(*_jsRuntime);
-  _jsRuntime->global().setProperty(*_jsRuntime, "RNWebGPU",
-                                   RNWebGPU::create(*_jsRuntime, rnWebGPU));
-
-  // Install constructors for instanceof support
-  GPU::installConstructor(*_jsRuntime);
-  GPUAdapter::installConstructor(*_jsRuntime);
-  GPUAdapterInfo::installConstructor(*_jsRuntime);
-  GPUBindGroup::installConstructor(*_jsRuntime);
-  GPUBindGroupLayout::installConstructor(*_jsRuntime);
-  GPUBuffer::installConstructor(*_jsRuntime);
-  GPUCanvasContext::installConstructor(*_jsRuntime);
-  GPUCommandBuffer::installConstructor(*_jsRuntime);
-  GPUCommandEncoder::installConstructor(*_jsRuntime);
-  GPUCompilationInfo::installConstructor(*_jsRuntime);
-  GPUCompilationMessage::installConstructor(*_jsRuntime);
-  GPUComputePassEncoder::installConstructor(*_jsRuntime);
-  GPUComputePipeline::installConstructor(*_jsRuntime);
-  GPUDevice::installConstructor(*_jsRuntime);
-  GPUDeviceLostInfo::installConstructor(*_jsRuntime);
-  GPUError::installConstructor(*_jsRuntime);
-  GPUExternalTexture::installConstructor(*_jsRuntime);
-  GPUInternalError::installConstructor(*_jsRuntime);
-  GPUOutOfMemoryError::installConstructor(*_jsRuntime);
-  GPUValidationError::installConstructor(*_jsRuntime);
-  GPUUncapturedErrorEvent::installConstructor(*_jsRuntime);
-  GPUPipelineLayout::installConstructor(*_jsRuntime);
-  GPUQuerySet::installConstructor(*_jsRuntime);
-  GPUQueue::installConstructor(*_jsRuntime);
-  GPURenderBundle::installConstructor(*_jsRuntime);
-  GPURenderBundleEncoder::installConstructor(*_jsRuntime);
-  GPURenderPassEncoder::installConstructor(*_jsRuntime);
-  GPURenderPipeline::installConstructor(*_jsRuntime);
-  GPUSampler::installConstructor(*_jsRuntime);
-  GPUSharedTextureMemory::installConstructor(*_jsRuntime);
-  GPUShaderModule::installConstructor(*_jsRuntime);
-  GPUSupportedLimits::installConstructor(*_jsRuntime);
-  GPUTexture::installConstructor(*_jsRuntime);
-  GPUTextureView::installConstructor(*_jsRuntime);
-  VideoFrame::installConstructor(*_jsRuntime);
-  VideoPlayer::installConstructor(*_jsRuntime);
-
-  // Install constant objects as plain JS objects with own properties
-  _jsRuntime->global().setProperty(*_jsRuntime, "GPUBufferUsage",
-                                   GPUBufferUsage::create(*_jsRuntime));
-  _jsRuntime->global().setProperty(*_jsRuntime, "GPUColorWrite",
-                                   GPUColorWrite::create(*_jsRuntime));
-  _jsRuntime->global().setProperty(*_jsRuntime, "GPUMapMode",
-                                   GPUMapMode::create(*_jsRuntime));
-  _jsRuntime->global().setProperty(*_jsRuntime, "GPUShaderStage",
-                                   GPUShaderStage::create(*_jsRuntime));
-  _jsRuntime->global().setProperty(*_jsRuntime, "GPUTextureUsage",
-                                   GPUTextureUsage::create(*_jsRuntime));
-
-  // Install global helper functions for Worklets serialization
-  // These are standalone functions that don't require RNWebGPU instance
-  installWebGPUWorkletHelpers(*_jsRuntime);
-}
-
-void RNWebGPUManager::installWebGPUWorkletHelpers(jsi::Runtime &runtime) {
-  // __webgpuIsWebGPUObject - checks if a value is a WebGPU NativeObject
-  auto isWebGPUObjectFunc = jsi::Function::createFromHostFunction(
-      runtime, jsi::PropNameID::forUtf8(runtime, "__webgpuIsWebGPUObject"), 1,
-      [](jsi::Runtime &rt, const jsi::Value & /*thisVal*/,
-         const jsi::Value *args, size_t count) -> jsi::Value {
-        if (count < 1 || !args[0].isObject()) {
-          return jsi::Value(false);
-        }
-        auto obj = args[0].getObject(rt);
-
-        // Check if it has native state
-        if (!obj.hasNativeState(rt)) {
-          return jsi::Value(false);
-        }
-
-        // Check if it has Symbol.toStringTag on its prototype (WebGPU objects
-        // do)
-        auto objectCtor = rt.global().getPropertyAsObject(rt, "Object");
-        auto getPrototypeOf =
-            objectCtor.getPropertyAsFunction(rt, "getPrototypeOf");
-        auto proto = getPrototypeOf.call(rt, obj);
-
-        if (!proto.isObject()) {
-          return jsi::Value(false);
-        }
-
-        auto protoObj = proto.getObject(rt);
-        auto symbolCtor = rt.global().getPropertyAsObject(rt, "Symbol");
-        auto toStringTag = symbolCtor.getProperty(rt, "toStringTag");
-        if (toStringTag.isUndefined()) {
-          return jsi::Value(false);
-        }
-
-        auto getOwnPropertyDescriptor =
-            objectCtor.getPropertyAsFunction(rt, "getOwnPropertyDescriptor");
-        auto desc = getOwnPropertyDescriptor.call(rt, protoObj, toStringTag);
-        return jsi::Value(desc.isObject());
-      });
-  runtime.global().setProperty(runtime, "__webgpuIsWebGPUObject",
-                               std::move(isWebGPUObjectFunc));
-
-  // __webgpuBox - boxes a WebGPU object for Worklets serialization
-  auto boxFunc = jsi::Function::createFromHostFunction(
-      runtime, jsi::PropNameID::forUtf8(runtime, "__webgpuBox"), 1,
-      [](jsi::Runtime &rt, const jsi::Value & /*thisVal*/,
-         const jsi::Value *args, size_t count) -> jsi::Value {
-        if (count < 1 || !args[0].isObject()) {
-          throw jsi::JSError(rt,
-                             "__webgpuBox() requires a WebGPU object argument");
-        }
-
-        auto obj = args[0].getObject(rt);
-
-        // Check if it has native state
-        if (!obj.hasNativeState(rt)) {
-          throw jsi::JSError(
-              rt, "Object has no native state - not a WebGPU object");
-        }
-
-        // Get the brand name from Symbol.toStringTag on the prototype
-        auto objectCtor = rt.global().getPropertyAsObject(rt, "Object");
-        auto getPrototypeOf =
-            objectCtor.getPropertyAsFunction(rt, "getPrototypeOf");
-        auto proto = getPrototypeOf.call(rt, obj);
-
-        std::string brand;
-        if (proto.isObject()) {
-          auto protoObj = proto.getObject(rt);
-          auto symbolCtor = rt.global().getPropertyAsObject(rt, "Symbol");
-          auto toStringTag = symbolCtor.getProperty(rt, "toStringTag");
-          if (!toStringTag.isUndefined()) {
-            auto getOwnPropertyDescriptor = objectCtor.getPropertyAsFunction(
-                rt, "getOwnPropertyDescriptor");
-            auto desc =
-                getOwnPropertyDescriptor.call(rt, protoObj, toStringTag);
-            if (desc.isObject()) {
-              auto descObj = desc.getObject(rt);
-              auto value = descObj.getProperty(rt, "value");
-              if (value.isString()) {
-                brand = value.getString(rt).utf8(rt);
-              }
-            }
-          }
-        }
-
-        if (brand.empty()) {
-          throw jsi::JSError(rt, "Cannot determine WebGPU object type - no "
-                                 "Symbol.toStringTag found");
-        }
-
-        auto nativeState = obj.getNativeState(rt);
-        auto boxed = std::make_shared<BoxedWebGPUObject>(nativeState, brand);
-        return jsi::Object::createFromHostObject(rt, boxed);
-      });
-  runtime.global().setProperty(runtime, "__webgpuBox", std::move(boxFunc));
-}
-
-RNWebGPUManager::~RNWebGPUManager() {
-  _jsRuntime = nullptr;
-  _jsCallInvoker = nullptr;
-}
-
-} // namespace rnwgpu