react-native-wgpu 0.1.0 → 0.1.2

package/cpp/rnwgpu/api/descriptors/GPUImageCopyTextureTagged.h

@@ -1,28 +1,37 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "External.h"
+#include "GPUOrigin3D.h"
+#include "GPUTexture.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUImageCopyTextureTagged {
-public:
-  wgpu::ImageCopyTextureTagged *getInstance() { return &_instance; }
-
-  wgpu::ImageCopyTextureTagged _instance;
+struct GPUImageCopyTextureTagged {
+  std::optional<PredefinedColorSpace> colorSpace;     // PredefinedColorSpace
+  std::optional<bool> premultipliedAlpha;             // boolean
+  std::shared_ptr<GPUTexture> texture;                // GPUTexture
+  std::optional<double> mipLevel;                     // GPUIntegerCoordinate
+  std::optional<std::shared_ptr<GPUOrigin3D>> origin; // GPUOrigin3D
+  std::optional<wgpu::TextureAspect> aspect;          // GPUTextureAspect
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyTextureTagged>> {
   static std::shared_ptr<rnwgpu::GPUImageCopyTextureTagged>
@@ -31,58 +40,47 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyTextureTagged>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "colorSpace")) {
-        auto colorSpace = value.getProperty(runtime, "colorSpace");
+        auto prop = value.getProperty(runtime, "colorSpace");
+        result->colorSpace =
+            JSIConverter<std::optional<PredefinedColorSpace>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "premultipliedAlpha")) {
-        auto premultipliedAlpha =
-            value.getProperty(runtime, "premultipliedAlpha");
+        auto prop = value.getProperty(runtime, "premultipliedAlpha");
+        result->premultipliedAlpha =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "texture")) {
-        auto texture = value.getProperty(runtime, "texture");
-
-        if (texture.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUImageCopyTextureTagged::texture is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUImageCopyTextureTagged::texture is not defined");
+        auto prop = value.getProperty(runtime, "texture");
+        result->texture = JSIConverter<std::shared_ptr<GPUTexture>>::fromJSI(
+            runtime, prop, false);
       }
       if (value.hasProperty(runtime, "mipLevel")) {
-        auto mipLevel = value.getProperty(runtime, "mipLevel");
-
-        if (mipLevel.isNumber()) {
-          result->_instance.mipLevel =
-              static_cast<wgpu::IntegerCoordinate>(mipLevel.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "mipLevel");
+        result->mipLevel =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "origin")) {
-        auto origin = value.getProperty(runtime, "origin");
+        auto prop = value.getProperty(runtime, "origin");
+        result->origin =
+            JSIConverter<std::optional<std::shared_ptr<GPUOrigin3D>>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "aspect")) {
-        auto aspect = value.getProperty(runtime, "aspect");
+        auto prop = value.getProperty(runtime, "aspect");
+        result->aspect =
+            JSIConverter<std::optional<wgpu::TextureAspect>>::fromJSI(
+                runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUImageCopyTextureTagged::colorSpace = %f",
-                                 result->_instance.colorSpace);
-    rnwgpu::Logger::logToConsole(
-        "GPUImageCopyTextureTagged::premultipliedAlpha = %f",
-        result->_instance.premultipliedAlpha);
-    rnwgpu::Logger::logToConsole("GPUImageCopyTextureTagged::texture = %f",
-                                 result->_instance.texture);
-    rnwgpu::Logger::logToConsole("GPUImageCopyTextureTagged::mipLevel = %f",
-                                 result->_instance.mipLevel);
-    rnwgpu::Logger::logToConsole("GPUImageCopyTextureTagged::origin = %f",
-                                 result->_instance.origin);
-    rnwgpu::Logger::logToConsole("GPUImageCopyTextureTagged::aspect = %f",
-                                 result->_instance.aspect);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUImageCopyTextureTagged> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUImageCopyTextureTagged::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUImageDataLayout.h

@@ -1,28 +1,31 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUImageDataLayout {
-public:
-  wgpu::ImageDataLayout *getInstance() { return &_instance; }
-
-  wgpu::ImageDataLayout _instance;
+struct GPUImageDataLayout {
+  std::optional<double> offset;       // GPUSize64
+  std::optional<double> bytesPerRow;  // GPUSize32
+  std::optional<double> rowsPerImage; // GPUSize32
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageDataLayout>> {
   static std::shared_ptr<rnwgpu::GPUImageDataLayout>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -30,41 +33,28 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageDataLayout>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "offset")) {
-        auto offset = value.getProperty(runtime, "offset");
-
-        if (offset.isNumber()) {
-          result->_instance.offset = offset.getNumber();
-        }
+        auto prop = value.getProperty(runtime, "offset");
+        result->offset =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "bytesPerRow")) {
-        auto bytesPerRow = value.getProperty(runtime, "bytesPerRow");
-
-        if (bytesPerRow.isNumber()) {
-          result->_instance.bytesPerRow =
-              static_cast<wgpu::Size32>(bytesPerRow.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "bytesPerRow");
+        result->bytesPerRow =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "rowsPerImage")) {
-        auto rowsPerImage = value.getProperty(runtime, "rowsPerImage");
-
-        if (rowsPerImage.isNumber()) {
-          result->_instance.rowsPerImage =
-              static_cast<wgpu::Size32>(rowsPerImage.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "rowsPerImage");
+        result->rowsPerImage =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUImageDataLayout::offset = %f",
-                                 result->_instance.offset);
-    rnwgpu::Logger::logToConsole("GPUImageDataLayout::bytesPerRow = %f",
-                                 result->_instance.bytesPerRow);
-    rnwgpu::Logger::logToConsole("GPUImageDataLayout::rowsPerImage = %f",
-                                 result->_instance.rowsPerImage);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUImageDataLayout> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUImageDataLayout::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUMultisampleState.h

@@ -1,28 +1,31 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUMultisampleState {
-public:
-  wgpu::MultisampleState *getInstance() { return &_instance; }
-
-  wgpu::MultisampleState _instance;
+struct GPUMultisampleState {
+  std::optional<double> count;                // GPUSize32
+  std::optional<double> mask;                 // GPUSampleMask
+  std::optional<bool> alphaToCoverageEnabled; // boolean
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUMultisampleState>> {
   static std::shared_ptr<rnwgpu::GPUMultisampleState>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -30,39 +33,28 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUMultisampleState>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "count")) {
-        auto count = value.getProperty(runtime, "count");
-
-        if (count.isNumber()) {
-          result->_instance.count =
-              static_cast<wgpu::Size32>(count.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "count");
+        result->count =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "mask")) {
-        auto mask = value.getProperty(runtime, "mask");
-
-        if (mask.isNumber()) {
-          result->_instance.mask =
-              static_cast<wgpu::SampleMask>(mask.getNumber());
-        }
+        auto prop = value.getProperty(runtime, "mask");
+        result->mask =
+            JSIConverter<std::optional<double>>::fromJSI(runtime, prop, false);
       }
       if (value.hasProperty(runtime, "alphaToCoverageEnabled")) {
-        auto alphaToCoverageEnabled =
-            value.getProperty(runtime, "alphaToCoverageEnabled");
+        auto prop = value.getProperty(runtime, "alphaToCoverageEnabled");
+        result->alphaToCoverageEnabled =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUMultisampleState::count = %f",
-                                 result->_instance.count);
-    rnwgpu::Logger::logToConsole("GPUMultisampleState::mask = %f",
-                                 result->_instance.mask);
-    rnwgpu::Logger::logToConsole(
-        "GPUMultisampleState::alphaToCoverageEnabled = %f",
-        result->_instance.alphaToCoverageEnabled);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUMultisampleState> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUMultisampleState::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUPipelineLayoutDescriptor.h

@@ -2,29 +2,33 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUBindGroupLayout.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUPipelineLayoutDescriptor {
-public:
-  wgpu::PipelineLayoutDescriptor *getInstance() { return &_instance; }
-
-  wgpu::PipelineLayoutDescriptor _instance;
-
-  std::string label;
+struct GPUPipelineLayoutDescriptor {
+  std::vector<std::shared_ptr<GPUBindGroupLayout>>
+      bindGroupLayouts;             // Iterable<GPUBindGroupLayout>
+  std::optional<std::string> label; // string
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUPipelineLayoutDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUPipelineLayoutDescriptor>
@@ -33,40 +37,26 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUPipelineLayoutDescriptor>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "bindGroupLayouts")) {
-        auto bindGroupLayouts = value.getProperty(runtime, "bindGroupLayouts");
-
-        if (bindGroupLayouts.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUPipelineLayoutDescriptor::bindGroupLayouts is "
-              "required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUPipelineLayoutDescriptor::bindGroupLayouts is not "
-            "defined");
+        auto prop = value.getProperty(runtime, "bindGroupLayouts");
+        result->bindGroupLayouts = JSIConverter<
+            std::vector<std::shared_ptr<GPUBindGroupLayout>>>::fromJSI(runtime,
+                                                                       prop,
+                                                                       false);
       }
       if (value.hasProperty(runtime, "label")) {
-        auto label = value.getProperty(runtime, "label");
-
-        if (label.isString()) {
-          auto str = label.asString(runtime).utf8(runtime);
-          result->label = str;
-          result->_instance.label = result->label.c_str();
-        }
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole(
-        "GPUPipelineLayoutDescriptor::bindGroupLayouts = %f",
-        result->_instance.bindGroupLayouts);
-    rnwgpu::Logger::logToConsole("GPUPipelineLayoutDescriptor::label = %f",
-                                 result->_instance.label);
+
     return result;
   }
   static jsi::Value
   toJSI(jsi::Runtime &runtime,
         std::shared_ptr<rnwgpu::GPUPipelineLayoutDescriptor> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUPipelineLayoutDescriptor::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUPrimitiveState.h

@@ -1,28 +1,33 @@
 #pragma once
 
 #include <memory>
-#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUPrimitiveState {
-public:
-  wgpu::PrimitiveState *getInstance() { return &_instance; }
-
-  wgpu::PrimitiveState _instance;
+struct GPUPrimitiveState {
+  std::optional<wgpu::PrimitiveTopology> topology;   // GPUPrimitiveTopology
+  std::optional<wgpu::IndexFormat> stripIndexFormat; // GPUIndexFormat
+  std::optional<wgpu::FrontFace> frontFace;          // GPUFrontFace
+  std::optional<wgpu::CullMode> cullMode;            // GPUCullMode
+  std::optional<bool> unclippedDepth;                // boolean
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUPrimitiveState>> {
   static std::shared_ptr<rnwgpu::GPUPrimitiveState>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -30,37 +35,41 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUPrimitiveState>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "topology")) {
-        auto topology = value.getProperty(runtime, "topology");
+        auto prop = value.getProperty(runtime, "topology");
+        result->topology =
+            JSIConverter<std::optional<wgpu::PrimitiveTopology>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "stripIndexFormat")) {
-        auto stripIndexFormat = value.getProperty(runtime, "stripIndexFormat");
+        auto prop = value.getProperty(runtime, "stripIndexFormat");
+        result->stripIndexFormat =
+            JSIConverter<std::optional<wgpu::IndexFormat>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "frontFace")) {
-        auto frontFace = value.getProperty(runtime, "frontFace");
+        auto prop = value.getProperty(runtime, "frontFace");
+        result->frontFace =
+            JSIConverter<std::optional<wgpu::FrontFace>>::fromJSI(runtime, prop,
+                                                                  false);
       }
       if (value.hasProperty(runtime, "cullMode")) {
-        auto cullMode = value.getProperty(runtime, "cullMode");
+        auto prop = value.getProperty(runtime, "cullMode");
+        result->cullMode = JSIConverter<std::optional<wgpu::CullMode>>::fromJSI(
+            runtime, prop, false);
       }
       if (value.hasProperty(runtime, "unclippedDepth")) {
-        auto unclippedDepth = value.getProperty(runtime, "unclippedDepth");
+        auto prop = value.getProperty(runtime, "unclippedDepth");
+        result->unclippedDepth =
+            JSIConverter<std::optional<bool>>::fromJSI(runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUPrimitiveState::topology = %f",
-                                 result->_instance.topology);
-    rnwgpu::Logger::logToConsole("GPUPrimitiveState::stripIndexFormat = %f",
-                                 result->_instance.stripIndexFormat);
-    rnwgpu::Logger::logToConsole("GPUPrimitiveState::frontFace = %f",
-                                 result->_instance.frontFace);
-    rnwgpu::Logger::logToConsole("GPUPrimitiveState::cullMode = %f",
-                                 result->_instance.cullMode);
-    rnwgpu::Logger::logToConsole("GPUPrimitiveState::unclippedDepth = %f",
-                                 result->_instance.unclippedDepth);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUPrimitiveState> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUPrimitiveState::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUProgrammableStage.h

@@ -1,30 +1,35 @@
 #pragma once
 
+#include <map>
 #include <memory>
 #include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Logger.h"
 #include "RNFJSIConverter.h"
-#include <RNFHybridObject.h>
+#include "WGPULogger.h"
+
+#include "GPUShaderModule.h"
+#include "RNFHybridObject.h"
 
 namespace jsi = facebook::jsi;
+namespace m = margelo;
 
 namespace rnwgpu {
 
-class GPUProgrammableStage {
-public:
-  wgpu::ProgrammableStage *getInstance() { return &_instance; }
-
-  wgpu::ProgrammableStage _instance;
-
-  std::string entryPoint;
+struct GPUProgrammableStage {
+  std::shared_ptr<GPUShaderModule> module; // GPUShaderModule
+  std::optional<std::string> entryPoint;   // string
+  std::optional<std::map<std::string, double>>
+      constants; // Record< string, GPUPipelineConstantValue >
 };
+
 } // namespace rnwgpu
 
 namespace margelo {
 
+using namespace rnwgpu; // NOLINT(build/namespaces)
+
 template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUProgrammableStage>> {
   static std::shared_ptr<rnwgpu::GPUProgrammableStage>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
@@ -32,41 +37,30 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUProgrammableStage>> {
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "module")) {
-        auto module = value.getProperty(runtime, "module");
-
-        if (module.isUndefined()) {
-          throw std::runtime_error(
-              "Property GPUProgrammableStage::module is required");
-        }
-      } else {
-        throw std::runtime_error(
-            "Property GPUProgrammableStage::module is not defined");
+        auto prop = value.getProperty(runtime, "module");
+        result->module =
+            JSIConverter<std::shared_ptr<GPUShaderModule>>::fromJSI(
+                runtime, prop, false);
       }
       if (value.hasProperty(runtime, "entryPoint")) {
-        auto entryPoint = value.getProperty(runtime, "entryPoint");
-
-        if (entryPoint.isString()) {
-          auto str = entryPoint.asString(runtime).utf8(runtime);
-          result->entryPoint = str;
-          result->_instance.entryPoint = result->entryPoint.c_str();
-        }
+        auto prop = value.getProperty(runtime, "entryPoint");
+        result->entryPoint = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
       }
       if (value.hasProperty(runtime, "constants")) {
-        auto constants = value.getProperty(runtime, "constants");
+        auto prop = value.getProperty(runtime, "constants");
+        result->constants =
+            JSIConverter<std::optional<std::map<std::string, double>>>::fromJSI(
+                runtime, prop, false);
       }
     }
-    rnwgpu::Logger::logToConsole("GPUProgrammableStage::module = %f",
-                                 result->_instance.module);
-    rnwgpu::Logger::logToConsole("GPUProgrammableStage::entryPoint = %f",
-                                 result->_instance.entryPoint);
-    rnwgpu::Logger::logToConsole("GPUProgrammableStage::constants = %f",
-                                 result->_instance.constants);
+
     return result;
   }
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUProgrammableStage> arg) {
-    // No conversions here
-    return jsi::Value::null();
+    throw std::runtime_error("Invalid GPUProgrammableStage::toJSI()");
   }
 };
-} // namespace margelo
+
+} // namespace margelo