@mentra/crust 3.5.0-dev.1239 → 3.5.0-dev.1242

package/android/src/main/java/com/mentra/crust/jsc/JSCRuntime.kt

@@ -262,9 +262,11 @@ class JSCRuntime private constructor(private val appContext: Context) {
         // anyway, so this is safe.
         val qjs = try {
             executor.submit<QuickJs> {
-                QuickJs.create(Dispatchers.Unconfined).apply {
-                    memoryLimit = 32L * 1024 * 1024     // 32 MB heap per miniapp
-                    maxStackSize = 512L * 1024          // 512 KB stack
+                QuickJsNativeLifecycle.withNative {
+                    QuickJs.create(Dispatchers.Unconfined).apply {
+                        memoryLimit = 32L * 1024 * 1024     // 32 MB heap per miniapp
+                        maxStackSize = 512L * 1024          // 512 KB stack
+                    }
                 }
             }.get()
         } catch (e: Throwable) {
@@ -575,7 +577,7 @@ class JSCRuntime private constructor(private val appContext: Context) {
         try {
             record.executor.submit {
                 try {
-                    record.qjs.close()
+                    QuickJsNativeLifecycle.withNative { record.qjs.close() }
                 } catch (e: Throwable) {
                     Log.w(TAG, "QuickJs.close() threw for $packageName: ${e.message}")
                 }

package/android/src/main/java/com/mentra/crust/jsc/QuickJsNativeLifecycle.kt

@@ -0,0 +1,16 @@
+package com.mentra.crust.jsc
+
+/**
+ * quickjs-kt 1.0.15 keeps one process-wide JavaVM and an instance counter.
+ * Neither update is atomic. Two miniapps creating or closing at the same time
+ * can drop that VM while another context is still open, and the next call
+ * logs "Cannot get jni env because the vm is not cached".
+ *
+ * Every [com.dokar.quickjs.QuickJs.create] and [com.dokar.quickjs.QuickJs.close]
+ * in this process goes through [withNative]. Evaluation stays outside the lock.
+ */
+internal object QuickJsNativeLifecycle {
+    private val lock = Any()
+
+    fun <T> withNative(block: () -> T): T = synchronized(lock) { block() }
+}

package/android/src/test/java/com/mentra/crust/jsc/QuickJsLifecycleTest.kt

@@ -3,7 +3,6 @@ package com.mentra.crust.jsc
 import com.dokar.quickjs.QuickJs
 import com.dokar.quickjs.QuickJsException
 import com.dokar.quickjs.binding.function
-import java.util.concurrent.Executors
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withTimeout
@@ -16,7 +15,11 @@ import org.junit.Test
  * bindings called from JS, and independent close orders.
  */
 class QuickJsLifecycleTest {
-    private fun create() = QuickJs.create(Dispatchers.Unconfined)
+    private fun create() = QuickJsNativeLifecycle.withNative {
+        QuickJs.create(Dispatchers.Unconfined)
+    }
+
+    private fun QuickJs.release() = QuickJsNativeLifecycle.withNative { close() }
 
     @Test fun `closing one instance keeps another instance's callbacks working`() = runBlocking {
         var calls = 0
@@ -24,31 +27,31 @@ class QuickJsLifecycleTest {
         survivor.function("hostCallback") { calls++; 42 }
         val other = create()
         assertEquals(42, survivor.evaluate<Int>("hostCallback()"))
-        other.close()
+        other.release()
         withTimeout(1000) { assertEquals(42, survivor.evaluate<Int>("hostCallback()")) }
         assertEquals(2, calls)
         repeat(20) {
-            create().close()
+            create().release()
             assertEquals(42, survivor.evaluate<Int>("hostCallback()"))
         }
-        val workers = Executors.newFixedThreadPool(4)
+        val workers = java.util.concurrent.Executors.newFixedThreadPool(4)
         try {
-            (1..40).map { workers.submit { create().close() } }.forEach { it.get() }
+            (1..40).map { workers.submit { create().release() } }.forEach { it.get() }
             assertEquals(42, survivor.evaluate<Int>("hostCallback()"))
         } finally {
             workers.shutdownNow()
         }
-        survivor.close()
+        survivor.release()
         val fresh = create()
         fresh.function("hostCallback") { 7 }
         assertEquals(7, fresh.evaluate<Int>("hostCallback()"))
-        fresh.close()
+        fresh.release()
         val older = create()
         val newer = create()
         newer.function("hostCallback") { 9 }
-        older.close()
+        older.release()
         assertEquals(9, newer.evaluate<Int>("hostCallback()"))
-        newer.close()
+        newer.release()
     }
 
     @Test fun `a binding exception is a catchable JS Error carrying the message`() = runBlocking {
@@ -58,7 +61,7 @@ class QuickJsLifecycleTest {
             "try { __dispatch(); 'no throw' } catch (e) { (e instanceof Error) + '|' + e.message }",
         )
         assertEquals("true|INVALID_ARGS: iface", caught)
-        qjs.close()
+        qjs.release()
     }
 
     @Test fun `non-ASCII strings cross the bridge unchanged`() = runBlocking {
@@ -69,7 +72,7 @@ class QuickJsLifecycleTest {
         qjs.function("hostEcho") { args -> received = args[0] as String; args[0] }
         assertEquals(text, qjs.evaluate<String>("hostEcho(hostText())"))
         assertEquals(text, received)
-        qjs.close()
+        qjs.release()
     }
 
     @Test fun `unusual thrown values fail as exceptions, not crashes`() = runBlocking {
@@ -82,6 +85,6 @@ class QuickJsLifecycleTest {
             }
             assertEquals(2, qjs.evaluate<Int>("1 + 1"))
         }
-        qjs.close()
+        qjs.release()
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/crust",
-  "version": "3.5.0-dev.1239",
+  "version": "3.5.0-dev.1242",
   "description": "Mentra Native Module",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -35,7 +35,7 @@
   "license": "Apache-2.0",
   "homepage": "https://github.com/Mentra-Community/MentraOS/tree/dev/mobile/modules/crust#readme",
   "dependencies": {
-    "@mentra/jspolyfill": "3.5.0-dev.1239"
+    "@mentra/jspolyfill": "3.5.0-dev.1242"
   },
   "devDependencies": {
     "@expo/config-plugins": ">=8.0.0",