feat: expose Dawn debug toggles via requestDevice() dawnToggles option

JS側から dump_shaders や use_user_defined_labels_in_backend などの
Dawn デバッグトグルを有効化・無効化できるようにする。
WebGPU仕様外の非標準拡張フィールドとして GPUDeviceDescriptor に追加。

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: halby24

packages/webgpu/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -86,15 +86,45 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
   std::string label =
       descriptor.has_value() ? descriptor.value()->label.value_or("") : "";
 
+  // Extract Dawn toggle data by value before the async lambda captures it
+  std::optional<rnwgpu::GPUDawnTogglesDescriptor> dawnTogglesData;
+  if (descriptor.has_value() && descriptor.value()->dawnToggles.has_value()) {
+    dawnTogglesData = *descriptor.value()->dawnToggles.value();
+  }
+
   auto creationRuntime = getCreationRuntime();
   return _async->postTask(
       [this, aDescriptor, descriptor, label = std::move(label),
-       deviceLostBinding,
+       deviceLostBinding, dawnTogglesData = std::move(dawnTogglesData),
        creationRuntime](const async::AsyncTaskHandle::ResolveFunction &resolve,
                         const async::AsyncTaskHandle::RejectFunction &reject) {
         (void)descriptor;
+
+        // Build Dawn toggles chain if provided
+        wgpu::DawnTogglesDescriptor togglesDesc;
+        std::vector<const char *> enablePtrs, disablePtrs;
+        auto localDescriptor = aDescriptor;
+
+        if (dawnTogglesData.has_value()) {
+          const auto &td = *dawnTogglesData;
+          if (td.enable.has_value() && !td.enable->empty()) {
+            for (const auto &s : *td.enable) enablePtrs.push_back(s.c_str());
+            togglesDesc.enabledToggles = enablePtrs.data();
+            togglesDesc.enabledTogglesCount = enablePtrs.size();
+          }
+          if (td.disable.has_value() && !td.disable->empty()) {
+            for (const auto &s : *td.disable) disablePtrs.push_back(s.c_str());
+            togglesDesc.disabledToggles = disablePtrs.data();
+            togglesDesc.disabledTogglesCount = disablePtrs.size();
+          }
+          if (!enablePtrs.empty() || !disablePtrs.empty()) {
+            togglesDesc.nextInChain = localDescriptor.nextInChain;
+            localDescriptor.nextInChain = &togglesDesc;
+          }
+        }
+
         _instance.RequestDevice(
-            &aDescriptor, wgpu::CallbackMode::AllowProcessEvents,
+            &localDescriptor, wgpu::CallbackMode::AllowProcessEvents,
             [asyncRunner = _async, resolve, reject, label, creationRuntime,
              deviceLostBinding](wgpu::RequestDeviceStatus status,
                                 wgpu::Device device,
@@ -131,6 +161,8 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
                   break;
                 case wgpu::LoggingType::Verbose:
                   logLevel = "Verbose";
+                  Logger::logToConsole("%s: %.*s", logLevel,
+                                       static_cast<int>(msg.length), msg.data);
                   break;
                 case wgpu::LoggingType::Info:
                   logLevel = "Info";

packages/webgpu/cpp/rnwgpu/api/descriptors/GPUDawnTogglesDescriptor.h

@@ -0,0 +1,37 @@
+#pragma once
+#include <optional>
+#include <string>
+#include <vector>
+#include "JSIConverter.h"
+
+namespace rnwgpu {
+
+struct GPUDawnTogglesDescriptor {
+  std::optional<std::vector<std::string>> enable;
+  std::optional<std::vector<std::string>> disable;
+};
+
+template <>
+struct JSIConverter<std::shared_ptr<GPUDawnTogglesDescriptor>> {
+  static std::shared_ptr<GPUDawnTogglesDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_shared<GPUDawnTogglesDescriptor>();
+    if (outOfBounds || arg.isNull() || arg.isUndefined()) return result;
+    auto obj = arg.asObject(runtime);
+    if (obj.hasProperty(runtime, "enable")) {
+      result->enable = JSIConverter<std::vector<std::string>>::fromJSI(
+          runtime, obj.getProperty(runtime, "enable"), false);
+    }
+    if (obj.hasProperty(runtime, "disable")) {
+      result->disable = JSIConverter<std::vector<std::string>>::fromJSI(
+          runtime, obj.getProperty(runtime, "disable"), false);
+    }
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &,
+                           std::shared_ptr<GPUDawnTogglesDescriptor>) {
+    throw std::runtime_error("GPUDawnTogglesDescriptor: toJSI not supported");
+  }
+};
+
+} // namespace rnwgpu

packages/webgpu/cpp/rnwgpu/api/descriptors/GPUDeviceDescriptor.h

@@ -11,6 +11,7 @@
 #include "WGPULogger.h"
 
 #include "GPUQueueDescriptor.h"
+#include "GPUDawnTogglesDescriptor.h"
 
 namespace jsi = facebook::jsi;
 
@@ -24,6 +25,7 @@ struct GPUDeviceDescriptor {
   std::optional<std::shared_ptr<GPUQueueDescriptor>>
       defaultQueue;                 // GPUQueueDescriptor
   std::optional<std::string> label; // string
+  std::optional<std::shared_ptr<GPUDawnTogglesDescriptor>> dawnToggles;
 };
 
 } // namespace rnwgpu
@@ -87,6 +89,12 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDeviceDescriptor>> {
         result->label = JSIConverter<std::optional<std::string>>::fromJSI(
             runtime, prop, false);
       }
+      if (value.hasProperty(runtime, "dawnToggles")) {
+        auto prop = value.getProperty(runtime, "dawnToggles");
+        result->dawnToggles =
+            JSIConverter<std::optional<std::shared_ptr<GPUDawnTogglesDescriptor>>>::
+                fromJSI(runtime, prop, false);
+      }
     }
 
     return result;

packages/webgpu/src/types.ts

@@ -1,5 +1,24 @@
 type SurfacePointer = bigint;
 
+/** Dawn固有のデバッグトグル設定 (WebGPU仕様外) */
+export interface DawnTogglesDescriptor {
+  /**
+   * 有効化するトグル名の配列
+   * 例: 'dump_shaders', 'use_user_defined_labels_in_backend',
+   *     'disable_symbol_renaming', 'emit_hlsl_debug_symbols'
+   */
+  enable?: string[];
+  /** 無効化するトグル名の配列 */
+  disable?: string[];
+}
+
+declare global {
+  interface GPUDeviceDescriptor {
+    /** Dawn固有のトグル設定。非Dawn環境では無視される。 */
+    dawnToggles?: DawnTogglesDescriptor;
+  }
+}
+
 export interface NativeCanvas {
   surface: SurfacePointer;
   width: number;