@shopify/react-native-skia 2.6.5 → 2.6.7

package/lib/typescript/lib/module/skia/types/WebGPU.d.ts

@@ -1 +1,31 @@
-export {};
+/**
+ * Make the WebGPU flag constants (`GPUBufferUsage`, `GPUColorWrite`,
+ * `GPUMapMode`, `GPUShaderStage`, `GPUTextureUsage`) available on the runtime
+ * that calls this.
+ *
+ * The native module installs these globals on the main JS runtime, but worklet
+ * runtimes (Reanimated UI, dedicated worklet runtimes, Vision Camera frame
+ * processors) start without them, so referencing the bare global inside a
+ * worklet yields `undefined`. Call `installWebGPU()` once at the top of a
+ * worklet to install them there:
+ *
+ * ```tsx
+ * import { installWebGPU } from "@shopify/react-native-skia";
+ *
+ * const work = (device: GPUDevice) => {
+ *   "worklet";
+ *   installWebGPU();
+ *   device.createBuffer({
+ *     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+ *   });
+ * };
+ * ```
+ *
+ * `installWebGPU` is a native host function. When captured into a worklet, the
+ * Worklets serializer re-creates it on the worklet runtime, so calling it there
+ * installs the constants on that runtime. The values come from the native
+ * `wgpu::*Usage` enums, so they stay a single source of truth across runtimes.
+ * Calling it on a runtime that already has the constants is a safe no-op, and on
+ * web (where the constants are always global) it is a no-op too.
+ */
+export const installWebGPU: any;

package/lib/typescript/src/skia/types/WebGPU.d.ts

@@ -1,4 +1,35 @@
 import type { NativeBuffer } from "./NativeBuffer";
+/**
+ * Make the WebGPU flag constants (`GPUBufferUsage`, `GPUColorWrite`,
+ * `GPUMapMode`, `GPUShaderStage`, `GPUTextureUsage`) available on the runtime
+ * that calls this.
+ *
+ * The native module installs these globals on the main JS runtime, but worklet
+ * runtimes (Reanimated UI, dedicated worklet runtimes, Vision Camera frame
+ * processors) start without them, so referencing the bare global inside a
+ * worklet yields `undefined`. Call `installWebGPU()` once at the top of a
+ * worklet to install them there:
+ *
+ * ```tsx
+ * import { installWebGPU } from "@shopify/react-native-skia";
+ *
+ * const work = (device: GPUDevice) => {
+ *   "worklet";
+ *   installWebGPU();
+ *   device.createBuffer({
+ *     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+ *   });
+ * };
+ * ```
+ *
+ * `installWebGPU` is a native host function. When captured into a worklet, the
+ * Worklets serializer re-creates it on the worklet runtime, so calling it there
+ * installs the constants on that runtime. The values come from the native
+ * `wgpu::*Usage` enums, so they stay a single source of truth across runtimes.
+ * Calling it on a runtime that already has the constants is a safe no-op, and on
+ * web (where the constants are always global) it is a no-op too.
+ */
+export declare const installWebGPU: () => void;
 /**
  * Descriptor for {@link GPUDevice.importExternalTexture} when the source is a
  * Skia NativeBuffer (Skia has no WebCodecs `VideoFrame`).
@@ -24,6 +55,62 @@ export interface SkiaGPUExternalTextureDescriptor extends GPUObjectDescriptorBas
 export interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBase {
     handle: NativeBuffer;
 }
+/**
+ * The kind of native synchronization primitive a {@link GPUSharedFence} wraps,
+ * matching the `shared-fence-*` device feature names. Limited to the kinds
+ * react-native-skia targets (iOS/Metal and Android/Vulkan); `importSharedFence`
+ * accepts these and `export()` reports them.
+ */
+export type GPUSharedFenceType = "mtl-shared-event" | "sync-fd" | "vk-semaphore-opaque-fd";
+/**
+ * Descriptor for {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFenceDescriptor {
+    /**
+     * The fence kind to import. Must match a `shared-fence-*` feature enabled on
+     * the device.
+     */
+    type: GPUSharedFenceType;
+    /**
+     * The raw native handle as a BigInt: an `id<MTLSharedEvent>` pointer for
+     * `"mtl-shared-event"`, or an OS file descriptor for the `*-fd` kinds.
+     */
+    handle: bigint;
+    label?: string;
+}
+export interface GPUSharedFenceExportInfo {
+    type: GPUSharedFenceType;
+    /**
+     * An `id<MTLSharedEvent>` pointer (Apple) or file descriptor (Android), as a
+     * BigInt. The caller takes ownership; e.g. an exported sync-fd must be closed
+     * once consumed.
+     */
+    handle: bigint;
+}
+/**
+ * A native GPU synchronization primitive shared across queues/APIs. Produced by
+ * {@link GPUSharedTextureMemory.endAccess}, consumed by
+ * {@link GPUSharedTextureMemory.beginAccess}, or imported from a consumer's
+ * fence with {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFence {
+    readonly __brand: "GPUSharedFence";
+    label: string;
+    export(): GPUSharedFenceExportInfo;
+}
+/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */
+export interface GPUSharedFenceState {
+    fence: GPUSharedFence;
+    signaledValue: bigint;
+}
+/**
+ * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled
+ * at its `signaledValue` once Dawn's GPU work for the access completes.
+ */
+export interface GPUSharedTextureMemoryEndAccessState {
+    initialized: boolean;
+    fences: GPUSharedFenceState[];
+}
 /**
  * Shared texture memory imported from a platform native buffer via
  * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases
@@ -36,14 +123,16 @@ export interface GPUSharedTextureMemory extends GPUObjectBase {
     /**
      * Acquire the memory for GPU access. `initialized` marks whether the existing
      * contents should be preserved (pass `true` for an already-rendered frame).
-     * Returns `false` if access could not be acquired.
+     * Optional `fences` are wait fences: Dawn waits for each to reach its
+     * `signaledValue` before writing the surface. Throws if the access could not
+     * be acquired.
      */
