react-native-nitro-modules 0.1.6 → 0.2.0

package/cpp/jsi/JSIConverter.hpp

@@ -25,18 +25,34 @@ using namespace facebook;
  * Value types, custom types (HostObjects), and even functions with any number of arguments/types are supported.
  * This type can be extended by just creating a new template for JSIConverter in a header.
  */
-template <typename ArgType, typename Enable = void>
+template <typename T, typename Enable = void>
 struct JSIConverter final {
   JSIConverter() = delete;
 
-  static inline ArgType fromJSI(jsi::Runtime&, const jsi::Value&) {
-    static_assert(always_false<ArgType>::value, "This type is not supported by the JSIConverter!");
-    return ArgType();
-  }
-  static inline jsi::Value toJSI(jsi::Runtime&, ArgType) {
-    static_assert(always_false<ArgType>::value, "This type is not supported by the JSIConverter!");
+  /**
+   * Converts the given `jsi::Value` to type `T`.
+   * By default, this static-asserts.
+   */
+  static inline T fromJSI(jsi::Runtime&, const jsi::Value&) {
+    static_assert(always_false<T>::value, "This type is not supported by the JSIConverter!");
+    return T();
+  }
+  /**
+   * Converts `T` to a `jsi::Value`.
+   * By default, this static-asserts.
+   */
+  static inline jsi::Value toJSI(jsi::Runtime&, T) {
+    static_assert(always_false<T>::value, "This type is not supported by the JSIConverter!");
     return jsi::Value::undefined();
   }
+  /**
+   * Returns whether the given `jsi::Value` can be converted to `T`.
+   * This involves runtime type-checks.
+   * By default, this returns `false`.
+   */
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value&) {
+    return false;
+  }
 
 private:
   template <typename>
@@ -52,6 +68,9 @@ struct JSIConverter<int> {
   static inline jsi::Value toJSI(jsi::Runtime&, int arg) {
     return jsi::Value(arg);
   }
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+    return value.isNumber();
+  }
 };
 
 // std::monostate <> null
@@ -63,6 +82,9 @@ struct JSIConverter<std::monostate> {
   static inline jsi::Value toJSI(jsi::Runtime&, std::monostate arg) {
     return jsi::Value::null();
   }
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+    return value.isNull() || value.isUndefined();
+  }
 };
 
 // double <> number
@@ -74,6 +96,9 @@ struct JSIConverter<double> {
   static inline jsi::Value toJSI(jsi::Runtime&, double arg) {
     return jsi::Value(arg);
   }
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+    return value.isNumber();
+  }
 };
 
 // float <> number
@@ -85,6 +110,9 @@ struct JSIConverter<float> {
   static inline jsi::Value toJSI(jsi::Runtime&, float arg) {
     return jsi::Value(static_cast<double>(arg));
   }
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+    return value.isNumber();
+  }
 };
 
 // int64_t <> BigInt
@@ -96,6 +124,13 @@ struct JSIConverter<int64_t> {
   static inline jsi::Value toJSI(jsi::Runtime& runtime, int64_t arg) {
     return jsi::BigInt::fromInt64(runtime, arg);
   }
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (value.isBigInt()) {
+      jsi::BigInt bigint = value.getBigInt(runtime);
+      return bigint.isInt64(runtime);
+    }
+    return false;
+  }
 };
 
 // uint64_t <> BigInt
@@ -107,6 +142,13 @@ struct JSIConverter<uint64_t> {
   static inline jsi::Value toJSI(jsi::Runtime& runtime, uint64_t arg) {
     return jsi::BigInt::fromUint64(runtime, arg);
   }
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (value.isBigInt()) {
+      jsi::BigInt bigint = value.getBigInt(runtime);
+      return bigint.isUint64(runtime);
+    }
+    return false;
+  }
 };
 
 // bool <> boolean
@@ -118,6 +160,9 @@ struct JSIConverter<bool> {
   static inline jsi::Value toJSI(jsi::Runtime&, bool arg) {
     return jsi::Value(arg);
   }
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+    return value.isBool();
+  }
 };
 
 // std::string <> string
