@shopify/react-native-skia 2.10.0 → 2.10.2

package/cpp/rnwgpu/api/GPUDevice.h

@@ -1,258 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <map>
-#include <memory>
-#include <mutex>
-#include <optional>
-#include <string>
-#include <unordered_set>
-#include <utility>
-#include <variant>
-#include <vector>
-
-#include "descriptors/Unions.h"
-
-#include "jsi/NativeObject.h"
-
-#include "rnwgpu/async/AsyncTaskHandle.h"
-#include "rnwgpu/async/RuntimeContext.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "GPUUncapturedErrorEvent.h"
-
-#include "GPUBindGroup.h"
-#include "GPUBindGroupLayout.h"
-#include "GPUBuffer.h"
-#include "GPUCommandEncoder.h"
-#include "GPUComputePipeline.h"
-#include "GPUDeviceLostInfo.h"
-#include "GPUError.h"
-#include "GPUExternalTexture.h"
-#include "GPUPipelineLayout.h"
-#include "GPUQuerySet.h"
-#include "GPUQueue.h"
-#include "GPURenderBundleEncoder.h"
-#include "GPURenderPipeline.h"
-#include "GPUSampler.h"
-#include "GPUShaderModule.h"
-#include "GPUSharedFence.h"
-#include "GPUSharedTextureMemory.h"
-#include "GPUSupportedLimits.h"
-#include "GPUTexture.h"
-#include "descriptors/GPUBindGroupDescriptor.h"
-#include "descriptors/GPUBindGroupLayoutDescriptor.h"
-#include "descriptors/GPUBufferDescriptor.h"
-#include "descriptors/GPUCommandEncoderDescriptor.h"
-#include "descriptors/GPUComputePipelineDescriptor.h"
-#include "descriptors/GPUExternalTextureDescriptor.h"
-#include "descriptors/GPUPipelineLayoutDescriptor.h"
-#include "descriptors/GPUQuerySetDescriptor.h"
-#include "descriptors/GPURenderBundleEncoderDescriptor.h"
-#include "descriptors/GPURenderPipelineDescriptor.h"
-#include "descriptors/GPUSamplerDescriptor.h"
-#include "descriptors/GPUShaderModuleDescriptor.h"
-#include "descriptors/GPUSharedFenceDescriptor.h"
-#include "descriptors/GPUSharedTextureMemoryDescriptor.h"
-#include "descriptors/GPUTextureDescriptor.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-// Forward declaration
-class GPUDevice;
-
-// Static registry to map wgpu::Device handles to GPUDevice instances
-class GPUDeviceRegistry {
-public:
-  static GPUDeviceRegistry &getInstance() {
-    static GPUDeviceRegistry instance;
-    return instance;
-  }
-
-  void registerDevice(WGPUDevice handle, GPUDevice *device) {
-    std::lock_guard<std::mutex> lock(_mutex);
-    _devices[handle] = device;
-  }
-
-  void unregisterDevice(WGPUDevice handle) {
-    std::lock_guard<std::mutex> lock(_mutex);
-    _devices.erase(handle);
-  }
-
-  GPUDevice *getDevice(WGPUDevice handle) {
-    std::lock_guard<std::mutex> lock(_mutex);
-    auto it = _devices.find(handle);
-    return it != _devices.end() ? it->second : nullptr;
-  }
-
-private:
-  GPUDeviceRegistry() = default;
-  std::mutex _mutex;
-  std::map<WGPUDevice, GPUDevice *> _devices;
-};
-
-class GPUDevice : public NativeObject<GPUDevice> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUDevice";
-
-  explicit GPUDevice(wgpu::Device instance,
-                     std::shared_ptr<async::RuntimeContext> async,
-                     std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _async(async),
-        _label(label) {
-    // Register this device in the global registry
-    GPUDeviceRegistry::getInstance().registerDevice(_instance.Get(), this);
-  }
-
-  ~GPUDevice() {
-    // Unregister from the global registry
-    GPUDeviceRegistry::getInstance().unregisterDevice(_instance.Get());
-  }
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  void destroy();
-  std::shared_ptr<GPUBuffer>
-  createBuffer(std::shared_ptr<GPUBufferDescriptor> descriptor);
-  std::shared_ptr<GPUTexture>
-  createTexture(std::shared_ptr<GPUTextureDescriptor> descriptor);
-  std::shared_ptr<GPUSampler> createSampler(
-      std::optional<std::shared_ptr<GPUSamplerDescriptor>> descriptor);
-  std::shared_ptr<GPUExternalTexture> importExternalTexture(
-      std::shared_ptr<GPUExternalTextureDescriptor> descriptor);
-  std::shared_ptr<GPUSharedTextureMemory> importSharedTextureMemory(
-      std::shared_ptr<GPUSharedTextureMemoryDescriptor> descriptor);
-  std::shared_ptr<GPUSharedFence>
-  importSharedFence(std::shared_ptr<GPUSharedFenceDescriptor> descriptor);
-  std::shared_ptr<GPUBindGroupLayout> createBindGroupLayout(
-      std::shared_ptr<GPUBindGroupLayoutDescriptor> descriptor);
-  std::shared_ptr<GPUPipelineLayout>
-  createPipelineLayout(std::shared_ptr<GPUPipelineLayoutDescriptor> descriptor);
-  std::shared_ptr<GPUBindGroup>
-  createBindGroup(std::shared_ptr<GPUBindGroupDescriptor> descriptor);
-  std::shared_ptr<GPUShaderModule>
-  createShaderModule(std::shared_ptr<GPUShaderModuleDescriptor> descriptor);
-  std::shared_ptr<GPUComputePipeline> createComputePipeline(
-      std::shared_ptr<GPUComputePipelineDescriptor> descriptor);
-  std::shared_ptr<GPURenderPipeline>
-  createRenderPipeline(std::shared_ptr<GPURenderPipelineDescriptor> descriptor);
-  async::AsyncTaskHandle createComputePipelineAsync(
-      jsi::Runtime &runtime,
-      std::shared_ptr<GPUComputePipelineDescriptor> descriptor);
-  async::AsyncTaskHandle createRenderPipelineAsync(
-      jsi::Runtime &runtime,
-      std::shared_ptr<GPURenderPipelineDescriptor> descriptor);
-  std::shared_ptr<GPUCommandEncoder> createCommandEncoder(
-      std::optional<std::shared_ptr<GPUCommandEncoderDescriptor>> descriptor);
-  std::shared_ptr<GPURenderBundleEncoder> createRenderBundleEncoder(
-      std::shared_ptr<GPURenderBundleEncoderDescriptor> descriptor);
-  std::shared_ptr<GPUQuerySet>
-  createQuerySet(std::shared_ptr<GPUQuerySetDescriptor> descriptor);
-  void pushErrorScope(wgpu::ErrorFilter filter);
-  async::AsyncTaskHandle popErrorScope(jsi::Runtime &runtime);
-
-  std::unordered_set<std::string> getFeatures();
-  std::shared_ptr<GPUSupportedLimits> getLimits();
-  std::shared_ptr<GPUQueue> getQueue();
-  async::AsyncTaskHandle getLost();
-  void notifyDeviceLost(wgpu::DeviceLostReason reason, std::string message);
-  void forceLossForTesting();
-
-  // Event listener methods
-  void addEventListener(std::string type, jsi::Function callback);
-  void removeEventListener(std::string type, jsi::Function callback);
-  void notifyUncapturedError(GPUErrorVariant error);
-
-  std::string getLabel() { return _label; }
-  void setLabel(const std::string &label) {
-    _label = label;
-    _instance.SetLabel(_label.c_str());
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPUDevice::getBrand);
-    installMethod(runtime, prototype, "destroy", &GPUDevice::destroy);
-    installMethod(runtime, prototype, "createBuffer", &GPUDevice::createBuffer);
-    installMethod(runtime, prototype, "createTexture",
-                  &GPUDevice::createTexture);
-    installMethod(runtime, prototype, "createSampler",
-                  &GPUDevice::createSampler);
-    installMethod(runtime, prototype, "importExternalTexture",
-                  &GPUDevice::importExternalTexture);
-    installMethod(runtime, prototype, "importSharedTextureMemory",
-                  &GPUDevice::importSharedTextureMemory);
-    installMethod(runtime, prototype, "importSharedFence",
-                  &GPUDevice::importSharedFence);
-    installMethod(runtime, prototype, "createBindGroupLayout",
-                  &GPUDevice::createBindGroupLayout);
-    installMethod(runtime, prototype, "createPipelineLayout",
-                  &GPUDevice::createPipelineLayout);
-    installMethod(runtime, prototype, "createBindGroup",
-                  &GPUDevice::createBindGroup);
-    installMethod(runtime, prototype, "createShaderModule",
-                  &GPUDevice::createShaderModule);
-    installMethod(runtime, prototype, "createComputePipeline",
-                  &GPUDevice::createComputePipeline);
-    installMethod(runtime, prototype, "createRenderPipeline",
-                  &GPUDevice::createRenderPipeline);
-    installMethodWithRuntime(runtime, prototype, "createComputePipelineAsync",
-                             &GPUDevice::createComputePipelineAsync);
-    installMethodWithRuntime(runtime, prototype, "createRenderPipelineAsync",
-                             &GPUDevice::createRenderPipelineAsync);
-    installMethod(runtime, prototype, "createCommandEncoder",
-                  &GPUDevice::createCommandEncoder);
-    installMethod(runtime, prototype, "createRenderBundleEncoder",
-                  &GPUDevice::createRenderBundleEncoder);
-    installMethod(runtime, prototype, "createQuerySet",
-                  &GPUDevice::createQuerySet);
-    installMethod(runtime, prototype, "pushErrorScope",
-                  &GPUDevice::pushErrorScope);
-    installMethodWithRuntime(runtime, prototype, "popErrorScope",
-                             &GPUDevice::popErrorScope);
-    installGetter(runtime, prototype, "features", &GPUDevice::getFeatures);
-    installGetter(runtime, prototype, "limits", &GPUDevice::getLimits);
-    installGetter(runtime, prototype, "queue", &GPUDevice::getQueue);
-    installGetter(runtime, prototype, "lost", &GPUDevice::getLost);
-    installGetterSetter(runtime, prototype, "label", &GPUDevice::getLabel,
-                        &GPUDevice::setLabel);
-    installMethod(runtime, prototype, "forceLossForTesting",
-                  &GPUDevice::forceLossForTesting);
-    installMethod(runtime, prototype, "addEventListener",
-                  &GPUDevice::addEventListener);
-    installMethod(runtime, prototype, "removeEventListener",
-                  &GPUDevice::removeEventListener);
-  }
-
-  inline const wgpu::Device get() { return _instance; }
-
-private:
-  friend class GPUAdapter;
-
-  // Runs the uncapturederror listeners on the creation runtime's JS thread.
-  // Invoked from notifyUncapturedError via the main CallInvoker.
-  void deliverUncapturedError(GPUErrorVariant error);
-
-  wgpu::Device _instance;
-  std::shared_ptr<async::RuntimeContext> _async;
-  std::string _label;
-  // Guards the device-lost state below. In the ProcessEvents model both
-  // notifyDeviceLost() (fired by Dawn during ProcessEvents) and getLost() run
-  // on the owning runtime's own thread, but device destruction can also trigger
-  // notifyDeviceLost() synchronously, so the mutex keeps these fields safe.
-  std::mutex _lostMutex;
-  std::optional<async::AsyncTaskHandle> _lostHandle;
-  std::shared_ptr<GPUDeviceLostInfo> _lostInfo;
-  bool _lostSettled = false;
-  std::optional<async::AsyncTaskHandle::ResolveFunction> _lostResolve;
-
-  // Event listeners storage
-  std::mutex _listenersMutex;
-  std::map<std::string, std::vector<std::shared_ptr<jsi::Function>>>
-      _eventListeners;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDeviceLostInfo.cpp

