react-native-litert-lm 0.2.1 → 0.3.0

package/lib/specs/LiteRTLM.nitro.d.ts

@@ -88,6 +88,20 @@ export interface GenerationStats {
     /** Tokens per second */
     tokensPerSecond: number;
 }
+/**
+ * Real memory usage statistics from the native runtime.
+ * Measured from OS-level APIs, not estimated.
+ */
+export interface MemoryUsage {
+    /** Native heap allocated bytes (Debug.getNativeHeapAllocatedSize on Android, malloc_size on iOS) */
+    nativeHeapBytes: number;
+    /** Total process resident set size (RSS) in bytes */
+    residentBytes: number;
+    /** Available system memory in bytes */
+    availableMemoryBytes: number;
+    /** Whether the system considers memory low */
+    isLowMemory: boolean;
+}
 /**
  * LiteRT-LM: High-performance LLM inference engine.
  * Supports Gemma 3n, Phi-4, Qwen, and other .litertlm models.
@@ -175,6 +189,11 @@ export interface LiteRTLM extends HybridObject<{
      * Get the last generation statistics.
      */
     getStats(): GenerationStats;
+    /**
+     * Get real memory usage from the native runtime.
+     * Uses OS-level APIs to report actual memory consumption.
+     */
+    getMemoryUsage(): MemoryUsage;
     /**
      * Release all native resources.
      * Call this when done with the LLM instance.

package/nitrogen/generated/android/LiteRTLMOnLoad.cpp

@@ -23,26 +23,36 @@
 namespace margelo::nitro::litertlm {
 
 int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::litertlm::registerAllNatives();
+  });
+}
+
+struct JHybridLiteRTLMSpecImpl: public jni::JavaClass<JHybridLiteRTLMSpecImpl, JHybridLiteRTLMSpec::JavaPart> {
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/HybridLiteRTLM;";
+  static std::shared_ptr<JHybridLiteRTLMSpec> create() {
+    static auto constructorFn = javaClassStatic()->getConstructor<JHybridLiteRTLMSpecImpl::javaobject()>();
+    jni::local_ref<JHybridLiteRTLMSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridLiteRTLMSpec();
+  }
+};
+
+void registerAllNatives() {
   using namespace margelo::nitro;
   using namespace margelo::nitro::litertlm;
-  using namespace facebook;
-
-  return facebook::jni::initialize(vm, [] {
-    // Register native JNI methods
-    margelo::nitro::litertlm::JHybridLiteRTLMSpec::registerNatives();
-    margelo::nitro::litertlm::JFunc_void_double_cxx::registerNatives();
-    margelo::nitro::litertlm::JFunc_void_std__string_bool_cxx::registerNatives();
-
-    // Register Nitro Hybrid Objects
-    HybridObjectRegistry::registerHybridObjectConstructor(
-      "LiteRTLM",
-      []() -> std::shared_ptr<HybridObject> {
-        static DefaultConstructableObject<JHybridLiteRTLMSpec::javaobject> object("com/margelo/nitro/dev/litert/litertlm/HybridLiteRTLM");
-        auto instance = object.create();
-        return instance->cthis()->shared();
-      }
-    );
-  });
+
+  // Register native JNI methods
+  margelo::nitro::litertlm::JHybridLiteRTLMSpec::CxxPart::registerNatives();
+  margelo::nitro::litertlm::JFunc_void_double_cxx::registerNatives();
+  margelo::nitro::litertlm::JFunc_void_std__string_bool_cxx::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "LiteRTLM",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridLiteRTLMSpecImpl::create();
+    }
+  );
 }
 
 } // namespace margelo::nitro::litertlm

package/nitrogen/generated/android/LiteRTLMOnLoad.hpp

@@ -6,20 +6,29 @@
 ///
 
 #include <jni.h>
+#include <functional>
 #include <NitroModules/NitroDefines.hpp>
 
 namespace margelo::nitro::litertlm {
 
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
   /**
-   * Initializes the native (C++) part of LiteRTLM, and autolinks all Hybrid Objects.
-   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`).
+   * Register the native (C++) part of LiteRTLM, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
    * Example:
    * ```cpp (cpp-adapter.cpp)
    * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-   *   return margelo::nitro::litertlm::initialize(vm);
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all LiteRTLM HybridObjects
+   *     margelo::nitro::litertlm::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
    * }
    * ```
    */