-    beginAccess(texture: GPUTexture, initialized: boolean): boolean;
+    beginAccess(texture: GPUTexture, initialized: boolean, fences?: GPUSharedFenceState[]): void;
     /**
-     * Release the memory after the GPU work that accessed it has been submitted.
-     * Returns `false` on failure.
+     * Release the memory after the GPU work that accessed it has been submitted,
+     * and return the fences Dawn produced for the access. Throws on failure.
      */
-    endAccess(texture: GPUTexture): boolean;
+    endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;
 }
 /**
  * Dawn-specific toggles, passed via {@link GPUDeviceDescriptor.dawnToggles} to
@@ -84,5 +173,12 @@ declare global {
          * begin/end access window yourself.
          */
         importSharedTextureMemory(descriptor: GPUSharedTextureMemoryDescriptor): GPUSharedTextureMemory;
+        /**
+         * Skia extension: import a native synchronization primitive (an
+         * `id<MTLSharedEvent>` on Apple, a sync-fd / VkSemaphore on Android) as a
+         * {@link GPUSharedFence}, e.g. to wait on a fence a consumer produced. The
+         * matching `shared-fence-*` feature must be enabled on the device.
+         */
+        importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;
     }
 }

package/package.json

@@ -8,7 +8,7 @@
     "setup-skia-web": "scripts/setup-canvaskit.js"
   },
   "title": "React Native Skia",
-  "version": "2.6.5",
+  "version": "2.6.7",
   "description": "High-performance React Native Graphics using Skia",
   "main": "lib/module/index.js",
   "react-native": "src/index.ts",