@@ -1,7 +0,0 @@
-#include "GPUDeviceLostInfo.h"
-#include <string>
-
-namespace rnwgpu {
-wgpu::DeviceLostReason getReason();
-std::string getMessage();
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDeviceLostInfo.h

@@ -1,40 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "descriptors/Unions.h"
-
-#include "jsi/NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUDeviceLostInfo : public NativeObject<GPUDeviceLostInfo> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUDeviceLostInfo";
-
-  explicit GPUDeviceLostInfo(wgpu::DeviceLostReason reason, std::string message)
-      : NativeObject(CLASS_NAME), _reason(reason), _message(message) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  wgpu::DeviceLostReason getReason() { return _reason; }
-  std::string getMessage() { return _message; }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPUDeviceLostInfo::getBrand);
-    installGetter(runtime, prototype, "reason", &GPUDeviceLostInfo::getReason);
-    installGetter(runtime, prototype, "message",
-                  &GPUDeviceLostInfo::getMessage);
-  }
-
-private:
-  wgpu::DeviceLostReason _reason;
-  std::string _message;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUError.h

@@ -1,35 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "jsi/NativeObject.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUError : public NativeObject<GPUError> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUError";
-
-  explicit GPUError(std::string message)
-      : NativeObject(CLASS_NAME), _message(std::move(message)) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-  std::string getMessage() { return _message; }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPUError::getBrand);
-    installGetter(runtime, prototype, "message", &GPUError::getMessage);
-  }
-
-protected:
-  // Protected constructor for subclasses
-  GPUError(const char *className, std::string message)
-      : NativeObject(className), _message(std::move(message)) {}
-
-  std::string _message;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUExtent3D.h

