react-native-nitro-modules 0.9.2 → 0.10.0

package/README.md

@@ -154,8 +154,8 @@ The following C++ / JS types are supported out of the box:
   <tr>
     <td><code>A | B | C | ...</code></td>
     <td><code>std::variant&lt;A, B, C, ...&gt;</code></td>
-    <td><code>Variant_A_B_C</code> 🟡  (<a href="https://github.com/mrousavy/nitro/issues/39">#39</a>)</td>
-    <td>❌</td>
+    <td><code>Variant_A_B_C</code></td>
+    <td><code>Variant_A_B_C</code></td>
   </tr>
   <tr>
     <td><code>Record&lt;string, T&gt;</code></td>
@@ -190,7 +190,7 @@ The following C++ / JS types are supported out of the box:
   <tr>
     <td><code>{ ... }</code></td>
     <td><code>std::shared_ptr&lt;<a href="./cpp/core/AnyMap.hpp">AnyMap</a>&gt;</code></td>
-    <td><code><a href="./ios/core/AnyMapHolder.swift">AnyMapHolder</a></code> 🟡  (<a href="https://github.com/mrousavy/nitro/issues/57">#57</a>)</td>
+    <td><code><a href="./ios/core/AnyMapHolder.swift">AnyMapHolder</a></code></td>
     <td><code><a href="./android/src/main/java/com/margelo/nitro/core/AnyMap.kt">AnyMap</a></code></td>
   </tr>
   <tr>

package/cpp/core/BoxedHybridObject.cpp

@@ -0,0 +1,29 @@
+//
+//  BoxedHybridObject.cpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 17.09.24.
+//
+
+#include "BoxedHybridObject.hpp"
+
+namespace margelo::nitro {
+
+std::vector<jsi::PropNameID> BoxedHybridObject::getPropertyNames(facebook::jsi::Runtime& runtime) {
+  return jsi::PropNameID::names(runtime, "unbox");
+}
+
+jsi::Value BoxedHybridObject::get(jsi::Runtime& runtime, const jsi::PropNameID& propName) {
+  std::string name = propName.utf8(runtime);
+
+  if (name == "unbox") {
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "unbox"), 0,
+        [hybridObject = _hybridObject](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args,
+                                       size_t count) -> jsi::Value { return hybridObject->toObject(runtime); });
+  }
+
+  return jsi::Value::undefined();
+}
+
+} // namespace margelo::nitro

package/cpp/core/BoxedHybridObject.hpp

@@ -0,0 +1,36 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+#include "HybridObject.hpp"
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents a `HybridObject` that has been boxed into a `jsi::HostObject`.
+ *
+ * While `HybridObject`s are runtime agnostic, some threading/worklet libraries do not support copying over objects
+ * with `jsi::NativeState` and a prototype chain (which is what a `HybridObject` is), so Nitro offers support for
+ * boxing those `HybridObject`s into a type that those libraries support - which is a `jsi::HostObject`.
+ *
+ * Simply call `unbox()` on this `jsi::HostObject` from the new Runtime/context to get the `HybridObject` again.
+ */
+class BoxedHybridObject : public jsi::HostObject {
+public:
+  explicit BoxedHybridObject(const std::shared_ptr<HybridObject>& hybridObject) : _hybridObject(hybridObject) {}
+
+public:
+  jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName) override;
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override;
+
+private:
+  std::shared_ptr<HybridObject> _hybridObject;
+};
+
+} // namespace margelo::nitro

package/cpp/templates/FutureType.hpp

@@ -1,5 +1,5 @@
 //
-//  BorrowingReference.hpp
+//  FutureType.hpp
 //  NitroModules
 //
 //  Created by Marc Rousavy on 21.06.24.

package/cpp/templates/TypeIndex.hpp

@@ -0,0 +1,29 @@
+//
+//  TypeIndex.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+#include <tuple>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+// Gets the index of `T` in a `std::tuple<...>`.
+template <typename T, typename... Ts>
+struct type_index;
+
+template <typename T, typename First, typename... Rest>
+struct type_index<T, First, Rest...> {
+  static constexpr size_t value = std::is_same_v<T, First> ? 0 : 1 + type_index<T, Rest...>::value;
+};
+
+template <typename T>
+struct type_index<T> {
+  static constexpr size_t value = -1; // Type not found
+};
+
+} // namespace margelo::nitro