@@ -131,10 +131,10 @@
   },
   "dependencies": {
     "canvaskit-wasm": "0.41.0",
-    "react-native-skia-android": "147.1.0",
-    "react-native-skia-apple-ios": "147.1.0",
-    "react-native-skia-apple-macos": "147.1.0",
-    "react-native-skia-apple-tvos": "147.1.0",
+    "react-native-skia-android": "150.0.0",
+    "react-native-skia-apple-ios": "150.0.0",
+    "react-native-skia-apple-macos": "150.0.0",
+    "react-native-skia-apple-tvos": "150.0.0",
     "react-reconciler": "0.31.0"
   },
   "eslintIgnore": [

package/src/skia/types/WebGPU.ts

@@ -1,5 +1,45 @@
 import type { NativeBuffer } from "./NativeBuffer";
 
+/**
+ * Make the WebGPU flag constants (`GPUBufferUsage`, `GPUColorWrite`,
+ * `GPUMapMode`, `GPUShaderStage`, `GPUTextureUsage`) available on the runtime
+ * that calls this.
+ *
+ * The native module installs these globals on the main JS runtime, but worklet
+ * runtimes (Reanimated UI, dedicated worklet runtimes, Vision Camera frame
+ * processors) start without them, so referencing the bare global inside a
+ * worklet yields `undefined`. Call `installWebGPU()` once at the top of a
+ * worklet to install them there:
+ *
+ * ```tsx
+ * import { installWebGPU } from "@shopify/react-native-skia";
+ *
+ * const work = (device: GPUDevice) => {
+ *   "worklet";
+ *   installWebGPU();
+ *   device.createBuffer({
+ *     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+ *   });
+ * };
+ * ```
+ *
+ * `installWebGPU` is a native host function. When captured into a worklet, the
+ * Worklets serializer re-creates it on the worklet runtime, so calling it there
+ * installs the constants on that runtime. The values come from the native
+ * `wgpu::*Usage` enums, so they stay a single source of truth across runtimes.
+ * Calling it on a runtime that already has the constants is a safe no-op, and on
+ * web (where the constants are always global) it is a no-op too.
+ */
+export const installWebGPU: () => void = (() => {
+  const g =
+    typeof global !== "undefined"
+      ? (global as unknown as { installWebGPU?: () => void })
+      : undefined;
+  return g && typeof g.installWebGPU === "function"
+    ? g.installWebGPU
+    : () => {};
+})();
+
 // Skia's Graphite/Dawn backend extends the standard WebGPU API (typed by
 // @webgpu/types) with a few Skia- and Dawn-specific entry points. These are
 // only available on native (SK_GRAPHITE) builds, reachable through
@@ -36,6 +76,71 @@ export interface GPUSharedTextureMemoryDescriptor extends GPUObjectDescriptorBas
   handle: NativeBuffer;
 }
 
+/**
+ * The kind of native synchronization primitive a {@link GPUSharedFence} wraps,
+ * matching the `shared-fence-*` device feature names. Limited to the kinds
+ * react-native-skia targets (iOS/Metal and Android/Vulkan); `importSharedFence`
+ * accepts these and `export()` reports them.
+ */
+export type GPUSharedFenceType =
+  | "mtl-shared-event"
+  | "sync-fd"
+  | "vk-semaphore-opaque-fd";
+
+/**
+ * Descriptor for {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFenceDescriptor {
+  /**
+   * The fence kind to import. Must match a `shared-fence-*` feature enabled on
+   * the device.
+   */
+  type: GPUSharedFenceType;
+  /**
+   * The raw native handle as a BigInt: an `id<MTLSharedEvent>` pointer for
+   * `"mtl-shared-event"`, or an OS file descriptor for the `*-fd` kinds.
+   */
+  handle: bigint;
+  label?: string;
+}
+
+export interface GPUSharedFenceExportInfo {
+  type: GPUSharedFenceType;
+  /**
+   * An `id<MTLSharedEvent>` pointer (Apple) or file descriptor (Android), as a
+   * BigInt. The caller takes ownership; e.g. an exported sync-fd must be closed
+   * once consumed.
+   */
+  handle: bigint;
+}
+
+/**
+ * A native GPU synchronization primitive shared across queues/APIs. Produced by
+ * {@link GPUSharedTextureMemory.endAccess}, consumed by
+ * {@link GPUSharedTextureMemory.beginAccess}, or imported from a consumer's
+ * fence with {@link GPUDevice.importSharedFence}.
+ */
+export interface GPUSharedFence {
+  readonly __brand: "GPUSharedFence";
+  label: string;
+  export(): GPUSharedFenceExportInfo;
+}
+
+/** A fence and the timeline value to wait for (0n for binary sync-fd fences). */
+export interface GPUSharedFenceState {
+  fence: GPUSharedFence;
+  signaledValue: bigint;
+}
+
+/**
+ * The result of {@link GPUSharedTextureMemory.endAccess}: each fence is signaled
+ * at its `signaledValue` once Dawn's GPU work for the access completes.
+ */
+export interface GPUSharedTextureMemoryEndAccessState {
+  initialized: boolean;
+  fences: GPUSharedFenceState[];
+}
+
 /**
  * Shared texture memory imported from a platform native buffer via
  * {@link GPUDevice.importSharedTextureMemory}. Create a texture that aliases
@@ -48,14 +153,20 @@ export interface GPUSharedTextureMemory extends GPUObjectBase {
   /**
    * Acquire the memory for GPU access. `initialized` marks whether the existing
    * contents should be preserved (pass `true` for an already-rendered frame).
-   * Returns `false` if access could not be acquired.
+   * Optional `fences` are wait fences: Dawn waits for each to reach its
+   * `signaledValue` before writing the surface. Throws if the access could not
+   * be acquired.
    */
