@runanywhere/core 0.16.0

package/ios/SDKLogger.swift

@@ -0,0 +1,329 @@
+/**
+ * SDKLogger.swift
+ *
+ * iOS native logging implementation for React Native SDK.
+ * Provides structured logging with category-based filtering.
+ *
+ * Matches:
+ * - iOS SDK: sdk/runanywhere-swift/Sources/RunAnywhere/Infrastructure/Logging/SDKLogger.swift
+ * - TypeScript: packages/core/src/Foundation/Logging/Logger/SDKLogger.ts
+ *
+ * Usage:
+ *   SDKLogger.shared.info("SDK initialized")
+ *   SDKLogger.download.debug("Starting download: \(url)")
+ *   SDKLogger.llm.error("Generation failed", metadata: ["modelId": "llama-3.2"])
+ */
+
+import Foundation
+import os
+
+// MARK: - LogLevel
+
+/// Log severity levels matching TypeScript LogLevel enum
+@objc public enum RNLogLevel: Int, Comparable {
+    case debug = 0
+    case info = 1
+    case warning = 2
+    case error = 3
+    case fault = 4
+
+    public static func < (lhs: RNLogLevel, rhs: RNLogLevel) -> Bool {
+        lhs.rawValue < rhs.rawValue
+    }
+
+    public var description: String {
+        switch self {
+        case .debug: return "DEBUG"
+        case .info: return "INFO"
+        case .warning: return "WARN"
+        case .error: return "ERROR"
+        case .fault: return "FAULT"
+        }
+    }
+}
+
+// MARK: - SDKLogger
+
+// MARK: - Log Entry (for forwarding to TypeScript)
+
+/// Log entry structure for forwarding to TypeScript
+/// Matches TypeScript: LogEntry interface
+@objc public class NativeLogEntry: NSObject {
+    @objc public let level: Int
+    @objc public let category: String
+    @objc public let message: String
+    @objc public let metadata: [String: Any]?
+    @objc public let timestamp: Date
+
+    @objc public init(level: RNLogLevel, category: String, message: String, metadata: [String: Any]?, timestamp: Date) {
+        self.level = level.rawValue
+        self.category = category
+        self.message = message
+        self.metadata = metadata
+        self.timestamp = timestamp
+        super.init()
+    }
+
+    /// Convert to dictionary for JSON serialization
+    @objc public func toDictionary() -> [String: Any] {
+        var dict: [String: Any] = [
+            "level": level,
+            "category": category,
+            "message": message,
+            "timestamp": ISO8601DateFormatter().string(from: timestamp)
+        ]
+        if let metadata = metadata {
+            // Convert metadata to JSON-safe types
+            dict["metadata"] = metadata.mapValues { value -> Any in
+                if let stringValue = value as? String { return stringValue }
+                if let numberValue = value as? NSNumber { return numberValue }
+                return String(describing: value)
+            }
+        }
+        return dict
+    }
+}
+
+// MARK: - Log Forwarder Protocol
+
+/// Protocol for forwarding logs to TypeScript
+@objc public protocol NativeLogForwarder {
+    func forwardLog(_ entry: NativeLogEntry)
+}
+
+/// Simple logger for SDK components with category-based filtering.
+/// Thread-safe and easy to use. Supports forwarding to TypeScript.
+@objc public final class SDKLogger: NSObject {
+
+    // MARK: - Properties
+
+    /// Logger category (e.g., "LLM", "Download", "Models")
+    public let category: String
+
+    /// Minimum log level (logs below this level are ignored)
+    private static var minLogLevel: RNLogLevel = .debug
+
+    /// Whether local console logging is enabled
+    private static var localLoggingEnabled = true
+
+    /// Whether to forward logs to TypeScript
+    private static var forwardingEnabled = true
+
+    /// Log forwarder for TypeScript bridge
+    private static var logForwarder: NativeLogForwarder?
+
+    /// OSLog instance for this category
+    private lazy var osLog: OSLog = {
+        OSLog(subsystem: "com.runanywhere.reactnative", category: category)
+    }()
+
+    // MARK: - Initialization
+
+    /// Create a new logger with the specified category.
+    /// - Parameter category: Category name for log filtering
+    @objc public init(category: String = "SDK") {
+        self.category = category
+        super.init()
+    }
+
+    // MARK: - Configuration
+
+    /// Set the minimum log level.
+    /// - Parameter level: Minimum level to log
+    @objc public static func setMinLogLevel(_ level: RNLogLevel) {
+        minLogLevel = level
+    }
+
+    /// Get the current minimum log level.
+    @objc public static func getMinLogLevel() -> RNLogLevel {
+        return minLogLevel
+    }
+
+    /// Enable or disable local console logging.
+    /// - Parameter enabled: Whether to log to console
+    @objc public static func setLocalLoggingEnabled(_ enabled: Bool) {
+        localLoggingEnabled = enabled
+    }
+
+    /// Enable or disable log forwarding to TypeScript.
+    /// - Parameter enabled: Whether to forward logs
+    @objc public static func setForwardingEnabled(_ enabled: Bool) {
+        forwardingEnabled = enabled
+    }
+
+    /// Set the log forwarder for TypeScript bridge.
+    /// - Parameter forwarder: Log forwarder implementation
+    @objc public static func setLogForwarder(_ forwarder: NativeLogForwarder?) {
+        logForwarder = forwarder
+    }
+
+    /// Check if log forwarding is configured
+    @objc public static func isForwardingConfigured() -> Bool {
+        return logForwarder != nil && forwardingEnabled
+    }
+
+    // MARK: - Logging Methods
+
+    /// Log a debug message.
+    /// - Parameters:
+    ///   - message: Log message
+    ///   - metadata: Optional metadata dictionary
+    @objc public func debug(_ message: String, metadata: [String: Any]? = nil) {
+        log(level: .debug, message: message, metadata: metadata)
+    }
+
+    /// Log an info message.
+    /// - Parameters:
+    ///   - message: Log message
+    ///   - metadata: Optional metadata dictionary
+    @objc public func info(_ message: String, metadata: [String: Any]? = nil) {
+        log(level: .info, message: message, metadata: metadata)
+    }
+
+    /// Log a warning message.
+    /// - Parameters:
+    ///   - message: Log message
+    ///   - metadata: Optional metadata dictionary
+    @objc public func warning(_ message: String, metadata: [String: Any]? = nil) {
+        log(level: .warning, message: message, metadata: metadata)
+    }
+
+    /// Log an error message.
+    /// - Parameters:
+    ///   - message: Log message
+    ///   - metadata: Optional metadata dictionary
+    @objc public func error(_ message: String, metadata: [String: Any]? = nil) {
+        log(level: .error, message: message, metadata: metadata)
+    }
+
+    /// Log a fault/critical message.
+    /// - Parameters:
+    ///   - message: Log message
+    ///   - metadata: Optional metadata dictionary
+    @objc public func fault(_ message: String, metadata: [String: Any]? = nil) {
+        log(level: .fault, message: message, metadata: metadata)
+    }
+
+    // MARK: - Error Logging
+
+    /// Log an Error with full context.
+    /// - Parameters:
+    ///   - error: Error to log
+    ///   - additionalInfo: Optional additional context
+    @objc public func logError(_ error: Error, additionalInfo: String? = nil) {
+        let nsError = error as NSError
+        var message = error.localizedDescription
+        if let info = additionalInfo {
+            message += " | Context: \(info)"
+        }
+
+        var metadata: [String: Any] = [
+            "error_domain": nsError.domain,
+            "error_code": nsError.code
+        ]
+
+        if !nsError.userInfo.isEmpty {
+            metadata["error_userInfo"] = nsError.userInfo.description
+        }
+
+        log(level: .error, message: message, metadata: metadata)
+    }
+
+    // MARK: - Core Logging
+
+    /// Log a message with the specified level.
+    /// - Parameters:
+    ///   - level: Log level
+    ///   - message: Log message
+    ///   - metadata: Optional metadata dictionary
+    public func log(level: RNLogLevel, message: String, metadata: [String: Any]? = nil) {
+        guard level >= Self.minLogLevel else { return }
+
+        let timestamp = Date()
+
+        // Build formatted message
+        var output = "[\(category)] \(message)"
+        if let metadata = metadata, !metadata.isEmpty {
+            let metaStr = metadata.map { "\($0.key)=\($0.value)" }.joined(separator: ", ")
+            output += " | \(metaStr)"
+        }
+
+        // Log to OSLog (always, for system log capture)
+        switch level {
+        case .debug:
+            os_log(.debug, log: osLog, "%{public}@", output)
+        case .info:
+            os_log(.info, log: osLog, "%{public}@", output)
+        case .warning:
+            os_log(.default, log: osLog, "[WARN] %{public}@", output)
+        case .error:
+            os_log(.error, log: osLog, "%{public}@", output)
+        case .fault:
+            os_log(.fault, log: osLog, "%{public}@", output)
+        }
+
+        // Also log to console if enabled
+        if Self.localLoggingEnabled {
+            let emoji: String
+            switch level {
+            case .debug: emoji = "[DEBUG]"
+            case .info: emoji = "[INFO]"
+            case .warning: emoji = "[WARN]"
+            case .error: emoji = "[ERROR]"
+            case .fault: emoji = "[FAULT]"
+            }
+            // swiftlint:disable:next no_print_statements
+            NSLog("%@ %@", emoji, output)
+        }
+
+        // Forward to TypeScript if enabled
+        if Self.forwardingEnabled, let forwarder = Self.logForwarder {
+            let entry = NativeLogEntry(
+                level: level,
+                category: category,
+                message: message,
+                metadata: metadata,
+                timestamp: timestamp
+            )
+            forwarder.forwardLog(entry)
+        }
+    }
+
+    // MARK: - Convenience Loggers (Static)
+
+    /// Shared logger for general SDK operations. Category: "RunAnywhere"
+    @objc public static let shared = SDKLogger(category: "RunAnywhere")
+
+    /// Logger for LLM operations. Category: "LLM"
+    @objc public static let llm = SDKLogger(category: "LLM")
+
+    /// Logger for STT (Speech-to-Text) operations. Category: "STT"
+    @objc public static let stt = SDKLogger(category: "STT")
+
+    /// Logger for TTS (Text-to-Speech) operations. Category: "TTS"
+    @objc public static let tts = SDKLogger(category: "TTS")
+
+    /// Logger for download operations. Category: "Download"
+    @objc public static let download = SDKLogger(category: "Download")
+
+    /// Logger for model operations. Category: "Models"
+    @objc public static let models = SDKLogger(category: "Models")
+
+    /// Logger for core SDK operations. Category: "Core"
+    @objc public static let core = SDKLogger(category: "Core")
+
+    /// Logger for VAD operations. Category: "VAD"
+    @objc public static let vad = SDKLogger(category: "VAD")
+
+    /// Logger for network operations. Category: "Network"
+    @objc public static let network = SDKLogger(category: "Network")
+
+    /// Logger for events. Category: "Events"
+    @objc public static let events = SDKLogger(category: "Events")
+
+    /// Logger for archive/extraction operations. Category: "Archive"
+    @objc public static let archive = SDKLogger(category: "Archive")
+
+    /// Logger for audio decoding operations. Category: "AudioDecoder"
+    @objc public static let audioDecoder = SDKLogger(category: "AudioDecoder")
+}