package/cpp/turbomodule/NativeNitroModules.cpp

@@ -6,6 +6,7 @@
 //
 
 #include "NativeNitroModules.hpp"
+#include "BoxedHybridObject.hpp"
 #include "CallInvokerDispatcher.hpp"
 #include "Dispatcher.hpp"
 #include "HybridObjectRegistry.hpp"
@@ -18,8 +19,6 @@ using namespace margelo::nitro;
 NativeNitroModules::NativeNitroModules(std::shared_ptr<CallInvoker> jsInvoker)
     : TurboModule(kModuleName, jsInvoker), _callInvoker(jsInvoker) {}
 
-NativeNitroModules::~NativeNitroModules() {}
-
 jsi::Value NativeNitroModules::get(jsi::Runtime& runtime, const jsi::PropNameID& propName) {
   std::string name = propName.utf8(runtime);
 
@@ -33,21 +32,16 @@ jsi::Value NativeNitroModules::get(jsi::Runtime& runtime, const jsi::PropNameID&
   }
   if (name == "createHybridObject") {
     return jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forUtf8(runtime, "createHybridObject"), 2,
+        runtime, jsi::PropNameID::forUtf8(runtime, "createHybridObject"), 1,
         [this](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
 #ifdef NITRO_DEBUG
-          if (count != 1 && count != 2) [[unlikely]] {
-            throw jsi::JSError(runtime, "NitroModules.createHybridObject(..) expects 1 or 2 arguments, but " + std::to_string(count) +
-                                            " were supplied!");
+          if (count != 1) [[unlikely]] {
+            throw jsi::JSError(runtime,
+                               "NitroModules.createHybridObject(..) expects 1 argument, but " + std::to_string(count) + " were supplied!");
           }
 #endif
           jsi::String objectName = args[0].asString(runtime);
-          std::optional<jsi::Object> optionalArgs = std::nullopt;
-          if (count > 1) {
-            optionalArgs = args[1].asObject(runtime);
-          }
-
-          return createHybridObject(runtime, objectName, optionalArgs);
+          return createHybridObject(runtime, objectName);
         });
   }
   if (name == "hasHybridObject") {
@@ -87,6 +81,29 @@ jsi::Value NativeNitroModules::get(jsi::Runtime& runtime, const jsi::PropNameID&
           return jsi::Value::undefined();
         });
   }
+  if (name == "box") {
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "box"), 1,
+        [](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
+          jsi::Object object = args[0].asObject(runtime);
+#ifdef NITRO_DEBUG
+          if (!object.hasNativeState(runtime)) {
+            std::string stringified = args[0].toString(runtime).utf8(runtime);
+            throw std::runtime_error("Cannot box object " + stringified + " - it does not have a NativeState!");
+          }
+#endif
+
+          std::shared_ptr<jsi::NativeState> nativeState = object.getNativeState(runtime);
+          std::shared_ptr<HybridObject> maybeHybridObject = std::dynamic_pointer_cast<HybridObject>(nativeState);
+          if (maybeHybridObject == nullptr) {
+            std::string stringified = args[0].toString(runtime).utf8(runtime);
+            throw std::runtime_error("Cannot box object " + stringified + " - it has a NativeState, but it's not a HybridObject!");
+          }
+
+          auto boxed = std::make_shared<BoxedHybridObject>(maybeHybridObject);
+          return jsi::Object::createFromHostObject(runtime, boxed);
+        });
+  }
   if (name == "buildType") {
 #ifdef NITRO_DEBUG
     return jsi::String::createFromAscii(runtime, "debug");
@@ -105,11 +122,9 @@ void NativeNitroModules::install(jsi::Runtime& runtime) {
   Dispatcher::installRuntimeGlobalDispatcher(runtime, dispatcher);
 }
 
-jsi::Value NativeNitroModules::createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName,
-                                                  const std::optional<jsi::Object>&) {
+jsi::Value NativeNitroModules::createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName) {
   auto name = hybridObjectName.utf8(runtime);
-  // TODO: Pass args? Do we need that?
-  auto hybridObject = HybridObjectRegistry::createHybridObject(name.c_str());
+  auto hybridObject = HybridObjectRegistry::createHybridObject(name);
   return hybridObject->toObject(runtime);
 }
 