@@ -129,6 +174,9 @@ struct JSIConverter<std::string> {
   static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::string& arg) {
     return jsi::String::createFromUtf8(runtime, arg);
   }
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+    return value.isString();
+  }
 };
 
 } // namespace margelo::nitro

package/cpp/jsi/JSIHelpers.hpp

@@ -0,0 +1,52 @@
+//
+//  JSIHelpers.hpp
+//  Pods
+//
+//  Created by Marc Rousavy on 07.08.24.
+//
+
+#pragma once
+
+#include "ThreadUtils.hpp"
+#include <jsi/jsi.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Returns whether the given `jsi::Object` is a plain-JS object, or not.
+ * If it is not a plain-JS object, it could be an Array, ArrayBuffer, Function,
+ * HostObject or NativeState.
+ */
+static inline bool isPlainObject(jsi::Runtime& runtime, const jsi::Object& object) {
+  if (object.isArray(runtime)) {
+    return false;
+  }
+  if (object.isArrayBuffer(runtime)) {
+    return false;
+  }
+  if (object.isFunction(runtime)) {
+    return false;
+  }
+  if (object.isHostObject(runtime)) {
+    return false;
+  }
+  if (object.hasNativeState(runtime)) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Get an ID for the given Runtime.
+ *
+ * The ID usually consists of a Runtime description (e.g. "HermesRuntime"),
+ * and it's Thread (e.g. "com.facebook.react.runtime.JavaScript")
+ */
+static inline std::string getRuntimeId(jsi::Runtime& runtime) {
+  std::string threadName = ThreadUtils::getThreadName();
+  return runtime.description() + std::string(" (") + threadName + std::string(")");
+}
+
+} // namespace margelo::nitro

package/cpp/jsi/Promise.cpp