@@ -1,66 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "jsi/JSIConverter.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-struct GPUExtent3D {
-  double width;
-  double height = 1;
-  double depthOrArrayLayers = 1;
-};
-
-template <> struct JSIConverter<std::shared_ptr<GPUExtent3D>> {
-  static std::shared_ptr<GPUExtent3D>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<GPUExtent3D>();
-    if (!outOfBounds && arg.isObject()) {
-      if (arg.getObject(runtime).isArray(runtime)) {
-        auto array = arg.getObject(runtime).asArray(runtime);
-        auto size = array.size(runtime);
-        if (size == 0) {
-          throw std::runtime_error(
-              "Expected an array of size >1 for GPUTExtent3D");
-        }
-        if (size > 0) {
-          result->width = array.getValueAtIndex(runtime, 0).asNumber();
-        }
-        if (size > 1) {
-          result->height = array.getValueAtIndex(runtime, 1).asNumber();
-        }
-        if (size > 2) {
-          result->depthOrArrayLayers =
-              array.getValueAtIndex(runtime, 2).asNumber();
-        }
-      } else {
-        auto object = arg.getObject(runtime);
-        if (object.hasProperty(runtime, "width")) {
-          result->width = object.getProperty(runtime, "width").asNumber();
-        } else {
-          throw std::runtime_error("Property GPUTExtent3D::width is required");
-        }
-        if (object.hasProperty(runtime, "height")) {
-          result->height = object.getProperty(runtime, "height").asNumber();
-        }
-        if (object.hasProperty(runtime, "depthOrArrayLayers")) {
-          result->depthOrArrayLayers =
-              object.getProperty(runtime, "depthOrArrayLayers").asNumber();
-        }
-      }
-    } else {
-      throw std::runtime_error("Expected an object for GPUTExtent3D");
-    }
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<GPUExtent3D> arg) {
-    // No conversions here
-    return jsi::Value::null();
-  }
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUExternalTexture.cpp