package/cpp/turbomodule/NativeNitroModules.hpp

@@ -16,8 +16,7 @@ using namespace facebook;
 // The base C++-based TurboModule. This is the entry point where all nitro modules get initialized.
 class NativeNitroModules : public TurboModule {
 public:
-  NativeNitroModules(std::shared_ptr<CallInvoker> jsInvoker);
-  ~NativeNitroModules();
+  explicit NativeNitroModules(std::shared_ptr<CallInvoker> jsInvoker);
 
 public:
   jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName) override;
@@ -25,7 +24,7 @@ public:
   // Setup
   void install(jsi::Runtime& runtime);
   // Hybrid Objects stuff
-  jsi::Value createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName, const std::optional<jsi::Object>& args);
+  jsi::Value createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName);
   jsi::Value hasHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName);
   jsi::Value getAllHybridObjectNames(jsi::Runtime& runtime);
 

package/cpp/utils/NitroDefines.hpp

@@ -15,6 +15,11 @@
 #ifdef NDEBUG
 #undef NITRO_DEBUG
 #endif
+#ifdef ANDROID
+#ifndef NDEBUG
+#define NITRO_DEBUG
+#endif
+#endif
 
 // Helper to find out if a C++ compiler attribute is available
 #ifdef __has_attribute

package/ios/core/AnyMapHolder.hpp

@@ -88,4 +88,12 @@ inline std::vector<std::string> getAnyObjectKeys(const AnyObject& object) {
   return keys;
 }
 
+inline AnyValue getAnyObjectValue(const AnyObject& object, const std::string& key) {
+  auto item = object.find(key);
+  if (item == object.end()) {
+    throw std::runtime_error("Couldn't find " + key + " in AnyObject!");
+  }
+  return item->second;
+}
+
 } // namespace margelo::nitro

package/ios/core/AnyMapHolder.swift

@@ -11,12 +11,13 @@ import Foundation
  * Represents any value representable by the `AnyMap`.
  * Note: Arrays are currently not implemented due to a Swift compiler bug https://github.com/swiftlang/swift/issues/75994
  */
