@dr33m/react-native-litert-lm 0.5.0

package/android/src/main/java/com/margelo/nitro/dev/litert/litertlm/HybridModelStore.kt

@@ -0,0 +1,189 @@
+package com.margelo.nitro.dev.litert.litertlm
+
+import android.util.Log
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
+import dev.litert.litertlm.LiteRTLMInitProvider
+import java.io.File
+import java.io.FileOutputStream
+import java.net.HttpURLConnection
+import java.net.URL
+import org.json.JSONObject
+
+@DoNotStrip
+@Keep
+class HybridModelStore : HybridModelStoreSpec() {
+
+    private val tag = "HybridModelStore"
+
+    private val modelsDirectory: File
+        get() {
+            val context = LiteRTLMInitProvider.applicationContext 
+                ?: throw RuntimeException("Android Application Context is not available")
+            val modelsDir = File(context.filesDir, "models")
+            if (!modelsDir.exists()) {
+                modelsDir.mkdirs()
+            }
+            return modelsDir
+        }
+
+    private fun sanitizeFileName(fileName: String) {
+        if (fileName.contains("..") || fileName.contains("/") || fileName.contains("\\")) {
+            throw IllegalArgumentException("Invalid filename: path traversal or directory separators are not allowed.")
+        }
+    }
+
+    override fun isCached(fileName: String): Boolean {
+        sanitizeFileName(fileName)
+        val file = File(modelsDirectory, fileName)
+        return file.exists() && file.length() > 0
+    }
+
+    override fun getFilePath(fileName: String): String {
+        sanitizeFileName(fileName)
+        return File(modelsDirectory, fileName).absolutePath
+    }
+
+    override fun listCachedFiles(): Array<ModelFile> {
+        return try {
+            val dir = modelsDirectory
+            val files = dir.listFiles() ?: return emptyArray()
+            val result = mutableListOf<ModelFile>()
+            for (f in files) {
+                if (f.isFile && !f.name.endsWith(".tmp")) {
+                    result.add(
+                        ModelFile(
+                            fileName = f.name,
+                            absolutePath = f.absolutePath,
+                            sizeBytes = f.length().toDouble(),
+                            lastModifiedMs = f.lastModified().toDouble()
+                        )
+                    )
+                }
+            }
+            result.toTypedArray()
+        } catch (e: Exception) {
+            Log.e(tag, "Failed to list cached files", e)
+            emptyArray()
+        }
+    }
+
+    override fun deleteFile(fileName: String) {
+        sanitizeFileName(fileName)
+        val file = File(modelsDirectory, fileName)
+        if (file.exists()) {
+            val deleted = file.delete()
+            if (!deleted) {
+                throw RuntimeException("Failed to delete model file: ${file.absolutePath}")
+            }
+        }
+    }
+
+    override fun downloadFile(
+        url: String,
+        fileName: String,
+        headersJson: String,
+        onProgress: (progress: Double) -> Unit
+    ): Promise<String> {
+        return Promise.parallel {
+            Log.i(tag, "downloadFile: $url -> $fileName")
+            sanitizeFileName(fileName)
+
+            if (!url.startsWith("https://", ignoreCase = true)) {
+                throw IllegalArgumentException("Invalid download URL: HTTPS is required for security.")
+            }
+
+            val dir = modelsDirectory
+            val modelFile = File(dir, fileName)
+            val tempFile = File(dir, "$fileName.tmp")
+
+            // Fast cache check
+            if (modelFile.exists() && modelFile.length() > 0) {
+                Log.i(tag, "Model already exists: ${modelFile.absolutePath}")
+                onProgress(1.0)
+                return@parallel modelFile.absolutePath
+            }
+
+            Log.i(tag, "Downloading model to temp file: ${tempFile.absolutePath}")
+            onProgress(0.0)
+
+            // Parse headers
+            val headersMap = mutableMapOf<String, String>()
+            if (headersJson.isNotEmpty()) {
+                try {
+                    val json = JSONObject(headersJson)
+                    val keys = json.keys()
+                    while (keys.hasNext()) {
+                        val key = keys.next()
+                        headersMap[key] = json.getString(key)
+                    }
+                } catch (e: Exception) {
+                    Log.e(tag, "Failed to parse custom headers JSON", e)
+                }
+            }
+
+            try {
+                val connection = URL(url).openConnection() as HttpURLConnection
+                connection.connectTimeout = 15000 // 15s
+                connection.readTimeout = 0 // Infinite read timeout for large files
+                connection.doInput = true
+
+                // Apply headers
+                for ((key, value) in headersMap) {
+                    connection.setRequestProperty(key, value)
+                }
+
+                connection.connect()
+
+                if (connection.responseCode != HttpURLConnection.HTTP_OK) {
+                    throw RuntimeException("Failed to download model: HTTP ${connection.responseCode}")
+                }
+
+                val contentLength = connection.contentLengthLong
+                val input = connection.inputStream
+                val output = FileOutputStream(tempFile)
+
+                val buffer = ByteArray(8 * 1024)
+                var bytesRead: Int
+                var totalBytesRead = 0L
+                var lastProgressUpdate = 0L
+
+                while (input.read(buffer).also { bytesRead = it } != -1) {
+                    output.write(buffer, 0, bytesRead)
+                    totalBytesRead += bytesRead
+
+                    if (contentLength > 0) {
+                        val currentTime = System.currentTimeMillis()
+                        // Update progress roughly every 100ms to prevent bridge flooding
+                        if (currentTime - lastProgressUpdate > 100) {
+                            val progress = totalBytesRead.toDouble() / contentLength.toDouble()
+                            onProgress(progress)
+                            lastProgressUpdate = currentTime
+                        }
+                    }
+                }
+
+                output.flush()
+                output.close()
+                input.close()
+                connection.disconnect()
+
+                // Atomic rename
+                if (tempFile.renameTo(modelFile)) {
+                    Log.i(tag, "Download complete and verified at: ${modelFile.absolutePath}")
+                    onProgress(1.0)
+                    modelFile.absolutePath
+                } else {
+                    throw RuntimeException("Failed to rename temporary file to model file")
+                }
+            } catch (e: Exception) {
+                Log.e(tag, "Download failed", e)
+                if (tempFile.exists()) {
+                    tempFile.delete()
+                }
+                throw RuntimeException("Download failed: ${e.message}", e)
+            }
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/dev/litert/litertlm/LiteRTLMRegistry.kt

@@ -0,0 +1,32 @@
+package com.margelo.nitro.dev.litert.litertlm
+
+import java.util.Collections
+import java.util.WeakHashMap
+import android.util.Log
+
+/**
+ * Global registry to track active LiteRTLM instances.
+ * Used for memory trimming and cleanup.
+ */
+object LiteRTLMRegistry {
+    private const val TAG = "LiteRTLMRegistry"
+    
+    // Use WeakSet-like structure to prevent leaks
+    private val instances = Collections.newSetFromMap(WeakHashMap<HybridLiteRTLM, Boolean>())
+
+    fun register(instance: HybridLiteRTLM) {
+        synchronized(instances) {
+            instances.add(instance)
+        }
+    }
+
+    fun onTrimMemory(level: Int) {
+        Log.w(TAG, "Received memory warning (level=$level). Releasing resources...")
+        synchronized(instances) {
+            instances.forEach { it.close() }
+            // Note: We don't clear the set here, as close() should be idempotent
+            // and the instance might still be ref-counted by JS. 
+            // We just ensure the HEAVY native resources are gone.
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/dev/litert/litertlm/MultimodalPartFactories.kt

@@ -0,0 +1,15 @@
+package com.margelo.nitro.dev.litert.litertlm
+
+/**
+ * Mirrors [src/inferenceRouting.ts] — keep shapes in sync for native direct hybrid access.
+ */
+object MultimodalPartFactories {
+    fun textPart(text: String): MultimodalPart =
+        MultimodalPart(type = PartType.TEXT, text = text, path = null, imageBuffer = null, audioBuffer = null)
+
+    fun imagePart(path: String): MultimodalPart =
+        MultimodalPart(type = PartType.IMAGE, text = null, path = path, imageBuffer = null, audioBuffer = null)
+
+    fun audioPart(path: String): MultimodalPart =
+        MultimodalPart(type = PartType.AUDIO, text = null, path = path, imageBuffer = null, audioBuffer = null)
+}

package/android/src/main/java/com/margelo/nitro/dev/litert/litertlm/StreamingCallbackListener.kt

@@ -0,0 +1,89 @@
+package com.margelo.nitro.dev.litert.litertlm
+
+import android.util.Log
+import com.google.ai.edge.litertlm.Content
+
+/**
+ * Named implementation of the LiteRT-LM MessageCallback for streaming inference.
+ *
+ * Accumulates response chunks, forwards tokens to JS, and appends the final
+ * response to the conversation history.
+ */
+internal class StreamingCallbackListener(
+    private val onToken: (String, Boolean) -> Unit,
+    private val responseBuilder: StringBuilder,
+    private val thinkingBuilder: StringBuilder = StringBuilder(),
+    private val history: MutableList<Message>,
+    private val userMessage: String,
+    private val onStatsReady: (GenerationStats) -> Unit,
+    private val onFailure: ((Throwable) -> Unit)? = null,
+    private val onThinkingToken: ((String) -> Unit)? = null,
+) : com.google.ai.edge.litertlm.MessageCallback {
+
+    private val startTime = System.nanoTime()
+    private var firstTokenTime = 0L
+    private var tokenCount = 0
+
+    override fun onMessage(message: com.google.ai.edge.litertlm.Message) {
+        val chunk = message.contents.contents
+            .filterIsInstance<Content.Text>()
+            .joinToString("") { it.text }
+
+        // Capture thinking from the "thought" channel
+        val thinkingChunk = message.channels["thought"]
+        if (!thinkingChunk.isNullOrEmpty()) {
+            thinkingBuilder.append(thinkingChunk)
+            onThinkingToken?.invoke(thinkingChunk)
+        }
+
+        if (firstTokenTime == 0L && chunk.isNotEmpty()) {
+            firstTokenTime = System.nanoTime()
+        }
+        if (chunk.isNotEmpty()) {
+            tokenCount++
+        }
+
+        onToken(chunk, false)
+
+        if (chunk.isNotEmpty()) {
+            responseBuilder.append(chunk)
+        }
+    }
+
+    override fun onDone() {
+        val fullResponse = responseBuilder.toString()
+        history.add(Message(Role.MODEL, fullResponse))
+
+        // Compute stats using heuristic token counts (~4 chars/token)
+        val elapsedMs = (System.nanoTime() - startTime) / 1_000_000.0
+        val ttftMs = if (firstTokenTime > 0) (firstTokenTime - startTime) / 1_000_000.0 else 0.0
+        val promptTokens = userMessage.length / 4.0
+        val completionTokens = fullResponse.length / 4.0
+        onStatsReady(GenerationStats(
+            promptTokens = promptTokens,
+            completionTokens = completionTokens,
+            totalTokens = promptTokens + completionTokens,
+            timeToFirstToken = ttftMs,
+            totalTime = elapsedMs,
+            tokensPerSecond = if (elapsedMs > 0) completionTokens / (elapsedMs / 1000.0) else 0.0
+        ))
+
+        Log.d("StreamingCallbackListener", "Streaming done. Length: ${fullResponse.length}, TTFT: ${ttftMs.toLong()}ms, Total: ${elapsedMs.toLong()}ms")
+
+        // Notify JS that streaming is done AFTER updating history and stats
+        onToken("", true)
+    }
+
+    override fun onError(throwable: Throwable) {
+        if (throwable is kotlinx.coroutines.CancellationException ||
+            throwable.message?.contains("cancel", ignoreCase = true) == true) {
+            // Graceful cancellation via stopGeneration() — treat as done with partial content
+            Log.i("StreamingCallbackListener", "Inference cancelled, emitting partial result")
+            onDone()
+            return
+        }
+        Log.e("StreamingCallbackListener", "Async generation failed", throwable)
+        onToken("Error: ${throwable.message}", true)
+        onFailure?.invoke(throwable)
+    }
+}

package/android/src/main/java/dev/litert/litertlm/LiteRTLMInitProvider.kt

@@ -0,0 +1,57 @@
+package dev.litert.litertlm
+
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.content.Context
+import android.database.Cursor
+import android.net.Uri
+import android.util.Log
+
+class LiteRTLMInitProvider : ContentProvider() {
+    companion object {
+        private const val TAG = "LiteRTLMInitProvider"
+        var applicationContext: Context? = null
+            private set
+    }
+
+    override fun onCreate(): Boolean {
+        applicationContext = context?.applicationContext
+        Log.i(TAG, "LiteRTLMInitProvider initialized with context: $applicationContext")
+        
+        applicationContext?.registerComponentCallbacks(object : android.content.ComponentCallbacks2 {
+            override fun onTrimMemory(level: Int) {
+                if (level >= android.content.ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW) {
+                    com.margelo.nitro.dev.litert.litertlm.LiteRTLMRegistry.onTrimMemory(level)
+                }
+            }
+
+            override fun onConfigurationChanged(newConfig: android.content.res.Configuration) {}
+            override fun onLowMemory() {
+                com.margelo.nitro.dev.litert.litertlm.LiteRTLMRegistry.onTrimMemory(android.content.ComponentCallbacks2.TRIM_MEMORY_COMPLETE)
+            }
+        })
+        
+        return true
+    }
+
+    override fun query(
+        uri: Uri,
+        projection: Array<out String>?,
+        selection: String?,
+        selectionArgs: Array<out String>?,
+        sortOrder: String?
+    ): Cursor? = null
+
+    override fun getType(uri: Uri): String? = null
+
+    override fun insert(uri: Uri, values: ContentValues?): Uri? = null
+
+    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int = 0
+
+    override fun update(
+        uri: Uri,
+        values: ContentValues?,
+        selection: String?,
+        selectionArgs: Array<out String>?
+    ): Int = 0
+}

package/android/src/main/java/dev/litert/litertlm/LiteRTLMPackage.kt

@@ -0,0 +1,43 @@
+package dev.litert.litertlm
+
+import android.os.Build
+import android.util.Log
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+
+import com.margelo.nitro.dev.litert.litertlm.LiteRTLMOnLoad
+
+class LiteRTLMPackage : TurboReactPackage() {
+    companion object {
+        private const val TAG = "LiteRTLMPackage"
+
+        private fun isSupportedPrimaryAbi(): Boolean {
+            val primaryAbi = Build.SUPPORTED_64_BIT_ABIS.firstOrNull() ?: return false
+            return primaryAbi == "arm64-v8a"
+        }
+    }
+    init {
+        if (!isSupportedPrimaryAbi()) {
+            Log.w(TAG, "Skipping LiteRTLM native init on unsupported primary ABI: ${Build.SUPPORTED_64_BIT_ABIS.firstOrNull()}")
+        } else {
+            try {
+                LiteRTLMOnLoad.initializeNative()
+            } catch (e: UnsatisfiedLinkError) {
+                Log.e(TAG, "LiteRTLM native init failed; disabling LiteRTLM for this process.", e)
+            }
+        }
+    }
+
+
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { emptyMap<String, ReactModuleInfo>() }
+    }
+}

package/android/src/test/java/com/margelo/nitro/core/Promise.kt

@@ -0,0 +1,46 @@
+package com.margelo.nitro.core
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+@Keep
+@DoNotStrip
+class Promise<T> {
+    companion object {
+        @JvmStatic
+        fun <T> parallel(block: () -> T): Promise<T> {
+            val promise = Promise<T>()
+            try {
+                val result = block()
+                promise.resolve(result)
+            } catch (e: Throwable) {
+                promise.reject(e)
+            }
+            return promise
+        }
+    }
+
+    var result: T? = null
+        private set
+    var error: Throwable? = null
+        private set
+    var isCompleted = false
+        private set
+    private val callbacks = mutableListOf<(T?, Throwable?) -> Unit>()
+
+    fun resolve(value: T) {
+        synchronized(this) {
+            result = value
+            isCompleted = true
+            callbacks.forEach { it(value, null) }
+        }
+    }
+
+    fun reject(exception: Throwable) {
+        synchronized(this) {
+            error = exception
+            isCompleted = true
+            callbacks.forEach { it(null, exception) }
+        }
+    }
+}

package/android/src/test/java/com/margelo/nitro/dev/litert/litertlm/HybridLiteRTLMTest.kt

@@ -0,0 +1,122 @@
+package com.margelo.nitro.dev.litert.litertlm
+
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.After
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import dev.litert.litertlm.LiteRTLMInitProvider
+import java.lang.IllegalArgumentException
+
+@RunWith(RobolectricTestRunner::class)
+class HybridLiteRTLMTest {
+    private lateinit var bridge: HybridLiteRTLM
+
+    @Before
+    fun setUp() {
+        // Initialize the static applicationContext inside LiteRTLMInitProvider via reflection
+        try {
+            val field = LiteRTLMInitProvider::class.java.getDeclaredField("applicationContext")
+            field.isAccessible = true
+            field.set(null, RuntimeEnvironment.getApplication())
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+        
+        bridge = HybridLiteRTLM()
+    }
+
+    @After
+    fun tearDown() {
+        bridge.close()
+    }
+
+    @Test
+    fun testAndroidPathTraversalPrevention() {
+        val traversals = arrayOf("../secret", "/etc/hosts", "nested\\..\\file", "..", "../", "..\\")
+        for (traversal in traversals) {
+            val promise = bridge.deleteModel(traversal)
+            assertNotNull("Promise should not be null", promise)
+            assertTrue("Promise should be completed", promise.isCompleted)
+            assertNotNull("Promise should have rejected with an error for filename: $traversal", promise.error)
+            val error = promise.error!!
+            val errMsg = error.message ?: error.cause?.message ?: ""
+            assertTrue("Expected message to contain traversal warning, got: $errMsg",
+                errMsg.contains("path traversal or directory separators are not allowed"))
+        }
+    }
+
+    @Test
+    fun testAndroidHTTPSDownloadEnforcement() {
+        val promise = bridge.downloadModel("http://insecure.site/model.bin", "model.bin", null)
+        assertNotNull("Promise should not be null", promise)
+        assertTrue("Promise should be completed", promise.isCompleted)
+        assertNotNull("Promise should have rejected with an error", promise.error)
+        val error = promise.error!!
+        val errMsg = error.message ?: error.cause?.message ?: ""
+        assertTrue("Expected message to contain HTTPS warning, got: $errMsg",
+            errMsg.contains("HTTPS is required for security"))
+    }
+
+    @Test
+    fun testAndroidMemoryTelemetry() {
+        val mem = bridge.getMemoryUsage()
+        assertNotNull(mem)
+        assertTrue(mem.nativeHeapBytes >= 0.0)
+        assertTrue(mem.residentBytes >= 0.0)
+        assertTrue(mem.availableMemoryBytes >= 0.0)
+    }
+
+    @Test
+    fun testSendMessageWithImageAsyncRejectsWithoutModel() {
+        val promise = bridge.sendMessageWithImageAsync("hello", "/tmp/image.jpg") { _, _ -> }
+        assertNotNull("Promise should not be null", promise)
+        assertTrue("Promise should be completed", promise.isCompleted)
+        assertNotNull("Promise should have rejected without model", promise.error)
+        val errMsg = promise.error!!.message ?: promise.error!!.cause?.message ?: ""
+        assertTrue("Expected no-model error, got: $errMsg",
+            errMsg.contains("No model loaded"))
+    }
+
+    @Test
+    fun testSendMessageWithAudioAsyncRejectsWithoutModel() {
+        val promise = bridge.sendMessageWithAudioAsync("hello", "/tmp/audio.wav") { _, _ -> }
+        assertNotNull("Promise should not be null", promise)
+        assertTrue("Promise should be completed", promise.isCompleted)
+        assertNotNull("Promise should have rejected without model", promise.error)
+        val errMsg = promise.error!!.message ?: promise.error!!.cause?.message ?: ""
+        assertTrue("Expected no-model error, got: $errMsg",
+            errMsg.contains("No model loaded"))
+    }
+
+    @Test
+    fun testAndroidInitialStats() {
+        val stats = bridge.getStats()
+        assertNotNull(stats)
+        assertEquals(0.0, stats.promptTokens, 0.0)
+        assertEquals(0.0, stats.completionTokens, 0.0)
+        assertEquals(0.0, stats.totalTokens, 0.0)
+        assertEquals(0.0, stats.timeToFirstToken, 0.0)
+        assertEquals(0.0, stats.totalTime, 0.0)
+        assertEquals(0.0, stats.tokensPerSecond, 0.0)
+    }
+
+    @Test
+    fun testDeleteModelCleanupLogic() {
+        val loadedPathField = HybridLiteRTLM::class.java.getDeclaredField("loadedModelPath")
+        loadedPathField.isAccessible = true
+        loadedPathField.set(bridge, "/path/to/my_loaded_model.litertlm")
+
+        val promise1 = bridge.deleteModel("other_model.litertlm")
+        assertNotNull(promise1)
+        while (!promise1.isCompleted) { Thread.sleep(10) }
+        assertEquals("/path/to/my_loaded_model.litertlm", loadedPathField.get(bridge))
+
+        val promise2 = bridge.deleteModel("my_loaded_model.litertlm")
+        assertNotNull(promise2)
+        while (!promise2.isCompleted) { Thread.sleep(10) }
+        assertNull(loadedPathField.get(bridge))
+    }
+}

package/app.plugin.js

@@ -0,0 +1,58 @@
+/**
+ * Expo config plugin for react-native-litert-lm.
+ *
+ * Ensures correct build settings for the LiteRT-LM native module:
+ * - Android: minSdkVersion 26, Kotlin 2.3.0 (required by litertlm-android AAR)
+ */
+const {
+  withGradleProperties,
+  withProjectBuildGradle,
+} = require('@expo/config-plugins');
+
+function withLiteRTLM(config) {
+  // Android: Ensure minSdkVersion is at least 26
+  config = withGradleProperties(config, (config) => {
+    const props = config.modResults;
+
+    // Set minSdkVersion if not already high enough
+    const minSdkProp = props.find((p) => p.key === 'android.minSdkVersion');
+    if (!minSdkProp) {
+      props.push({
+        type: 'property',
+        key: 'android.minSdkVersion',
+        value: '26',
+      });
+    } else if (parseInt(minSdkProp.value, 10) < 26) {
+      minSdkProp.value = '26';
+    }
+
+    return config;
+  });
+
+  // Android: Pin Kotlin Gradle plugin to 2.3.0
+  // The litertlm-android AAR uses Kotlin 2.3.0 metadata (version defined in
+  // package.json → litertLm.androidMavenVersion).
+  // React Native's default Kotlin version (2.1.0) cannot read this metadata,
+  // so we must force the Kotlin Gradle plugin to 2.3.0 in the project-level
+  // build.gradle. This ensures the fix survives `expo prebuild --clean`.
+  config = withProjectBuildGradle(config, (config) => {
+    if (config.modResults.language === 'groovy') {
+      const contents = config.modResults.contents;
+
+      // Only add if not already pinned
+      if (!contents.includes("kotlin-gradle-plugin:2.3.0")) {
+        // Replace the unversioned kotlin-gradle-plugin classpath with a pinned one
+        config.modResults.contents = contents.replace(
+          "classpath('org.jetbrains.kotlin:kotlin-gradle-plugin')",
+          "classpath('org.jetbrains.kotlin:kotlin-gradle-plugin:2.3.0')"
+        );
+      }
+    }
+
+    return config;
+  });
+
+  return config;
+}
+
+module.exports = withLiteRTLM;

package/cpp/cpp-adapter.cpp

@@ -0,0 +1,21 @@
+///
+/// cpp-adapter.cpp
+/// JNI Entry Point - Required by Nitrogen to register Kotlin HybridObjects
+///
+/// Updated for react-native-nitro-modules v0.35+:
+/// Uses facebook::jni::initialize() directly with registerAllNatives().
+///
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include "LiteRTLMOnLoad.hpp"
+
+// JNI_OnLoad is called when the native library is loaded via System.loadLibrary()
+// This is where we initialize the Nitrogen bridge and register all Kotlin HybridObjects.
+// The new v0.35 API allows registering custom C++ native JNI classes/functions
+// alongside Nitrogen's auto-generated registrations.
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+    return facebook::jni::initialize(vm, []() {
+        margelo::nitro::litertlm::registerAllNatives();
+    });
+}