-  beginAccess(texture: GPUTexture, initialized: boolean): boolean;
+  beginAccess(
+    texture: GPUTexture,
+    initialized: boolean,
+    fences?: GPUSharedFenceState[]
+  ): void;
   /**
-   * Release the memory after the GPU work that accessed it has been submitted.
-   * Returns `false` on failure.
+   * Release the memory after the GPU work that accessed it has been submitted,
+   * and return the fences Dawn produced for the access. Throws on failure.
    */
-  endAccess(texture: GPUTexture): boolean;
+  endAccess(texture: GPUTexture): GPUSharedTextureMemoryEndAccessState;
 }
 
 /**
@@ -104,5 +215,12 @@ declare global {
     importSharedTextureMemory(
       descriptor: GPUSharedTextureMemoryDescriptor
     ): GPUSharedTextureMemory;
+    /**
+     * Skia extension: import a native synchronization primitive (an
+     * `id<MTLSharedEvent>` on Apple, a sync-fd / VkSemaphore on Android) as a
+     * {@link GPUSharedFence}, e.g. to wait on a fence a consumer produced. The
+     * matching `shared-fence-*` feature must be enabled on the device.
+     */
+    importSharedFence(descriptor: GPUSharedFenceDescriptor): GPUSharedFence;
   }
 }

package/cpp/rnwgpu/async/AsyncDispatcher.h

@@ -1,28 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <memory>
-
-#include <jsi/jsi.h>
-
-namespace rnwgpu::async {
-
-namespace jsi = facebook::jsi;
-
-/**
- * Abstract dispatcher used by the AsyncRunner to enqueue work back onto the
- * JavaScript thread.
- */
-class AsyncDispatcher {
-public:
-  using Work = std::function<void(jsi::Runtime &)>;
-
-  virtual ~AsyncDispatcher() = default;
-
-  /**
-   * Enqueue a unit of work that will be executed on the JavaScript thread.
-   */
-  virtual void post(Work work) = 0;
-};
-
-} // namespace rnwgpu::async

package/cpp/rnwgpu/async/AsyncRunner.cpp