-  int initialize(JavaVM* vm);
+  void registerAllNatives();
 
 } // namespace margelo::nitro::litertlm

package/nitrogen/generated/android/c++/JHybridLiteRTLMSpec.cpp

@@ -13,6 +13,8 @@ namespace margelo::nitro::litertlm { struct Message; }
 namespace margelo::nitro::litertlm { enum class Role; }
 // Forward declaration of `GenerationStats` to properly resolve imports.
 namespace margelo::nitro::litertlm { struct GenerationStats; }
+// Forward declaration of `MemoryUsage` to properly resolve imports.
+namespace margelo::nitro::litertlm { struct MemoryUsage; }
 // Forward declaration of `LLMConfig` to properly resolve imports.
 namespace margelo::nitro::litertlm { struct LLMConfig; }
 // Forward declaration of `Backend` to properly resolve imports.
@@ -29,6 +31,8 @@ namespace margelo::nitro::litertlm { enum class Backend; }
 #include "JRole.hpp"
 #include "GenerationStats.hpp"
 #include "JGenerationStats.hpp"
+#include "MemoryUsage.hpp"
+#include "JMemoryUsage.hpp"
 #include "LLMConfig.hpp"
 #include <optional>
 #include "JLLMConfig.hpp"
@@ -41,37 +45,31 @@ namespace margelo::nitro::litertlm { enum class Backend; }
 
 namespace margelo::nitro::litertlm {
 
-  jni::local_ref<JHybridLiteRTLMSpec::jhybriddata> JHybridLiteRTLMSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
-  }
-
-  void JHybridLiteRTLMSpec::registerNatives() {
-    registerHybrid({
-      makeNativeMethod("initHybrid", JHybridLiteRTLMSpec::initHybrid),
-    });
+  std::shared_ptr<JHybridLiteRTLMSpec> JHybridLiteRTLMSpec::JavaPart::getJHybridLiteRTLMSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridLiteRTLMSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridLiteRTLMSpec!");
+    }
+    return castHybridObject;
   }
 
-  size_t JHybridLiteRTLMSpec::getExternalMemorySize() noexcept {
-    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
-    return method(_javaPart);
+  jni::local_ref<JHybridLiteRTLMSpec::CxxPart::jhybriddata> JHybridLiteRTLMSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
   }
 
-  bool JHybridLiteRTLMSpec::equals(const std::shared_ptr<HybridObject>& other) {
-    if (auto otherCast = std::dynamic_pointer_cast<JHybridLiteRTLMSpec>(other)) {
-      return _javaPart == otherCast->_javaPart;
+  std::shared_ptr<JHybridObject> JHybridLiteRTLMSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridLiteRTLMSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridLiteRTLMSpec::JavaPart!");
     }
-    return false;
+    return std::make_shared<JHybridLiteRTLMSpec>(castJavaPart);
   }
 
-  void JHybridLiteRTLMSpec::dispose() noexcept {
-    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
-    method(_javaPart);
-  }
-
-  std::string JHybridLiteRTLMSpec::toString() {
-    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
-    auto javaString = method(_javaPart);
-    return javaString->toStdString();
+  void JHybridLiteRTLMSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridLiteRTLMSpec::CxxPart::initHybrid),
+    });
   }
 
   // Properties