package/nitro.json

@@ -0,0 +1,20 @@
+{
+  "cxxNamespace": ["runanywhere"],
+  "ios": {
+    "iosModuleName": "RunAnywhereCore"
+  },
+  "android": {
+    "androidNamespace": ["runanywhere"],
+    "androidCxxLibName": "runanywherecore"
+  },
+  "autolinking": {
+    "RunAnywhereCore": {
+      "cpp": "HybridRunAnywhereCore"
+    },
+    "RunAnywhereDeviceInfo": {
+      "kotlin": "HybridRunAnywhereDeviceInfo",
+      "swift": "HybridRunAnywhereDeviceInfo"
+    }
+  },
+  "ignorePaths": ["node_modules", "lib", "example"]
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true

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

@@ -0,0 +1,257 @@
+///
+/// JHybridRunAnywhereDeviceInfoSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridRunAnywhereDeviceInfoSpec.hpp"
+
+
+
+#include <string>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+
+namespace margelo::nitro::runanywhere {
+
+  jni::local_ref<JHybridRunAnywhereDeviceInfoSpec::jhybriddata> JHybridRunAnywhereDeviceInfoSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridRunAnywhereDeviceInfoSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridRunAnywhereDeviceInfoSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridRunAnywhereDeviceInfoSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridRunAnywhereDeviceInfoSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridRunAnywhereDeviceInfoSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<std::string>> JHybridRunAnywhereDeviceInfoSpec::getDeviceModel() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getDeviceModel");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::string>> JHybridRunAnywhereDeviceInfoSpec::getOSVersion() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getOSVersion");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::string>> JHybridRunAnywhereDeviceInfoSpec::getPlatform() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getPlatform");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<double>> JHybridRunAnywhereDeviceInfoSpec::getTotalRAM() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getTotalRAM");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<double>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JDouble>(__boxedResult);
+        __promise->resolve(__result->value());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<double>> JHybridRunAnywhereDeviceInfoSpec::getAvailableRAM() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getAvailableRAM");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<double>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JDouble>(__boxedResult);
+        __promise->resolve(__result->value());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<double>> JHybridRunAnywhereDeviceInfoSpec::getCPUCores() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getCPUCores");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<double>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JDouble>(__boxedResult);
+        __promise->resolve(__result->value());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<bool>> JHybridRunAnywhereDeviceInfoSpec::hasGPU() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("hasGPU");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<bool>> JHybridRunAnywhereDeviceInfoSpec::hasNPU() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("hasNPU");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::string>> JHybridRunAnywhereDeviceInfoSpec::getChipName() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getChipName");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<double>> JHybridRunAnywhereDeviceInfoSpec::getThermalState() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getThermalState");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<double>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JDouble>(__boxedResult);
+        __promise->resolve(__result->value());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<double>> JHybridRunAnywhereDeviceInfoSpec::getBatteryLevel() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getBatteryLevel");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<double>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JDouble>(__boxedResult);
+        __promise->resolve(__result->value());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<bool>> JHybridRunAnywhereDeviceInfoSpec::isCharging() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("isCharging");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<bool>> JHybridRunAnywhereDeviceInfoSpec::isLowPowerMode() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("isLowPowerMode");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+
+} // namespace margelo::nitro::runanywhere

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