@@ -1,139 +0,0 @@
-#include "GPUExternalTexture.h"
-
-#include <cmath>
-#include <memory>
-#include <string>
-#include <utility>
-
-#include "NativeBufferUtils.h"
-#include "descriptors/GPUExternalTextureDescriptor.h"
-
-namespace rnwgpu {
-
-// Identity gamut (same primaries) as a 3x3 column-major matrix.
-static const float kIdentityGamutMatrix[9] = {
-    1.0f, 0.0f, 0.0f, //
-    0.0f, 1.0f, 0.0f, //
-    0.0f, 0.0f, 1.0f, //
-};
-
-// Identity transfer (y = x). The native buffers produced by Skia's NativeBuffer
-// API are single-plane BGRA/RGBA already in the render target's color space, so
-// no conversion is wanted. Dawn dereferences the transfer-function arrays
-// unconditionally (ComputeExternalTextureParams), so these must be non-null.
-static const float kIdentityTransferParams[7] = {
-    1.0f, // G
-    1.0f, // A
-    0.0f, // B
-    0.0f, // C
-    0.0f, // D
-    0.0f, // E
-    0.0f, // F
-};
-
-// Map a rotation in degrees (0 / 90 / 180 / 270) to Dawn's enum. Anything that
-// isn't a clean multiple of 90 snaps to the nearest quadrant; Dawn only
-// supports those four steps for external textures.
-static wgpu::ExternalTextureRotation toExternalTextureRotation(double degrees) {
-  int quadrant = static_cast<int>(std::lround(degrees / 90.0));
-  quadrant = ((quadrant % 4) + 4) % 4;
-  switch (quadrant) {
-  case 1:
-    return wgpu::ExternalTextureRotation::Rotate90Degrees;
-  case 2:
-    return wgpu::ExternalTextureRotation::Rotate180Degrees;
-  case 3:
-    return wgpu::ExternalTextureRotation::Rotate270Degrees;
-  default:
-    return wgpu::ExternalTextureRotation::Rotate0Degrees;
-  }
-}
-
-std::shared_ptr<GPUExternalTexture> GPUExternalTexture::Create(
-    wgpu::Device device,
-    std::shared_ptr<GPUExternalTextureDescriptor> descriptor) {
-  if (!descriptor || descriptor->source == 0) {
-    throw std::runtime_error(
-        "GPUExternalTexture::Create(): descriptor.source (a native buffer "
-        "pointer from Skia.NativeBuffer.MakeFromImage) is required");
-  }
-  void *bufferPtr =
-      reinterpret_cast<void *>(static_cast<uintptr_t>(descriptor->source));
-  std::string label = descriptor->label.value_or("external-texture");
-
-  // 1. Import the native buffer as SharedTextureMemory and read its dimensions.
-  uint32_t width = 0;
-  uint32_t height = 0;
-  wgpu::SharedTextureMemory memory = importNativeBufferAsSharedTextureMemory(
-      device, bufferPtr, label, &width, &height);
-  if (memory == nullptr) {
-    throw std::runtime_error(
-        "GPUExternalTexture::Create(): ImportSharedTextureMemory returned "
-        "null");
-  }
-
-  // 2. Create the texture from the surface (Dawn picks the single-plane
-  //    BGRA/RGBA format).
-  auto texture = memory.CreateTexture();
-  if (texture == nullptr) {
-    throw std::runtime_error(
-        "GPUExternalTexture::Create(): CreateTexture returned null");
-  }
-
-  // 3. Begin access. The matching EndAccess runs when the GPUExternalTexture is
-  //    destroyed (explicitly via destroy() or at GC).
-  wgpu::SharedTextureMemoryBeginAccessDescriptor begin{};
-  begin.initialized = true;
-  begin.concurrentRead = false;
-#if defined(__ANDROID__)
-  // Dawn's Vulkan backend requires the acquired VkImageLayout to be chained.
-  // UNDEFINED (= 0) on both ends is the canonical "no prior GPU producer"
-  // pattern (matches GPUSharedTextureMemory::beginAccess).
-  wgpu::SharedTextureMemoryVkImageLayoutBeginState vkBegin{};
-  vkBegin.oldLayout = 0;
-  vkBegin.newLayout = 0;
-  begin.nextInChain = &vkBegin;
-#endif
-  if (!memory.BeginAccess(texture, &begin)) {
-    throw std::runtime_error(
-        "GPUExternalTexture::Create(): BeginAccess failed");
-  }
-
-  // 4. Single-plane view (the whole BGRA/RGBA surface).
-  auto plane0 = texture.CreateView();
-
-  // 5. Build the ExternalTextureDescriptor. The surface is already RGB in the
-  //    target color space, so pass it through with identity transfer/gamut.
-  wgpu::ExternalTextureDescriptor extDesc{};
-  if (!label.empty()) {
-    extDesc.label = wgpu::StringView(label.c_str(), label.size());
-  }
-  extDesc.plane0 = plane0;
-  extDesc.gamutConversionMatrix = kIdentityGamutMatrix;
-  extDesc.srcTransferFunctionParameters = kIdentityTransferParams;
-  extDesc.dstTransferFunctionParameters = kIdentityTransferParams;
-  extDesc.cropOrigin = {0, 0};
-  extDesc.cropSize = {width, height};
-  extDesc.apparentSize = {width, height};
-  extDesc.mirrored = descriptor->mirrored.value_or(false);
-  extDesc.rotation =
-      toExternalTextureRotation(descriptor->rotation.value_or(0));
-
-  auto external = device.CreateExternalTexture(&extDesc);
-  if (external == nullptr) {
-    wgpu::SharedTextureMemoryEndAccessState state{};
-#if defined(__ANDROID__)
-    wgpu::SharedTextureMemoryVkImageLayoutEndState vkEnd{};
-    state.nextInChain = &vkEnd;
-#endif
-    (void)memory.EndAccess(texture, &state);
-    throw std::runtime_error(
-        "GPUExternalTexture::Create(): CreateExternalTexture returned null");
-  }
-
-  return std::make_shared<GPUExternalTexture>(
-      std::move(external), std::move(memory), std::move(texture),
-      std::move(label));
-}
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUExternalTexture.h

@@ -1,95 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <utility>
-
-#include "descriptors/Unions.h"
-
-#include "jsi/NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-struct GPUExternalTextureDescriptor;
-
-class GPUExternalTexture : public NativeObject<GPUExternalTexture> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUExternalTexture";
-
-  // Import a native buffer (via descriptor.source, a CVPixelBufferRef /
-  // AHardwareBuffer* from Skia's NativeBuffer API) as a GPUExternalTexture on
-  // `device`: imports the native surface as SharedTextureMemory, begins access,
-  // and wraps the resulting wgpu::ExternalTexture together with the resources
-  // whose lifetime it owns. The matching EndAccess runs in destroy() / the
-  // destructor. Defined in GPUExternalTexture.cpp.
-  static std::shared_ptr<GPUExternalTexture>
-  Create(wgpu::Device device,
-         std::shared_ptr<GPUExternalTextureDescriptor> descriptor);
-
-  // Construct from an already-built wgpu::ExternalTexture plus the underlying
-  // shared-memory resources we need to keep alive. The wrapper takes ownership
-  // of the SharedTextureMemory + Texture and calls EndAccess on destruction so
-  // the producer (the native buffer's surface) can reclaim it.
-  GPUExternalTexture(wgpu::ExternalTexture instance,
-                     wgpu::SharedTextureMemory memory, wgpu::Texture texture,
-                     std::string label)
-      : NativeObject(CLASS_NAME), _instance(std::move(instance)),
-        _memory(std::move(memory)), _texture(std::move(texture)),
-        _label(std::move(label)) {}
-
-  ~GPUExternalTexture() override { destroy(); }
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  // End the shared-memory access window and release the underlying resources.
-  // Idempotent: safe to call more than once, and the destructor calls it as a
-  // garbage-collection fallback. Call it right after the queue.submit() that
-  // sampled this texture (never before): a GPUExternalTexture's access window
-  // is owned by this wrapper's lifetime, not by submit, so without an explicit
-  // destroy() the producer's surface stays claimed until GC runs. EndAccess is
-  // the designed post-submit call: Dawn keeps the texture alive for in-flight
-  // GPU work via the fences it returns.
-  void destroy() {
-    if (_memory && _texture) {
-      wgpu::SharedTextureMemoryEndAccessState state{};
-#if defined(__ANDROID__)
-      // Dawn's Vulkan backend requires the released VkImageLayout to be chained
-      // (matches BeginAccess in GPUExternalTexture::Create).
-      wgpu::SharedTextureMemoryVkImageLayoutEndState vkEnd{};
-      state.nextInChain = &vkEnd;
-#endif
-      (void)_memory.EndAccess(_texture, &state);
-    }
-    _texture = nullptr;
-    _memory = nullptr;
-  }
-
-  std::string getLabel() { return _label; }
-  void setLabel(const std::string &label) {
-    _label = label;
-    _instance.SetLabel(_label.c_str());
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPUExternalTexture::getBrand);
-    installGetterSetter(runtime, prototype, "label",
-                        &GPUExternalTexture::getLabel,
-                        &GPUExternalTexture::setLabel);
-    installMethod(runtime, prototype, "destroy", &GPUExternalTexture::destroy);
-  }
-
-  inline const wgpu::ExternalTexture get() { return _instance; }
-
-private:
-  wgpu::ExternalTexture _instance;
-  wgpu::SharedTextureMemory _memory;
-  wgpu::Texture _texture;
-  std::string _label;
-};
-
-} // namespace rnwgpu