-public enum AnyValue {
+public indirect enum AnyValue {
   case null
   case number(Double)
   case bool(Bool)
   case bigint(Int64)
   case string(String)
+  case array(Array<AnyValue>)
   case object(Dictionary<String, AnyValue>)
 
   static func create(_ value: margelo.nitro.AnyValue) -> AnyValue {
@@ -30,6 +31,8 @@ public enum AnyValue {
       return .bigint(margelo.nitro.get_AnyValue_bigint(value))
     } else if margelo.nitro.is_AnyValue_string(value) {
       return .string(margelo.nitro.get_AnyValue_string(value).toSwift())
+    } else if margelo.nitro.is_AnyValue_AnyArray(value) {
+      return .array(margelo.nitro.get_AnyValue_AnyArray(value).toSwift())
     } else if margelo.nitro.is_AnyValue_AnyObject(value) {
       return .object(margelo.nitro.get_AnyValue_AnyObject(value).toSwift())
     } else {
@@ -42,22 +45,18 @@ public enum AnyValue {
  * Represents an `AnyMap` that can be passed to Swift.
  */
 public class AnyMapHolder {
-  let _cppPart: margelo.nitro.TSharedMap
-  
-  public var cppPart: margelo.nitro.TSharedMap {
-    return _cppPart
-  }
+  public let cppPart: margelo.nitro.TSharedMap
 
   public init() {
-    _cppPart = margelo.nitro.AnyMap.make()
+    cppPart = margelo.nitro.AnyMap.make()
   }
 
   public init(withPreallocatedSize size: Int) {
-    _cppPart = margelo.nitro.AnyMap.make(size)
+    cppPart = margelo.nitro.AnyMap.make(size)
   }
   
-  public init(withCppPart cppPart: margelo.nitro.TSharedMap) {
-    _cppPart = cppPart
+  public init(withCppPart otherCppPart: margelo.nitro.TSharedMap) {
+    cppPart = otherCppPart
   }
 
   // pragma MARK: Common Operations
@@ -66,21 +65,21 @@ public class AnyMapHolder {
    * Returns whether the given key exists in the map.
    */
   public func contains(key: String) -> Bool {
-    return _cppPart.pointee.contains(std.string(key))
+    return cppPart.pointee.contains(std.string(key))
   }
 
   /**
    * Removes the given key from the map.
    */
   public func remove(key: String) {
-    _cppPart.pointee.remove(std.string(key))
+    cppPart.pointee.remove(std.string(key))
   }
 
   /**
    * Removes all keys in this map.
    */
   public func clear() {
-    _cppPart.pointee.clear()
+    cppPart.pointee.clear()
   }
 
   // pragma MARK: Getters
@@ -91,44 +90,54 @@ public class AnyMapHolder {
    * this function throws.
    */
   public func getDouble(key: String) -> Double {
-    return _cppPart.pointee.getDouble(std.string(key))
+    return cppPart.pointee.getDouble(std.string(key))
   }
 
   /**
-   * Gets the double value at the given key.
+   * Gets the boolean value at the given key.
    * If no value exists at the given key, or if it is not a double,
    * this function throws.
    */
   public func getBoolean(key: String) -> Bool {
-    return _cppPart.pointee.getBoolean(std.string(key))
+    return cppPart.pointee.getBoolean(std.string(key))
   }
 
   /**
-   * Gets the double value at the given key.
+   * Gets the bigint value at the given key.
    * If no value exists at the given key, or if it is not a double,
    * this function throws.
    */
   public func getBigInt(key: String) -> Int64 {
-    return _cppPart.pointee.getBigInt(std.string(key))
+    return cppPart.pointee.getBigInt(std.string(key))
   }
 
   /**
-   * Gets the double value at the given key.
+   * Gets the string value at the given key.
    * If no value exists at the given key, or if it is not a double,
    * this function throws.
    */
   public func getString(key: String) -> String {
-    let value = _cppPart.pointee.getString(std.string(key))
+    let value = cppPart.pointee.getString(std.string(key))
     return String(value)
   }
-
+  
   /**
-   * Gets the double value at the given key.
+   * Gets the array value at the given key.
+   * If no value exists at the given key, or if it is not a double,
+   * this function throws.
+   */
+  public func getArray(key: String) -> [AnyValue] {
+    let value = cppPart.pointee.getArray(std.string(key))
+    return value.toSwift()
+  }
+  
+  /**
+   * Gets the object value at the given key.
    * If no value exists at the given key, or if it is not a double,
    * this function throws.
    */
   public func getObject(key: String) -> Dictionary<String, AnyValue> {
-    let value = _cppPart.pointee.getObject(std.string(key))
+    let value = cppPart.pointee.getObject(std.string(key))
     return value.toSwift()
   }
 
@@ -138,42 +147,49 @@ public class AnyMapHolder {
    * Set the given key to `null`.
    */
   public func setNull(key: String) {
-    _cppPart.pointee.setNull(std.string(key))
+    cppPart.pointee.setNull(std.string(key))
   }
 
   /**
    * Set the given key to the given double value.
    */
   public func setDouble(key: String, value: Double) {
-    _cppPart.pointee.setDouble(std.string(key), value)
+    cppPart.pointee.setDouble(std.string(key), value)
   }
 
   /**
    * Set the given key to the given boolean value.
    */
   public func setBoolean(key: String, value: Bool) {
-    _cppPart.pointee.setBoolean(std.string(key), value)
+    cppPart.pointee.setBoolean(std.string(key), value)
   }
 
   /**
    * Set the given key to the given bigint value.
    */
   public func setBigInt(key: String, value: Int64) {
-    _cppPart.pointee.setBigInt(std.string(key), value)
+    cppPart.pointee.setBigInt(std.string(key), value)
   }
 
   /**
    * Set the given key to the given string value.
    */
   public func setString(key: String, value: String) {
-    _cppPart.pointee.setString(std.string(key), std.string(value))
+    cppPart.pointee.setString(std.string(key), std.string(value))
   }
-
+  
+  /**
+   * Set the given key to the given array value.
+   */
+  public func setArray(key: String, value: [AnyValue]) {
+    cppPart.pointee.setArray(std.string(key), margelo.nitro.AnyArray.create(value))
+  }
+  
   /**
    * Set the given key to the given object value.
    */
   public func setObject(key: String, value: Dictionary<String, AnyValue>) {
-    _cppPart.pointee.setObject(std.string(key), margelo.nitro.AnyObject.create(value))
+    cppPart.pointee.setObject(std.string(key), margelo.nitro.AnyObject.create(value))
   }
 
   // pragma MARK: Is Getters
@@ -182,42 +198,49 @@ public class AnyMapHolder {
    * Gets whether the given `key` is holding a null value, or not.
    */
   public func isNull(key: String) -> Bool {
-    return _cppPart.pointee.isNull(std.string(key))
+    return cppPart.pointee.isNull(std.string(key))
   }
 
   /**
    * Gets whether the given `key` is holding a double value, or not.
    */
   public func isDouble(key: String) -> Bool {
-    return _cppPart.pointee.isDouble(std.string(key))
+    return cppPart.pointee.isDouble(std.string(key))
   }
 
   /**
    * Gets whether the given `key` is holding a boolean value, or not.
    */
   public func isBool(key: String) -> Bool {
-    return _cppPart.pointee.isBoolean(std.string(key))
+    return cppPart.pointee.isBoolean(std.string(key))
   }
 
   /**
    * Gets whether the given `key` is holding a bigint value, or not.
    */
   public func isBigInt(key: String) -> Bool {
-    return _cppPart.pointee.isBigInt(std.string(key))
+    return cppPart.pointee.isBigInt(std.string(key))
   }
 
   /**
    * Gets whether the given `key` is holding a string value, or not.
    */
   public func isString(key: String) -> Bool {
-    return _cppPart.pointee.isString(std.string(key))
+    return cppPart.pointee.isString(std.string(key))
   }
-
+  
   /**
-   * Gets whether the given `key` is holding a object value, or not.
+   * Gets whether the given `key` is holding an array value, or not.
+   */
+  public func isArray(key: String) -> Bool {
+    return cppPart.pointee.isArray(std.string(key))
+  }
+  
+  /**
+   * Gets whether the given `key` is holding an object value, or not.
    */
   public func isObject(key: String) -> Bool {
-    return _cppPart.pointee.isObject(std.string(key))
+    return cppPart.pointee.isObject(std.string(key))
   }
 }
 
@@ -236,6 +259,8 @@ extension margelo.nitro.AnyValue {
       return create(bigint)
     case .string(let string):
       return create(string)
+    case .array(let array):
+      return create(array)
     case .object(let object):
       return create(object)
     }
@@ -309,7 +334,8 @@ extension margelo.nitro.AnyObject {
     let keys = margelo.nitro.getAnyObjectKeys(self)
     var dictionary = Dictionary<String, AnyValue>(minimumCapacity: keys.size())
     for key in keys {
-
+      let value = margelo.nitro.getAnyObjectValue(self, key)
+      dictionary[String(key)] = AnyValue.create(value)
     }
     return dictionary
   }

package/lib/NativeNitroModules.d.ts

@@ -7,7 +7,6 @@ export interface Spec extends TurboModule {
     getAllHybridObjectNames(): string[];
     hasNativeState(obj: UnsafeObject): boolean;
     removeNativeState(obj: UnsafeObject): void;
-    buildType: 'debug' | 'release';
 }
 export declare function getNativeNitroModules(): Spec;
 declare global {

package/lib/NitroModules.d.ts

@@ -1,4 +1,15 @@
 import type { HybridObject } from './HybridObject';
+/**
+ * Represents a boxed {@linkcode HybridObject} that can later be unboxed again.
+ * This is implemented as a `jsi::HostObject`.
+ */
+export interface BoxedHybridObject<T extends HybridObject> {
+    /**
+     * Unboxes the {@linkcode HybridObject}.
+     * This can be called from a different Runtime than the one it was boxed in.
+     */
+    unbox(): T;
+}
 /**
  * A lazy proxy for initializing Nitro Modules HybridObjects.
  */
@@ -45,4 +56,28 @@ export declare const NitroModules: {
      * preprocessor flag.
      */
     readonly buildType: "debug" | "release";
+    /**
+     * Boxes the given {@linkcode hybridObject} into a {@linkcode BoxedHybridObject<T>}, which can
+     * later be unboxed in a separate Runtime.
+     *
+     * While Nitro is runtime-agnostic and all `HybridObject`s can be used from a any Runtime,
+     * some threading/worklet libraries (like [react-native-worklets-core](https://github.com/margelo/react-native-worklets-core))
+     * do not yet support copying over `HybridObject`s as they use newer JSI APIs like `jsi::NativeState`.
+     *
+     * While those APIs are not yet available, you can still use every Nitro Hybrid Object in a separate
+     * Runtime/Worklet context by just boxing it yourself:
+     *
+     * @example
+     * ```ts
+     * const something = NitroModules.createHybridObject<Something>('Something')
+     * const boxed = NitroModules.box(something)
+     * const context = Worklets.createContext('DummyContext')
+     * context.runAsync(() => {
+     *   'worklet'
+     *   const unboxed = boxed.unbox()
+     *   console.log(unboxed.name) // --> "Something"
+     * })
+     * ```
+     */
+    box<T extends HybridObject>(hybridObject: T): BoxedHybridObject<T>;
 };

package/lib/NitroModules.js

@@ -64,4 +64,31 @@ export const NitroModules = {
         const nitro = getNativeNitroModules();
         return nitro.buildType;
     },
+    /**
+     * Boxes the given {@linkcode hybridObject} into a {@linkcode BoxedHybridObject<T>}, which can
+     * later be unboxed in a separate Runtime.
+     *
+     * While Nitro is runtime-agnostic and all `HybridObject`s can be used from a any Runtime,
+     * some threading/worklet libraries (like [react-native-worklets-core](https://github.com/margelo/react-native-worklets-core))
+     * do not yet support copying over `HybridObject`s as they use newer JSI APIs like `jsi::NativeState`.
+     *
+     * While those APIs are not yet available, you can still use every Nitro Hybrid Object in a separate
+     * Runtime/Worklet context by just boxing it yourself:
+     *
+     * @example
+     * ```ts
+     * const something = NitroModules.createHybridObject<Something>('Something')
+     * const boxed = NitroModules.box(something)
+     * const context = Worklets.createContext('DummyContext')
+     * context.runAsync(() => {
+     *   'worklet'
+     *   const unboxed = boxed.unbox()
+     *   console.log(unboxed.name) // --> "Something"
+     * })
+     * ```
+     */
+    box(hybridObject) {
+        const nitro = getNativeNitroModules();
+        return nitro.box(hybridObject);
+    },
 };

package/lib/NitroModulesTurboModule.d.ts

@@ -2,12 +2,13 @@ import type { TurboModule } from 'react-native';
 import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
 export interface NativeNitroSpec extends TurboModule {
     install(): void;
-    createHybridObject(name: string, args?: UnsafeObject): UnsafeObject;
+    createHybridObject(name: string): UnsafeObject;
     hasHybridObject(name: string): boolean;
     getAllHybridObjectNames(): string[];
     hasNativeState(obj: UnsafeObject): boolean;
     removeNativeState(obj: UnsafeObject): void;
     buildType: 'debug' | 'release';
+    box(obj: UnsafeObject): UnsafeObject;
 }
 export declare function getNativeNitroModules(): NativeNitroSpec;
 declare global {