@@ -9,8 +9,8 @@ using namespace facebook;
 
 Promise::Promise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter) {
   auto functionCache = JSICache::getOrCreateCache(runtime);
-  _resolver = functionCache.makeGlobal<jsi::Function>(std::move(resolver));
-  _rejecter = functionCache.makeGlobal<jsi::Function>(std::move(rejecter));
+  _resolver = functionCache.makeShared(std::move(resolver));
+  _rejecter = functionCache.makeShared(std::move(rejecter));
 }
 
 jsi::Value Promise::createPromise(jsi::Runtime& runtime, RunPromise&& run) {

package/cpp/prototype/HybridObjectPrototype.cpp

@@ -0,0 +1,87 @@
+//
+//  HybridObjectPrototype.cpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 07.08.24.
+//
+
+#include "HybridObjectPrototype.hpp"
+#include "NitroLogger.hpp"
+
+namespace margelo::nitro {
+
+std::unordered_map<jsi::Runtime*, HybridObjectPrototype::PrototypeCache> HybridObjectPrototype::_prototypeCache;
+
+jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const std::shared_ptr<Prototype>& prototype) {
+  // 0. Check if we're at the highest level of our prototype chain
+  if (prototype == nullptr) {
+    // There is no prototype - we just have an empty Object base - so `Object.create({})`
+    return jsi::Object(runtime);
+  }
+
+  // 1. Try looking for the given prototype in cache.
+  //    If we find it in cache, we can create instances faster and skip creating the prototype from scratch!
+  auto& prototypeCache = _prototypeCache[&runtime];
+  auto cachedPrototype = prototypeCache.find(prototype->getNativeInstanceId());
+  if (cachedPrototype != prototypeCache.end()) {
+    const OwningReference<jsi::Object>& cachedObject = cachedPrototype->second;
+    return jsi::Value(runtime, *cachedObject).getObject(runtime);
+  }
+
+  // 2. We didn't find the given prototype in cache (either it's a new prototype, or a new runtime),
+  //    so we need to create it. First, we need some helper methods from JS
+  Logger::log(TAG, "Creating new JS prototype for C++ instance type \"%s\"...", prototype->getNativeInstanceId().name());
+  jsi::Object objectConstructor = runtime.global().getPropertyAsObject(runtime, "Object");
+  jsi::Function objectCreate = objectConstructor.getPropertyAsFunction(runtime, "create");
+  jsi::Function objectDefineProperty = objectConstructor.getPropertyAsFunction(runtime, "defineProperty");
+
+  // 3. Create an empty JS Object, inheriting from the base prototype (recursively!)
+  jsi::Object object = objectCreate.call(runtime, createPrototype(runtime, prototype->getBase())).getObject(runtime);
+
+  // 4. Add all Hybrid Methods to it
+  for (const auto& method : prototype->getMethods()) {
+    object.setProperty(runtime, method.first.c_str(), method.second.toJSFunction(runtime));
+  }
+
+  // 5. Add all properties (getter + setter) to it using defineProperty
+  for (const auto& getter : prototype->getGetters()) {
+    jsi::Object property(runtime);
+    property.setProperty(runtime, "configurable", false);
+    property.setProperty(runtime, "enumerable", true);
+    property.setProperty(runtime, "get", getter.second.toJSFunction(runtime));
+
+    const auto& setter = prototype->getSetters().find(getter.first);
+    if (setter != prototype->getSetters().end()) {
+      // there also is a setter for this property!
+      property.setProperty(runtime, "set", setter->second.toJSFunction(runtime));
+    }
+
+    property.setProperty(runtime, "name", jsi::String::createFromUtf8(runtime, getter.first.c_str()));
+    objectDefineProperty.call(runtime,
+                              /* obj */ object,
+                              /* propName */ jsi::String::createFromUtf8(runtime, getter.first.c_str()),
+                              /* descriptorObj */ property);
+  }
+
+  // 6. Throw it into our cache so the next lookup can be cached and therefore faster
+  JSICacheReference jsiCache = JSICache::getOrCreateCache(runtime);
+  OwningReference<jsi::Object> cachedObject = jsiCache.makeShared(std::move(object));
+  prototypeCache.emplace(prototype->getNativeInstanceId(), cachedObject);
+
+  // 7. In DEBUG, add a __type info to the prototype object.
+#if DEBUG
+  auto typeName = "Prototype<" + std::string(prototype->getNativeInstanceId().name()) + ">";
+  cachedObject->setProperty(runtime, "__type", jsi::String::createFromUtf8(runtime, typeName));
+#endif
+
+  // 8. Return it!
+  return jsi::Value(runtime, *cachedObject);
+}
+
+jsi::Value HybridObjectPrototype::getPrototype(jsi::Runtime& runtime) {
+  ensureInitialized();
+
+  return createPrototype(runtime, _prototypeChain.getPrototype());
+}
+
+} // namespace margelo::nitro

package/cpp/prototype/HybridObjectPrototype.hpp