@@ -0,0 +1,77 @@
+///
+/// HybridRunAnywhereDeviceInfoSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridRunAnywhereDeviceInfoSpec.hpp"
+
+
+
+
+namespace margelo::nitro::runanywhere {
+
+  using namespace facebook;
+
+  class JHybridRunAnywhereDeviceInfoSpec: public jni::HybridClass<JHybridRunAnywhereDeviceInfoSpec, JHybridObject>,
+                                          public virtual HybridRunAnywhereDeviceInfoSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/runanywhere/HybridRunAnywhereDeviceInfoSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridRunAnywhereDeviceInfoSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridRunAnywhereDeviceInfoSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridRunAnywhereDeviceInfoSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridRunAnywhereDeviceInfoSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<std::string>> getDeviceModel() override;
+    std::shared_ptr<Promise<std::string>> getOSVersion() override;
+    std::shared_ptr<Promise<std::string>> getPlatform() override;
+    std::shared_ptr<Promise<double>> getTotalRAM() override;
+    std::shared_ptr<Promise<double>> getAvailableRAM() override;
+    std::shared_ptr<Promise<double>> getCPUCores() override;
+    std::shared_ptr<Promise<bool>> hasGPU() override;
+    std::shared_ptr<Promise<bool>> hasNPU() override;
+    std::shared_ptr<Promise<std::string>> getChipName() override;
+    std::shared_ptr<Promise<double>> getThermalState() override;
+    std::shared_ptr<Promise<double>> getBatteryLevel() override;
+    std::shared_ptr<Promise<bool>> isCharging() override;
+    std::shared_ptr<Promise<bool>> isLowPowerMode() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridRunAnywhereDeviceInfoSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::runanywhere