@@ -79,7 +77,7 @@ namespace margelo::nitro::litertlm {
 
   // Methods
   std::shared_ptr<Promise<void>> JHybridLiteRTLMSpec::loadModel(const std::string& modelPath, const std::optional<LLMConfig>& config) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* modelPath */, jni::alias_ref<JLLMConfig> /* config */)>("loadModel");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* modelPath */, jni::alias_ref<JLLMConfig> /* config */)>("loadModel");
     auto __result = method(_javaPart, jni::make_jstring(modelPath), config.has_value() ? JLLMConfig::fromCpp(config.value()) : nullptr);
     return [&]() {
       auto __promise = Promise<void>::create();
@@ -94,7 +92,7 @@ namespace margelo::nitro::litertlm {
     }();
   }
   std::shared_ptr<Promise<std::string>> JHybridLiteRTLMSpec::sendMessage(const std::string& message) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */)>("sendMessage");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */)>("sendMessage");
     auto __result = method(_javaPart, jni::make_jstring(message));
     return [&]() {
       auto __promise = Promise<std::string>::create();
@@ -110,7 +108,7 @@ namespace margelo::nitro::litertlm {
     }();
   }
   std::shared_ptr<Promise<std::string>> JHybridLiteRTLMSpec::sendMessageWithImage(const std::string& message, const std::string& imagePath) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* imagePath */)>("sendMessageWithImage");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* imagePath */)>("sendMessageWithImage");
     auto __result = method(_javaPart, jni::make_jstring(message), jni::make_jstring(imagePath));
     return [&]() {
       auto __promise = Promise<std::string>::create();
@@ -126,7 +124,7 @@ namespace margelo::nitro::litertlm {
     }();
   }
   std::shared_ptr<Promise<std::string>> JHybridLiteRTLMSpec::downloadModel(const std::string& url, const std::string& fileName, const std::optional<std::function<void(double /* progress */)>>& onProgress) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<jni::JString> /* fileName */, jni::alias_ref<JFunc_void_double::javaobject> /* onProgress */)>("downloadModel_cxx");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<jni::JString> /* fileName */, jni::alias_ref<JFunc_void_double::javaobject> /* onProgress */)>("downloadModel_cxx");
     auto __result = method(_javaPart, jni::make_jstring(url), jni::make_jstring(fileName), onProgress.has_value() ? JFunc_void_double_cxx::fromCpp(onProgress.value()) : nullptr);
     return [&]() {
       auto __promise = Promise<std::string>::create();
@@ -142,7 +140,7 @@ namespace margelo::nitro::litertlm {
     }();
   }
   std::shared_ptr<Promise<void>> JHybridLiteRTLMSpec::deleteModel(const std::string& fileName) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* fileName */)>("deleteModel");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* fileName */)>("deleteModel");
     auto __result = method(_javaPart, jni::make_jstring(fileName));
     return [&]() {
       auto __promise = Promise<void>::create();
@@ -157,7 +155,7 @@ namespace margelo::nitro::litertlm {
     }();
   }
   std::shared_ptr<Promise<std::string>> JHybridLiteRTLMSpec::sendMessageWithAudio(const std::string& message, const std::string& audioPath) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* audioPath */)>("sendMessageWithAudio");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* audioPath */)>("sendMessageWithAudio");
     auto __result = method(_javaPart, jni::make_jstring(message), jni::make_jstring(audioPath));
     return [&]() {
       auto __promise = Promise<std::string>::create();
@@ -173,11 +171,11 @@ namespace margelo::nitro::litertlm {
     }();
   }
   void JHybridLiteRTLMSpec::sendMessageAsync(const std::string& message, const std::function<void(const std::string& /* token */, bool /* done */)>& onToken) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<JFunc_void_std__string_bool::javaobject> /* onToken */)>("sendMessageAsync_cxx");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* message */, jni::alias_ref<JFunc_void_std__string_bool::javaobject> /* onToken */)>("sendMessageAsync_cxx");
     method(_javaPart, jni::make_jstring(message), JFunc_void_std__string_bool_cxx::fromCpp(onToken));
   }
   std::vector<Message> JHybridLiteRTLMSpec::getHistory() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JMessage>>()>("getHistory");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JMessage>>()>("getHistory");
     auto __result = method(_javaPart);
     return [&]() {
       size_t __size = __result->size();
@@ -191,21 +189,26 @@ namespace margelo::nitro::litertlm {
     }();
   }
   void JHybridLiteRTLMSpec::resetConversation() {
-    static const auto method = javaClassStatic()->getMethod<void()>("resetConversation");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("resetConversation");
     method(_javaPart);
   }
   bool JHybridLiteRTLMSpec::isReady() {
-    static const auto method = javaClassStatic()->getMethod<jboolean()>("isReady");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("isReady");
     auto __result = method(_javaPart);
     return static_cast<bool>(__result);
   }
   GenerationStats JHybridLiteRTLMSpec::getStats() {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JGenerationStats>()>("getStats");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JGenerationStats>()>("getStats");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  MemoryUsage JHybridLiteRTLMSpec::getMemoryUsage() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JMemoryUsage>()>("getMemoryUsage");
     auto __result = method(_javaPart);
     return __result->toCpp();
   }
   void JHybridLiteRTLMSpec::close() {
-    static const auto method = javaClassStatic()->getMethod<void()>("close");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("close");
     method(_javaPart);
   }
 

package/nitrogen/generated/android/c++/JHybridLiteRTLMSpec.hpp