@@ -0,0 +1,92 @@
+//
+//  HybridObjectPrototype.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 07.08.24.
+//
+
+#pragma once
+
+#include "HybridFunction.hpp"
+#include "OwningReference.hpp"
+#include "Prototype.hpp"
+#include "PrototypeChain.hpp"
+#include <functional>
+#include <jsi/jsi.h>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents a Hybrid Object's prototype.
+ * The prototype should be cached per Runtime, and can be assigned to multiple jsi::Objects.
+ * When assigned to a jsi::Object, all methods of this prototype can be called on that jsi::Object,
+ * as long as it has a valid NativeState (`this`).
+ */
+class HybridObjectPrototype {
+private:
+  PrototypeChain _prototypeChain;
+  bool _didLoadMethods = false;
+  static constexpr auto TAG = "HybridObjectPrototype";
+
+public:
+  HybridObjectPrototype() {}
+
+public:
+  /**
+   * Get a fully initialized jsi::Object that represents this prototype to JS.
+   * The result of this value will be cached per Runtime, so it's safe to call this often.
+   */
+  jsi::Value getPrototype(jsi::Runtime& runtime);
+
+private:
+  static jsi::Value createPrototype(jsi::Runtime& runtime, const std::shared_ptr<Prototype>& prototype);
+  using PrototypeCache = std::unordered_map<NativeInstanceId, OwningReference<jsi::Object>>;
+  static std::unordered_map<jsi::Runtime*, PrototypeCache> _prototypeCache;
+
+protected:
+  /**
+   * Loads all Hybrid Methods that will be initialized in this Prototype.
+   * This will only be called once for the first time the Prototype will be created,
+   * so don't conditionally register methods.
+   */
+  virtual void loadHybridMethods() = 0;
+
+private:
+  /**
+   * Ensures that all Hybrid Methods, Getters and Setters are initialized by calling loadHybridMethods().
+   */
+  inline void ensureInitialized() {
+    if (!_didLoadMethods) [[unlikely]] {
+      // lazy-load all exposed methods
+      loadHybridMethods();
+      _didLoadMethods = true;
+    }
+  }
+
+protected:
+  using RegisterFn = void (*)(Prototype&);
+  /**
+   * Registers the given methods inside the Hybrid Object's prototype.
+   *
+   * For subsequent HybridObjects of the same type, `registerFunc` will not be called again, as the
+   * prototype will already be known and cached.
+   * **Do not conditionally register hybrid methods, getters or setter!**
+   */
+  template <typename Derived>
+  inline void registerHybrids(Derived* thisInstance, RegisterFn registerFunc) {
+    const std::shared_ptr<Prototype>& prototype = _prototypeChain.extendPrototype<Derived>();
+
+    if (!prototype->hasHybrids()) {
+      // The `Prototype` does not have any methods or properties registered yet - so do it now
+      registerFunc(*prototype);
+    }
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/prototype/Prototype.hpp

@@ -0,0 +1,163 @@
+//
+//  PrototypeChain.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 07.08.24.
+//
+
+#pragma once
+
+#include "HybridFunction.hpp"
+#include <memory>
+#include <string>
+#include <typeindex>
+#include <unordered_map>
+
+namespace margelo::nitro {
+
+/**
+ * Represents a Prototype's native C++ type ID.
+ * This can be used to identify a prototype against a C++ instance,
+ * or used as a cache-key.
+ */
+using NativeInstanceId = std::type_index;
+
+/**
+ * Represents a JS `Prototype`'s structure.
+ * Every prototype has a related C++ type ID (`instanceTypeId`).
+ * Prototypes can be sub-classes, in which case they have a `base` prototype.
+ * Each prototype has a list of methods, and properties (getters + setters).
+ *
+ * By using this `Prototype` structure, we can create JS objects that act
+ * as prototypes for `HybridObject`s.
+ *
+ * While a `Prototype` actually holds all the methods, a `HybridObject` only
+ * contains state and memory.
+ * This way the JS VM doesn't need to re-create methods for each `HybridObject`,
+ * they are only initialized once on the shared `Prototype`.
+ */
+struct Prototype final {
+private:
+  std::shared_ptr<Prototype> _base = nullptr;
+  NativeInstanceId _instanceTypeId;
+  std::unordered_map<std::string, HybridFunction> _methods;
+  std::unordered_map<std::string, HybridFunction> _getters;
+  std::unordered_map<std::string, HybridFunction> _setters;
+
+private:
+  Prototype(const NativeInstanceId& typeId, const std::shared_ptr<Prototype>& base) : _instanceTypeId(typeId), _base(base) {}
+
+public:
+  /**
+   * Gets a `Prototype` specification/node for the given native C++ type ID.
+   *
+   * If the given C++ type ID is unknown, a new `Prototype` node is created,
+   * which has to be initialized with methods, getters and setters first.
+   *
+   * If the given C++ type ID is already known in the static `Prototype` tree,
+   * a shared reference to it is returned.
+   */
+  static std::shared_ptr<Prototype> get(const NativeInstanceId& typeId, const std::shared_ptr<Prototype>& base = nullptr) {
+    static std::unordered_map<NativeInstanceId, std::shared_ptr<Prototype>> _prototypesCache;
+
+    const auto& found = _prototypesCache.find(typeId);
+    if (found != _prototypesCache.end()) {
+      // We know this C++ type ID / Prototype - return it!
+      return found->second;
+    } else {
+      // This is the first time we see this C++ type ID - create a new base Prototype for this.
+      auto prototype = std::shared_ptr<Prototype>(new Prototype(typeId, base));
+      _prototypesCache.emplace(typeId, prototype);
+      return prototype;
+    }
+  }
+
+public:
+  template <typename T>
+  inline bool isNativeInstance() const noexcept {
+    return _instanceTypeId == std::type_index(typeid(T));
+  }
+
+  inline bool hasHybrids() const {
+    return !_methods.empty() || !_getters.empty() || !_setters.empty();
+  }
+
+  inline bool hasBase() const noexcept {
+    return _base != nullptr;
+  }
+  inline const std::shared_ptr<Prototype>& getBase() const noexcept {
+    return _base;
+  }
+  inline const NativeInstanceId& getNativeInstanceId() const noexcept {
+    return _instanceTypeId;
+  }
+  inline const std::unordered_map<std::string, HybridFunction>& getMethods() const noexcept {
+    return _methods;
+  }
+  inline const std::unordered_map<std::string, HybridFunction>& getGetters() const noexcept {
+    return _getters;
+  }
+  inline const std::unordered_map<std::string, HybridFunction>& getSetters() const noexcept {
+    return _setters;
+  }
+
+public:
+  /**
+   * Registers the given C++ method as a Hybrid Method that can be called from JS, through the object's Prototype.
+   * Example:
+   * ```cpp
+   * registerHybridMethod("sayHello", &MyObject::sayHello);
+   * ```
+   */
+  template <typename Derived, typename ReturnType, typename... Args>
+  inline void registerHybridMethod(std::string name, ReturnType (Derived::*method)(Args...)) {
+    if (_getters.contains(name) || _setters.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a property with that name already exists!");
+    }
+    if (_methods.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a method with that name already exists!");
+    }
+
+    _methods.emplace(name, HybridFunction::createHybridFunction(name, method, FunctionType::METHOD));
+  }
+
+  /**
+   * Registers the given C++ method as a property getter that can be called from JS, through the object's Prototype.
+   * Example:
+   * ```cpp
+   * registerHybridGetter("foo", &MyObject::getFoo);
+   * ```
+   */
+  template <typename Derived, typename ReturnType>
+  inline void registerHybridGetter(std::string name, ReturnType (Derived::*method)()) {
+    if (_getters.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Property Getter \"" + name + "\" - a getter with that name already exists!");
+    }
+    if (_methods.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Property Getter \"" + name + "\" - a method with that name already exists!");
+    }
+
+    _getters.emplace(name, HybridFunction::createHybridFunction(name, method, FunctionType::GETTER));
+  }
+
+  /**
+   * Registers the given C++ method as a property setter that can be called from JS, through the object's Prototype.
+   * Example:
+   * ```cpp
+   * registerHybridSetter("foo", &MyObject::setFoo);
+   * ```
+   */
+  template <typename Derived, typename ValueType>
+  inline void registerHybridSetter(std::string name, void (Derived::*method)(ValueType)) {
+    if (_setters.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Property Setter \"" + name + "\" - a setter with that name already exists!");
+    }
+    if (_methods.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Property Setter \"" + name + "\" - a method with that name already exists!");
+    }
+
+    _setters.emplace(name, HybridFunction::createHybridFunction(name, method, FunctionType::SETTER));
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/prototype/PrototypeChain.hpp

@@ -0,0 +1,78 @@
+//
+//  PrototypeChain.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 07.08.24.
+//
+
+#pragma once
+
+#include "Prototype.hpp"
+
+namespace margelo::nitro {
+
+/**
+ * Represents a mutable chain of prototypes.
+ * Callers can use this class to incrementally add sub-classes to prototypes and build
+ * prototype chains/trees using C++ type information.
+ *
+ * The template methods can be used to find a specific C++ instance in the prototype tree,
+ * or create a new sub-class if it cannot be found.
+ */
+class PrototypeChain final {
+private:
+  std::shared_ptr<Prototype> _prototype;
+
+public:
+  PrototypeChain() {}
+
+public:
+  /**
+   * Gets the current `Prototype` as a whole.
+   * This does not do any modifications to the Prototype tree.
+   */
+  inline const std::shared_ptr<Prototype>& getPrototype() const {
+    return _prototype;
+  }
+
+public:
+  /**
+   * Extends the Prototype with the given type `Derived`.
+   * If the Prototype already extended `Derived`, this returns the current state.
+   */
+  template <typename Derived>
+  inline const std::shared_ptr<Prototype>& extendPrototype() {
+    if (_prototype == nullptr) {
+      _prototype = Prototype::get(typeid(Derived));
+    }
+
+    return getOrExtendPrototype<Derived>(_prototype);
+  }
+
+private:
+  /**
+   * Perform a bottom-down search of the given `Derived` C++ type info.
+   * If the current prototype tree does not have a Prototype that represents the
+   * C++ type `Derived`, it will extend it at the bottom and shift the `Prototype` tree
+   * up by one.
+   */
+  template <typename Derived>
+  inline const std::shared_ptr<Prototype>& getOrExtendPrototype(const std::shared_ptr<Prototype>& node) {
+    if (node->isNativeInstance<Derived>()) {
+      // If the Prototype represents the caller type (`Derived`), we work with this Prototype.
+      return node;
+    } else {
+      if (node->hasBase()) {
+        // We didn't find a match in this prototype, let's recursively try it's parent!
+        return getOrExtendPrototype<Derived>(node->getBase());
+      } else {
+        // We didn't find `Derived` and we don't have a base- add a child and shift the tree by one.
+        auto newBase = _prototype;
+        _prototype = Prototype::get(typeid(Derived), newBase);
+        return _prototype;
+      }
+    }
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/threading/Dispatcher.cpp

@@ -1,5 +1,5 @@
 #include "Dispatcher.hpp"
-#include "GetRuntimeID.hpp"
+#include "JSIHelpers.hpp"
 #include "NitroLogger.hpp"
 
 namespace margelo::nitro {

package/cpp/turbomodule/NativeNitroModules.cpp

@@ -9,7 +9,6 @@
 #include "CallInvokerDispatcher.hpp"
 #include "Dispatcher.hpp"
 #include "HybridObjectRegistry.hpp"
-#include "TestHybridObject.hpp"
 
 namespace facebook::react {
 
@@ -59,12 +58,12 @@ void NativeNitroModules::install(jsi::Runtime& runtime) {
   Dispatcher::installRuntimeGlobalDispatcher(runtime, dispatcher);
 }
 
-jsi::Object NativeNitroModules::createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName,
-                                                   const std::optional<jsi::Object>& args) {
+jsi::Value NativeNitroModules::createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName,
+                                                  const std::optional<jsi::Object>& args) {
   auto name = hybridObjectName.utf8(runtime);
   // TODO: Pass args? Do we need that?
   auto hybridObject = HybridObjectRegistry::createHybridObject(name.c_str());
-  return jsi::Object::createFromHostObject(runtime, hybridObject);
+  return hybridObject->toObject(runtime);
 }
 
 } // namespace facebook::react

package/cpp/turbomodule/NativeNitroModules.hpp

@@ -23,7 +23,7 @@ public:
   jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName) override;
 
   void install(jsi::Runtime& runtime);
-  jsi::Object createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName, const std::optional<jsi::Object>& args);
+  jsi::Value createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName, const std::optional<jsi::Object>& args);
 
 public:
   constexpr static auto kModuleName = "NitroModulesCxx";

package/cpp/utils/BorrowingReference+Owning.hpp

@@ -22,7 +22,7 @@ BorrowingReference<T>::BorrowingReference(const OwningReference<T>& ref) {
 }
 
 template <typename T>
-OwningReference<T> BorrowingReference<T>::lock() {
+OwningReference<T> BorrowingReference<T>::lock() const {
   std::unique_lock lock(*_mutex);
 
   if (*_isDeleted) {

package/cpp/utils/BorrowingReference.hpp

@@ -82,7 +82,7 @@ public:
    Try to lock the borrowing reference to an owning reference, or `nullptr` if it has already been deleted.
    */
   [[nodiscard]]
-  OwningReference<T> lock();
+  OwningReference<T> lock() const;
 
 public:
   friend class OwningReference<T>;