@@ -1,182 +0,0 @@
-#include "AsyncRunner.h"
-
-#include <chrono>
-#include <stdexcept>
-#include <utility>
-
-#include "AsyncTaskHandle.h"
-
-namespace rnwgpu::async {
-
-// Static member definitions
-std::mutex AsyncRunner::_runnersMutex;
-std::unordered_map<jsi::Runtime *, std::shared_ptr<AsyncRunner>>
-    AsyncRunner::_runners;
-
-AsyncRunner::AsyncRunner(wgpu::Instance instance,
-                         std::shared_ptr<AsyncDispatcher> dispatcher)
-    : _instance(std::move(instance)), _dispatcher(std::move(dispatcher)),
-      _pendingTasks(0), _pumpTasks(0), _tickScheduled(false),
-      _lastTickTimeNs(0) {
-  if (!_dispatcher) {
-    throw std::runtime_error("AsyncRunner requires a valid dispatcher.");
-  }
-}
-
-std::shared_ptr<AsyncRunner> AsyncRunner::get(jsi::Runtime &runtime) {
-  std::lock_guard<std::mutex> lock(_runnersMutex);
-  auto it = _runners.find(&runtime);
-  if (it == _runners.end()) {
-    return nullptr;
-  }
-  return it->second;
-}
-
-std::shared_ptr<AsyncRunner>
-AsyncRunner::getOrCreate(jsi::Runtime &runtime, wgpu::Instance instance,
-                         std::shared_ptr<AsyncDispatcher> dispatcher) {
-  std::lock_guard<std::mutex> lock(_runnersMutex);
-  auto it = _runners.find(&runtime);
-  if (it != _runners.end()) {
-    return it->second;
-  }
-
-  auto runner =
-      std::make_shared<AsyncRunner>(std::move(instance), std::move(dispatcher));
-  _runners[&runtime] = runner;
-  return runner;
-}
-
-AsyncTaskHandle AsyncRunner::postTask(const TaskCallback &callback,
-                                      bool keepPumping) {
-  auto handle = AsyncTaskHandle::create(shared_from_this(), keepPumping);
-  if (!handle.valid()) {
-    throw std::runtime_error("Failed to create AsyncTaskHandle.");
-  }
-
-  _pendingTasks.fetch_add(1, std::memory_order_acq_rel);
-  if (keepPumping) {
-    _pumpTasks.fetch_add(1, std::memory_order_acq_rel);
-  }
-  requestTick();
-
-  auto resolve = handle.createResolveFunction();
-  auto reject = handle.createRejectFunction();
-
-  try {
-    callback(resolve, reject);
-  } catch (const std::exception &exception) {
-    reject(exception.what());
-  } catch (...) {
-    reject("Unknown native error in AsyncRunner::postTask.");
-  }
-
-  return handle;
-}
-
-void AsyncRunner::requestTick() {
-  bool expected = false;
-  if (!_tickScheduled.compare_exchange_strong(expected, true,
-                                              std::memory_order_acq_rel)) {
-    return;
-  }
-
-  auto self = shared_from_this();
-  _dispatcher->post([self](jsi::Runtime &runtime) {
-    auto tickCallback = jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forAscii(runtime, "AsyncRunnerTick"), 0,
-        [self](jsi::Runtime &runtime, const jsi::Value & /*thisValue*/,
-               const jsi::Value * /*args*/, size_t /*count*/) -> jsi::Value {
-          self->tick(runtime);
-          return jsi::Value::undefined();
-        });
-
-#if defined(ANDROID) || defined(__ANDROID__)
-    auto global = runtime.global();
-    auto setImmediateValue = global.getProperty(runtime, "setImmediate");
-    constexpr auto kMinTickInterval = std::chrono::milliseconds(4);
-    const int64_t nowNs =
-        std::chrono::duration_cast<std::chrono::nanoseconds>(
-            std::chrono::steady_clock::now().time_since_epoch())
-            .count();
-    const int64_t lastNs =
-        self->_lastTickTimeNs.load(std::memory_order_acquire);
-    int delayMs = 0;
-    if (lastNs > 0) {
-      const int64_t elapsedNs = nowNs - lastNs;
-      const int64_t minIntervalNs = kMinTickInterval.count() * 1000000LL;
-      if (elapsedNs < minIntervalNs) {
-        const int64_t remainingNs = minIntervalNs - elapsedNs;
-        delayMs = static_cast<int>((remainingNs + 999999) / 1000000);
-      }
-    }
-
-    auto tryScheduleTimeout = [&](int ms) {
-      auto setTimeoutValue = global.getProperty(runtime, "setTimeout");
-      if (!setTimeoutValue.isObject()) {
-        return false;
-      }
-      auto setTimeoutObj = setTimeoutValue.asObject(runtime);
-      if (!setTimeoutObj.isFunction(runtime)) {
-        return false;
-      }
-      auto setTimeoutFn = setTimeoutObj.asFunction(runtime);
-      jsi::Value callbackArg(runtime, tickCallback);
-      jsi::Value delayArg(static_cast<double>(ms));
-      setTimeoutFn.call(runtime, callbackArg, delayArg);
-      return true;
-    };
-
-    if (delayMs > 0) {
-      if (tryScheduleTimeout(delayMs)) {
-        return;
-      }
-      // If setTimeout unavailable fall through to immediate scheduling.
-    }
-
-    if (setImmediateValue.isObject()) {
-      auto setImmediateObj = setImmediateValue.asObject(runtime);
-      if (setImmediateObj.isFunction(runtime)) {
-        auto setImmediateFn = setImmediateObj.asFunction(runtime);
-        jsi::Value callbackArg(runtime, tickCallback);
-        setImmediateFn.call(runtime, callbackArg);
-        return;
-      }
-    }
-
-    int timeoutDelayMs = delayMs > 0 ? delayMs : 0;
-    if (tryScheduleTimeout(timeoutDelayMs)) {
-      return;
-    }
-
-    runtime.queueMicrotask(std::move(tickCallback));
-#else
-    runtime.queueMicrotask(std::move(tickCallback));
-#endif
-  });
-}
-
-void AsyncRunner::tick(jsi::Runtime & /*runtime*/) {
-  _tickScheduled.store(false, std::memory_order_release);
-  _instance.ProcessEvents();
-  const auto nowNs = std::chrono::duration_cast<std::chrono::nanoseconds>(
-                         std::chrono::steady_clock::now().time_since_epoch())
-                         .count();
-  _lastTickTimeNs.store(nowNs, std::memory_order_release);
-  if (_pumpTasks.load(std::memory_order_acquire) > 0) {
-    requestTick();
-  }
-}
-
-void AsyncRunner::onTaskSettled(bool keepPumping) {
-  _pendingTasks.fetch_sub(1, std::memory_order_acq_rel);
-  if (keepPumping) {
-    _pumpTasks.fetch_sub(1, std::memory_order_acq_rel);
-  }
-}
-
-std::shared_ptr<AsyncDispatcher> AsyncRunner::dispatcher() const {
-  return _dispatcher;
-}
-
-} // namespace rnwgpu::async

package/cpp/rnwgpu/async/AsyncRunner.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#include <atomic>
-#include <cstdint>
-#include <functional>
-#include <memory>
-#include <mutex>
-#include <unordered_map>
-
-#include <jsi/jsi.h>
-
-#include "AsyncDispatcher.h"
-#include "AsyncTaskHandle.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace jsi = facebook::jsi;
-
-namespace rnwgpu::async {
-
-class AsyncRunner : public std::enable_shared_from_this<AsyncRunner> {
-public:
-  using TaskCallback =
-      std::function<void(const AsyncTaskHandle::ResolveFunction &,
-                         const AsyncTaskHandle::RejectFunction &)>;
-
-  AsyncRunner(wgpu::Instance instance,
-              std::shared_ptr<AsyncDispatcher> dispatcher);
-
-  static std::shared_ptr<AsyncRunner> get(jsi::Runtime &runtime);
-  static std::shared_ptr<AsyncRunner>
-  getOrCreate(jsi::Runtime &runtime, wgpu::Instance instance,
-              std::shared_ptr<AsyncDispatcher> dispatcher);
-
-  AsyncTaskHandle postTask(const TaskCallback &callback,
-                           bool keepPumping = true);
-
-  void requestTick();
-  void tick(jsi::Runtime &runtime);
-  void onTaskSettled(bool keepPumping);
-
-  std::shared_ptr<AsyncDispatcher> dispatcher() const;
-
-private:
-  static std::mutex _runnersMutex;
-  static std::unordered_map<jsi::Runtime *, std::shared_ptr<AsyncRunner>>
-      _runners;
-
-  wgpu::Instance _instance;
-  std::shared_ptr<AsyncDispatcher> _dispatcher;
-  std::atomic<size_t> _pendingTasks;
-  std::atomic<size_t> _pumpTasks;
-  std::atomic<bool> _tickScheduled;
-  std::atomic<int64_t> _lastTickTimeNs;
-};
-
-} // namespace rnwgpu::async

package/cpp/rnwgpu/async/JSIMicrotaskDispatcher.cpp

@@ -1,23 +0,0 @@
-#include "JSIMicrotaskDispatcher.h"
-
-#include <utility>
-
-namespace rnwgpu::async {
-
-JSIMicrotaskDispatcher::JSIMicrotaskDispatcher(jsi::Runtime &runtime)
-    : _runtime(runtime) {}
-
-void JSIMicrotaskDispatcher::post(Work work) {
-  auto microtask = jsi::Function::createFromHostFunction(
-      _runtime, jsi::PropNameID::forAscii(_runtime, "AsyncMicrotask"), 0,
-      [work = std::move(work)](
-          jsi::Runtime &runtime, const jsi::Value & /*thisValue*/,
-          const jsi::Value * /*args*/, size_t /*count*/) -> jsi::Value {
-        work(runtime);
-        return jsi::Value::undefined();
-      });
-
-  _runtime.queueMicrotask(std::move(microtask));
-}
-
-} // namespace rnwgpu::async

package/cpp/rnwgpu/async/JSIMicrotaskDispatcher.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include "AsyncDispatcher.h"
-
-namespace rnwgpu::async {
-
-/**
- * Dispatcher implementation backed by `jsi::Runtime::queueMicrotask`.
- */
-class JSIMicrotaskDispatcher final
-    : public AsyncDispatcher,
-      public std::enable_shared_from_this<JSIMicrotaskDispatcher> {
-public:
-  explicit JSIMicrotaskDispatcher(jsi::Runtime &runtime);
-
-  void post(Work work) override;
-
-private:
-  jsi::Runtime &_runtime;
-};
-
-} // namespace rnwgpu::async