@@ -18,34 +18,33 @@ namespace margelo::nitro::litertlm {
 
   using namespace facebook;
 
-  class JHybridLiteRTLMSpec: public jni::HybridClass<JHybridLiteRTLMSpec, JHybridObject>,
-                             public virtual HybridLiteRTLMSpec {
+  class JHybridLiteRTLMSpec: public virtual HybridLiteRTLMSpec, public virtual JHybridObject {
   public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/HybridLiteRTLMSpec;";
-    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
-    static void registerNatives();
-
-  protected:
-    // C++ constructor (called from Java via `initHybrid()`)
-    explicit JHybridLiteRTLMSpec(jni::alias_ref<jhybridobject> jThis) :
-      HybridObject(HybridLiteRTLMSpec::TAG),
-      HybridBase(jThis),
-      _javaPart(jni::make_global(jThis)) {}
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/HybridLiteRTLMSpec;";
+      std::shared_ptr<JHybridLiteRTLMSpec> getJHybridLiteRTLMSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/HybridLiteRTLMSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
 
   public:
+    explicit JHybridLiteRTLMSpec(const jni::local_ref<JHybridLiteRTLMSpec::JavaPart>& javaPart):
+      HybridObject(HybridLiteRTLMSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
     ~JHybridLiteRTLMSpec() override {
       // Hermes GC can destroy JS objects on a non-JNI Thread.
       jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
     }
 
   public:
-    size_t getExternalMemorySize() noexcept override;
-    bool equals(const std::shared_ptr<HybridObject>& other) override;
-    void dispose() noexcept override;
-    std::string toString() override;
-
-  public:
-    inline const jni::global_ref<JHybridLiteRTLMSpec::javaobject>& getJavaPart() const noexcept {
+    inline const jni::global_ref<JHybridLiteRTLMSpec::JavaPart>& getJavaPart() const noexcept {
       return _javaPart;
     }
 
@@ -66,12 +65,11 @@ namespace margelo::nitro::litertlm {
     void resetConversation() override;
     bool isReady() override;
     GenerationStats getStats() override;
+    MemoryUsage getMemoryUsage() override;
     void close() override;
 
   private:
-    friend HybridBase;
-    using HybridBase::HybridBase;
-    jni::global_ref<JHybridLiteRTLMSpec::javaobject> _javaPart;
+    jni::global_ref<JHybridLiteRTLMSpec::JavaPart> _javaPart;
   };
 
 } // namespace margelo::nitro::litertlm

package/nitrogen/generated/android/c++/JMemoryUsage.hpp

@@ -0,0 +1,69 @@
+///
+/// JMemoryUsage.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "MemoryUsage.hpp"
+
+
+
+namespace margelo::nitro::litertlm {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "MemoryUsage" and the the Kotlin data class "MemoryUsage".
+   */
+  struct JMemoryUsage final: public jni::JavaClass<JMemoryUsage> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/dev/litert/litertlm/MemoryUsage;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct MemoryUsage by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MemoryUsage toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldNativeHeapBytes = clazz->getField<double>("nativeHeapBytes");
+      double nativeHeapBytes = this->getFieldValue(fieldNativeHeapBytes);
+      static const auto fieldResidentBytes = clazz->getField<double>("residentBytes");
+      double residentBytes = this->getFieldValue(fieldResidentBytes);
+      static const auto fieldAvailableMemoryBytes = clazz->getField<double>("availableMemoryBytes");
+      double availableMemoryBytes = this->getFieldValue(fieldAvailableMemoryBytes);
+      static const auto fieldIsLowMemory = clazz->getField<jboolean>("isLowMemory");
+      jboolean isLowMemory = this->getFieldValue(fieldIsLowMemory);
+      return MemoryUsage(
+        nativeHeapBytes,
+        residentBytes,
+        availableMemoryBytes,
+        static_cast<bool>(isLowMemory)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JMemoryUsage::javaobject> fromCpp(const MemoryUsage& value) {
+      using JSignature = JMemoryUsage(double, double, double, jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.nativeHeapBytes,
+        value.residentBytes,
+        value.availableMemoryBytes,
+        value.isLowMemory
+      );
+    }
+  };
+
+} // namespace margelo::nitro::litertlm

package/nitrogen/generated/android/kotlin/com/margelo/nitro/dev/litert/litertlm/HybridLiteRTLMSpec.kt

@@ -25,23 +25,6 @@ import com.margelo.nitro.core.HybridObject
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
 abstract class HybridLiteRTLMSpec: HybridObject() {
-  @DoNotStrip
-  private var mHybridData: HybridData = initHybrid()
-
-  init {
-    super.updateNative(mHybridData)
-  }
-
-  override fun updateNative(hybridData: HybridData) {
-    mHybridData = hybridData
-    super.updateNative(hybridData)
-  }
-
-  // Default implementation of `HybridObject.toString()`
-  override fun toString(): String {
-    return "[HybridObject LiteRTLM]"
-  }
-
   // Properties
   
 
@@ -100,11 +83,29 @@ abstract class HybridLiteRTLMSpec: HybridObject() {
   @Keep
   abstract fun getStats(): GenerationStats
   
+  @DoNotStrip
+  @Keep
+  abstract fun getMemoryUsage(): MemoryUsage
+  
   @DoNotStrip
   @Keep
   abstract fun close(): Unit
 
-  private external fun initHybrid(): HybridData
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject LiteRTLM]"
+  }
+
+  // C++ backing class
+  @DoNotStrip
+  @Keep
+  protected open class CxxPart(javaPart: HybridLiteRTLMSpec): HybridObject.CxxPart(javaPart) {
+    // C++ JHybridLiteRTLMSpec::CxxPart::initHybrid(...)
+    external override fun initHybrid(): HybridData
+  }
+  override fun createCxxPart(): CxxPart {
+    return CxxPart(this)
+  }
 
   companion object {
     protected const val TAG = "HybridLiteRTLMSpec"

package/nitrogen/generated/android/kotlin/com/margelo/nitro/dev/litert/litertlm/MemoryUsage.kt

@@ -0,0 +1,47 @@
+///
+/// MemoryUsage.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.dev.litert.litertlm
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "MemoryUsage".
+ */
+@DoNotStrip
+@Keep
+data class MemoryUsage(
+  @DoNotStrip
+  @Keep
+  val nativeHeapBytes: Double,
+  @DoNotStrip
+  @Keep
+  val residentBytes: Double,
+  @DoNotStrip
+  @Keep
+  val availableMemoryBytes: Double,
+  @DoNotStrip
+  @Keep
+  val isLowMemory: Boolean
+) {
+  /* primary constructor */
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(nativeHeapBytes: Double, residentBytes: Double, availableMemoryBytes: Double, isLowMemory: Boolean): MemoryUsage {
+      return MemoryUsage(nativeHeapBytes, residentBytes, availableMemoryBytes, isLowMemory)
+    }
+  }
+}

package/nitrogen/generated/shared/c++/HybridLiteRTLMSpec.cpp

@@ -25,6 +25,7 @@ namespace margelo::nitro::litertlm {
       prototype.registerHybridMethod("resetConversation", &HybridLiteRTLMSpec::resetConversation);
       prototype.registerHybridMethod("isReady", &HybridLiteRTLMSpec::isReady);
       prototype.registerHybridMethod("getStats", &HybridLiteRTLMSpec::getStats);
+      prototype.registerHybridMethod("getMemoryUsage", &HybridLiteRTLMSpec::getMemoryUsage);
       prototype.registerHybridMethod("close", &HybridLiteRTLMSpec::close);
     });
   }

package/nitrogen/generated/shared/c++/HybridLiteRTLMSpec.hpp

@@ -19,6 +19,8 @@ namespace margelo::nitro::litertlm { struct LLMConfig; }
 namespace margelo::nitro::litertlm { struct Message; }
 // Forward declaration of `GenerationStats` to properly resolve imports.
 namespace margelo::nitro::litertlm { struct GenerationStats; }
+// Forward declaration of `MemoryUsage` to properly resolve imports.
+namespace margelo::nitro::litertlm { struct MemoryUsage; }
 
 #include <NitroModules/Promise.hpp>
 #include <string>
@@ -28,6 +30,7 @@ namespace margelo::nitro::litertlm { struct GenerationStats; }
 #include "Message.hpp"
 #include <vector>
 #include "GenerationStats.hpp"
+#include "MemoryUsage.hpp"
 
 namespace margelo::nitro::litertlm {
 
@@ -71,6 +74,7 @@ namespace margelo::nitro::litertlm {
       virtual void resetConversation() = 0;
       virtual bool isReady() = 0;
       virtual GenerationStats getStats() = 0;
+      virtual MemoryUsage getMemoryUsage() = 0;
       virtual void close() = 0;
 
     protected: