@mentra/crust 3.3.0-dev.656 → 3.3.0-dev.658

package/README.md

@@ -31,6 +31,13 @@ core-library desugaring. Add it to the host app's Expo config:
 Building with the navigation feature requires a `MAPBOX_DOWNLOADS_TOKEN` in
 the Android build environment (Mapbox's SDK repository is authenticated).
 
+The plugin also raises the host's Android build to Kotlin 2.3.0 (crust's
+QuickJS library, `quickjs-kt` 1.0.15, is compiled with Kotlin 2.4) and pins
+the root Kotlin Gradle plugin to that version. Every native module in the
+host then compiles with Kotlin 2.3. Known incompatibility:
+`react-native-gesture-handler` before 2.31.0 fails to compile; use 2.31.0 or
+later.
+
 At build time the Android side also reads the MentraJS polyfill bundle from
 its [`@mentra/jspolyfill`](https://www.npmjs.com/package/@mentra/jspolyfill)
 sibling, which is declared as a dependency.

package/android/build.gradle

@@ -1,24 +1,5 @@
 apply plugin: 'com.android.library'
 
-// Resolve alpha13 only as a build input. Embed its Kotlin classes as a local
-// JAR so its obsolete JNI libraries never reach a consuming app transitively.
-configurations {
-  quickJsKotlinAar {
-    canBeConsumed = false
-    canBeResolved = true
-    transitive = false
-    attributes.attribute(org.gradle.api.attributes.Usage.USAGE_ATTRIBUTE,
-      objects.named(org.gradle.api.attributes.Usage, org.gradle.api.attributes.Usage.JAVA_RUNTIME))
-  }
-}
-def extractQuickJsClasses = tasks.register('extractQuickJsClasses', Sync) {
-  from({ zipTree(configurations.quickJsKotlinAar.singleFile) }) {
-    include 'classes.jar'
-    rename 'classes.jar', 'quickjs-alpha13.jar'
-  }
-  into layout.buildDirectory.dir('quickjs-kotlin')
-}
-
 group = 'com.mentra.crust'
 version = '0.1.0'
 
@@ -69,17 +50,6 @@ android {
     versionCode 1
     versionName "0.1.0"
     multiDexEnabled true
-    // Preserve alpha13's JNI class names when consuming apps enable R8.
-    consumerProguardFiles 'quickjs-consumer-rules.pro'
-    externalNativeBuild {
-      cmake { arguments '-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON' }
-    }
-  }
-  externalNativeBuild {
-    cmake {
-      path 'src/main/cpp/quickjs/CMakeLists.txt'
-      version '3.22.1'
-    }
   }
   // Pull the MentraJS polyfill bundle from the sibling @mentra/jspolyfill
   // module's `assets/` directory — single committed source of truth. The
@@ -155,14 +125,10 @@ dependencies {
   // for installing Kotlin lambdas as JS globals via `JS_SetPropertyStr`.
   // Mirrors iOS Apple JSC's `setObject(_, forKeyedSubscript:)` pattern.
   //
-  // Version pin: this Expo SDK 55 build uses Kotlin 2.1.20, which can read
-  // metadata up to 2.2.0. dokar3 1.0.1+ ships classes with metadata 2.3.0
-  // (compiled with Kotlin 2.3.x) and is unreadable here. 1.0.0-alpha13 is
-  // the last release compiled with Kotlin 2.0 (metadata 2.0.0) — its API
-  // (`QuickJs.create`, `evaluate`, `function` extension) matches 1.0.5 1:1.
-  // Bump only when the host Kotlin compiler clears 2.3.0 metadata.
-  quickJsKotlinAar 'io.github.dokar3:quickjs-kt-android:1.0.0-alpha13'
-  implementation files(layout.buildDirectory.file('quickjs-kotlin/quickjs-alpha13.jar')).builtBy(extractQuickJsClasses)
+  // 1.0.15 is compiled with Kotlin 2.4.10. The crust config plugin raises the
+  // host to Kotlin 2.3.0, which reads one metadata version ahead. The AAR ships
+  // its own 16 KB-aligned JNI libraries and R8 keep rules.
+  implementation 'io.github.dokar3:quickjs-kt-android:1.0.15'
 
   // OkHttp for fetch / WebSocket — already used elsewhere in MentraOS;
   // pinned here so the gradle plugin doesn't downgrade us.
@@ -175,8 +141,8 @@ dependencies {
 
   // Kotlin coroutines: dokar3's `evaluate()` is suspend; we bridge it via
   // `runBlocking(dispatcher)` from the per-miniapp single-thread executor.
-  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.1'
-  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.1'
+  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.11.0'
+  implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.11.0'
 }
 
 // Notification lifecycle tests run against Android APIs without a device.
@@ -184,3 +150,12 @@ dependencies {
   testImplementation 'junit:junit:4.13.2'
   testImplementation 'org.robolectric:robolectric:4.11.1'
 }
+
+// A desktop JVM cannot load the Android QuickJS library, so local unit tests
+// run the same QuickJS build through its desktop JVM artifact.
+configurations.matching { it.name.endsWith('UnitTestRuntimeClasspath') }.configureEach {
+  resolutionStrategy.dependencySubstitution {
+    substitute(module('io.github.dokar3:quickjs-kt-android'))
+      .using(module('io.github.dokar3:quickjs-kt-jvm:1.0.15'))
+  }
+}

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

@@ -293,10 +293,10 @@ class JSCRuntime private constructor(private val appContext: Context) {
                 runBlocking {
                     installGlobals(qjs, packageName)
                     if (bundle.isNotEmpty()) {
-                        qjs.evaluate<Any?>(bundle, filename = "mentrajs:startup.js")
+                        qjs.evaluateForEffect(bundle, filename = "mentrajs:startup.js")
                     }
                     if (miniappJs.isNotEmpty()) {
-                        qjs.evaluate<Any?>(miniappJs, filename = "mentrajs:miniapp.js")
+                        qjs.evaluateForEffect(miniappJs, filename = "mentrajs:miniapp.js")
                     }
                 }
                 Log.i(TAG, "spawned $packageName")
@@ -420,7 +420,7 @@ class JSCRuntime private constructor(private val appContext: Context) {
                 record.executor.submit {
                     runBlocking {
                         try {
-                            record.qjs.evaluate<Any?>(
+                            record.qjs.evaluateForEffect(
                                 "globalThis.__deliverTimer && globalThis.__deliverTimer($token);",
                                 filename = "mentrajs:timer-$token.js",
                             )
@@ -511,7 +511,7 @@ class JSCRuntime private constructor(private val appContext: Context) {
                 try {
                     val source = "globalThis.__deliver(${jsStringLiteral(envelopeJson)});"
                     runBlocking {
-                        record.qjs.evaluate<Any?>(source, filename = "mentrajs:deliver.js")
+                        record.qjs.evaluateForEffect(source, filename = "mentrajs:deliver.js")
                     }
                 } catch (e: Throwable) {
                     failure = e
@@ -590,6 +590,15 @@ class JSCRuntime private constructor(private val appContext: Context) {
 
     // ------------------------------------------------------------------
 
+    /**
+     * Evaluate for side effects. A completion value is never converted to
+     * Kotlin: quickjs-kt 1.0.15 hangs converting a Set, Map or array that
+     * contains itself, and miniapp code chooses its bundle's last value.
+     */
+    private suspend fun QuickJs.evaluateForEffect(source: String, filename: String) {
+        evaluate<Any?>("$source\n;undefined", filename = filename)
+    }
+
     private fun parseArgsEnvelope(argsJson: String): Pair<List<Any?>, String?> {
         return try {
             if (argsJson.startsWith("{")) {

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

@@ -0,0 +1,87 @@
+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
+import org.junit.Assert.*
+import org.junit.Test
+
+/**
+ * Runs the real QuickJS JNI library (through the desktop JVM artifact, see
+ * build.gradle) the way [JSCRuntime] uses it: one instance per miniapp, Kotlin
+ * bindings called from JS, and independent close orders.
+ */
+class QuickJsLifecycleTest {
+    private fun create() = QuickJs.create(Dispatchers.Unconfined)
+
+    @Test fun `closing one instance keeps another instance's callbacks working`() = runBlocking {
+        var calls = 0
+        val survivor = create()
+        survivor.function("hostCallback") { calls++; 42 }
+        val other = create()
+        assertEquals(42, survivor.evaluate<Int>("hostCallback()"))
+        other.close()
+        withTimeout(1000) { assertEquals(42, survivor.evaluate<Int>("hostCallback()")) }
+        assertEquals(2, calls)
+        repeat(20) {
+            create().close()
+            assertEquals(42, survivor.evaluate<Int>("hostCallback()"))
+        }
+        val workers = Executors.newFixedThreadPool(4)
+        try {
+            (1..40).map { workers.submit { create().close() } }.forEach { it.get() }
+            assertEquals(42, survivor.evaluate<Int>("hostCallback()"))
+        } finally {
+            workers.shutdownNow()
+        }
+        survivor.close()
+        val fresh = create()
+        fresh.function("hostCallback") { 7 }
+        assertEquals(7, fresh.evaluate<Int>("hostCallback()"))
+        fresh.close()
+        val older = create()
+        val newer = create()
+        newer.function("hostCallback") { 9 }
+        older.close()
+        assertEquals(9, newer.evaluate<Int>("hostCallback()"))
+        newer.close()
+    }
+
+    @Test fun `a binding exception is a catchable JS Error carrying the message`() = runBlocking {
+        val qjs = create()
+        qjs.function("__dispatch") { throw MentraJSDispatchError("INVALID_ARGS", "iface") }
+        val caught = qjs.evaluate<String>(
+            "try { __dispatch(); 'no throw' } catch (e) { (e instanceof Error) + '|' + e.message }",
+        )
+        assertEquals("true|INVALID_ARGS: iface", caught)
+        qjs.close()
+    }
+
+    @Test fun `non-ASCII strings cross the bridge unchanged`() = runBlocking {
+        val text = "héllo 😀 中文 \u0000 end"
+        var received: String? = null
+        val qjs = create()
+        qjs.function("hostText") { text }
+        qjs.function("hostEcho") { args -> received = args[0] as String; args[0] }
+        assertEquals(text, qjs.evaluate<String>("hostEcho(hostText())"))
+        assertEquals(text, received)
+        qjs.close()
+    }
+
+    @Test fun `unusual thrown values fail as exceptions, not crashes`() = runBlocking {
+        val qjs = create()
+        for (source in listOf("throw undefined", "throw null", "throw new Error('%s%n%s%n')")) {
+            try {
+                qjs.evaluate<Any?>(source)
+                fail("$source did not throw")
+            } catch (_: QuickJsException) {
+            }
+            assertEquals(2, qjs.evaluate<Int>("1 + 1"))
+        }
+        qjs.close()
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/crust",
-  "version": "3.3.0-dev.656",
+  "version": "3.3.0-dev.658",
   "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.3.0-dev.656"
+    "@mentra/jspolyfill": "3.3.0-dev.658"
   },
   "devDependencies": {
     "@expo/config-plugins": ">=8.0.0",

package/plugin/build/index.d.ts

@@ -14,6 +14,8 @@ import { type ConfigPlugin } from "expo/config-plugins";
  *   both fails the release build with duplicate classes)
  * - core-library desugaring (crust's AAR metadata requires it of embedding
  *   apps — the Nav SDK uses newer core libs)
+ * - Kotlin 2.3.0 or newer, with the root Kotlin Gradle plugin pinned to it
+ *   (crust's QuickJS library, quickjs-kt 1.0.15, is compiled with Kotlin 2.4)
  * - a generated MainApplication process guard so the notification-listener
  *   process never initializes React Native
  * - iOS Mapbox Swift Package products and the Crust build-order dependency

package/plugin/build/index.js

@@ -21,6 +21,8 @@ const withMapboxNavIos_1 = __importDefault(require("./withMapboxNavIos"));
  *   both fails the release build with duplicate classes)
  * - core-library desugaring (crust's AAR metadata requires it of embedding
  *   apps — the Nav SDK uses newer core libs)
+ * - Kotlin 2.3.0 or newer, with the root Kotlin Gradle plugin pinned to it
+ *   (crust's QuickJS library, quickjs-kt 1.0.15, is compiled with Kotlin 2.4)
  * - a generated MainApplication process guard so the notification-listener
  *   process never initializes React Native
  * - iOS Mapbox Swift Package products and the Crust build-order dependency

package/plugin/build/withAndroid.js

@@ -20,12 +20,50 @@ const MAPBOX_REPO = [
     "      }",
     "    }",
 ].join("\n");
+// quickjs-kt 1.0.15 is compiled with Kotlin 2.4, and a Kotlin compiler reads
+// metadata one version ahead. 2.3.0 is the newest 2.3 release Expo SDK 55's
+// root plugin maps to a KSP version.
+const MIN_KOTLIN_VERSION = "2.3.0";
+// The template's unversioned classpath entry resolves to the Kotlin Gradle
+// plugin React Native's Gradle plugin depends on (2.1.20 on RN 0.83), whatever
+// `android.kotlinVersion` says; Expo fixes that only in SDK 58
+// (expo/expo#49668). SDK 56 also never copies the property into Expo's catalog,
+// so pin both the compiler and the root `kotlinVersion` to the property itself.
+const UNVERSIONED_KOTLIN_PLUGIN = "classpath('org.jetbrains.kotlin:kotlin-gradle-plugin')";
+const PINNED_KOTLIN_PLUGIN = `classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:\${findProperty('android.kotlinVersion')}")`;
+const KOTLIN_VERSION_MARKER = "kotlinVersion from android.kotlinVersion (injected by @mentra/crust)";
+const EXPO_ROOT_PROJECT = 'apply plugin: "expo-root-project"';
+function isOlderVersion(version, minimum) {
+    const actual = version.split(".").map(Number);
+    const required = minimum.split(".").map(Number);
+    for (let i = 0; i < required.length; i++) {
+        if ((actual[i] ?? 0) !== required[i])
+            return (actual[i] ?? 0) < required[i];
+    }
+    return false;
+}
+function withCrustKotlinVersion(config) {
+    return (0, config_plugins_1.withGradleProperties)(config, (cfg) => {
+        const property = cfg.modResults.find((item) => item.type === "property" && item.key === "android.kotlinVersion");
+        if (property?.type !== "property") {
+            cfg.modResults.push({ type: "property", key: "android.kotlinVersion", value: MIN_KOTLIN_VERSION });
+        }
+        else if (isOlderVersion(property.value, MIN_KOTLIN_VERSION)) {
+            property.value = MIN_KOTLIN_VERSION;
+        }
+        return cfg;
+    });
+}
 const PROTOBUF_EXCLUDE = "exclude group: 'com.google.protobuf', module: 'protobuf-javalite'";
 const NOTIFICATION_PROCESS_GUARD = "crust: skip React Native in notification process";
 const NOTIFICATION_CONFIG_GUARD = "crust: skip Expo lifecycle in notification process";
 function withCrustProjectGradle(config) {
     return (0, config_plugins_1.withProjectBuildGradle)(config, (cfg) => {
         let gradle = cfg.modResults.contents;
+        gradle = gradle.replace(UNVERSIONED_KOTLIN_PLUGIN, PINNED_KOTLIN_PLUGIN);
+        if (!gradle.includes(KOTLIN_VERSION_MARKER)) {
+            gradle = gradle.replace(EXPO_ROOT_PROJECT, `// ${KOTLIN_VERSION_MARKER}\next.kotlinVersion = findProperty('android.kotlinVersion')\n${EXPO_ROOT_PROJECT}`);
+        }
         // Mapbox Downloads repo, inserted at the top of allprojects.repositories.
         if (!gradle.includes(MAPBOX_REPO_MARKER)) {
             const reposMatch = gradle.match(/allprojects\s*\{[\s\S]*?repositories\s*\{/);
@@ -129,6 +167,7 @@ function withNotificationProcessGuard(config) {
     });
 }
 const withCrustAndroidBuildContract = (config) => {
+    config = withCrustKotlinVersion(config);
     config = withCrustProjectGradle(config);
     config = withCrustAppGradle(config);
     return withNotificationProcessGuard(config);

package/android/quickjs-consumer-rules.pro

@@ -1,6 +0,0 @@
--keep,allowoptimization class com.dokar.quickjs.QuickJs { *; }
--keep,allowoptimization class com.dokar.quickjs.QuickJsException { *; }
--keep,allowoptimization class com.dokar.quickjs.binding.JsProperty { *; }
--keep,allowoptimization class com.dokar.quickjs.binding.JsFunction { *; }
--keep,allowoptimization class com.dokar.quickjs.binding.JsObject { *; }
--keep,allowoptimization class kotlin.UByteArray

package/android/scripts/test-quickjs-lifecycle.py

@@ -1,45 +0,0 @@
-#!/usr/bin/env python3
-"""Compile and test real JNI on Linux; run only when native builds are authorized."""
-import os
-from pathlib import Path
-import subprocess
-import tempfile
-import zipfile
-
-android = Path(__file__).resolve().parents[1]
-cache = Path(os.environ.get("GRADLE_USER_HOME", str(Path.home() / ".gradle"))) / "caches/modules-2/files-2.1"
-
-
-def artifact(group, name, version, extension="jar"):
-    # Classifier artifacts such as -sources.jar share the version directory.
-    matches = [path for path in (cache / group / name / version).glob(f"*/*.{extension}")
-               if not path.stem.endswith(("-sources", "-javadoc"))]
-    if not matches:
-        raise SystemExit(f"Missing cached {group}:{name}:{version}; resolve Android dependencies first.")
-    return matches[0]
-
-
-with tempfile.TemporaryDirectory(prefix="mentra-quickjs-test-") as directory:
-    output = Path(directory)
-    native = output / "native"
-    subprocess.run(["cmake", "-S", str(android / "src/main/cpp/quickjs"), "-B", str(native),
-                    "-G", "Ninja", "-DCMAKE_BUILD_TYPE=Release"], check=True)
-    subprocess.run(["cmake", "--build", str(native), "-j", "2"], check=True)
-    aar = artifact("io.github.dokar3", "quickjs-kt-android", "1.0.0-alpha13", "aar")
-    with zipfile.ZipFile(aar) as archive:
-        (output / "quickjs.jar").write_bytes(archive.read("classes.jar"))
-    runtime = [output / "quickjs.jar",
-               artifact("org.jetbrains.kotlin", "kotlin-stdlib", "2.1.20"),
-               artifact("org.jetbrains.kotlinx", "kotlinx-coroutines-core-jvm", "1.8.1"),
-               artifact("androidx.annotation", "annotation-jvm", "1.9.1"),
-               artifact("org.jetbrains", "annotations", "23.0.0")]
-    compiler = runtime + [artifact("org.jetbrains.kotlin", "kotlin-compiler-embeddable", "2.1.20"),
-                          artifact("org.jetbrains.intellij.deps", "trove4j", "1.0.20200330")]
-    classpath = os.pathsep.join(map(str, runtime))
-    subprocess.run(["java", "-cp", os.pathsep.join(map(str, compiler)),
-                    "org.jetbrains.kotlin.cli.jvm.K2JVMCompiler", "-no-stdlib", "-no-reflect",
-                    "-jvm-target", "17", "-classpath", classpath, "-d", str(output / "classes"),
-                    str(android / "src/testNative/QuickJsLifecycleTest.kt")], check=True)
-    subprocess.run(["java", f"-Djava.library.path={native}", "-cp",
-                    str(output / "classes") + os.pathsep + classpath,
-                    "com.mentra.crust.jsc.QuickJsLifecycleTestKt"], check=True, timeout=30)

package/android/src/main/cpp/quickjs/CMakeLists.txt

@@ -1,20 +0,0 @@
-cmake_minimum_required(VERSION 3.22.1)
-project(mentra_quickjs C)
-set(CMAKE_C_STANDARD 99)
-file(READ "engine/VERSION" QUICKJS_VERSION)
-string(STRIP "${QUICKJS_VERSION}" QUICKJS_VERSION)
-file(GLOB JNI_SOURCES CONFIGURE_DEPENDS "jni/*.c" "jni/mapping/*.c")
-add_library(quickjs SHARED
-  engine/cutils.c engine/libbf.c engine/libregexp.c engine/libunicode.c
-  engine/quickjs.c common/quickjs_version.c ${JNI_SOURCES})
-target_include_directories(quickjs PRIVATE engine common c-vector jni jni/mapping)
-target_compile_definitions(quickjs PRIVATE CONFIG_BIGNUM CONFIG_VERSION="${QUICKJS_VERSION}")
-if(ANDROID)
-  target_compile_definitions(quickjs PRIVATE CONFIG_ANDROID)
-  target_link_libraries(quickjs PRIVATE log m)
-  target_link_options(quickjs PRIVATE "-Wl,-z,max-page-size=16384")
-else()
-  find_package(JNI REQUIRED)
-  target_include_directories(quickjs PRIVATE ${JNI_INCLUDE_DIRS})
-  target_link_libraries(quickjs PRIVATE pthread m)
-endif()

package/android/src/main/cpp/quickjs/LICENSE.quickjs-kt.txt

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2015 Anton Lopyrev
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

package/android/src/main/cpp/quickjs/README.md

@@ -1,30 +0,0 @@
-# QuickJS JNI lifetime backport
-
-The Kotlin API remains on `io.github.dokar3:quickjs-kt-android:1.0.0-alpha13` to
-preserve compatibility with Kotlin 2.1.20. Crust builds this native source for
-Android. A private build-input configuration extracts the original AAR's
-`classes.jar`. Crust embeds this JAR, preserving Kotlin metadata, while only its
-source-built JNI library reaches consuming apps. `quickjs-consumer-rules.pro` in
-the Android module preserves the original AAR's R8 rules so JNI class names remain
-valid in minified builds. Do not use `pickFirst` to choose between libraries.
-
-Source provenance (licenses accompany each source):
-
-- `jni/`, `common/`: quickjs-kt commit `d2fefdc451678d09bbef5526c3b00f12e41cd5cf`.
-- `engine/`: Bellard QuickJS commit `36911f0d3ab1a4c190a4d5cbe7c2db225a455389`, alpha13's submodule pin; only required build inputs.
-- `c-vector/`: alpha13 submodule pin `774773d4cb1e66dd736e90e7f482d4f22af464c6`.
-
-Upstream source changes are confined to `jni/jni_globals.{c,h}` and
-`jni/quickjs_jni.c`. They backport the shared-resource lifetime fix from
-[4a003f6](https://github.com/dokar3/quickjs-kt/commit/4a003f64b1d5e608df1768e6c1a743b603434e10).
-A mutex synchronizes VM initialization, instance counts and final cache disposal. Shared caches remain valid until the final instance closes.
-
-Shared-resource lifetime is unconditional; there is no setting or native toggle.
-A native Android rebuild is required. iOS does not use this JNI library.
-
-Run the Linux integration test with
-`python3 mobile/modules/crust/android/scripts/test-quickjs-lifecycle.py` from the
-repository root. It requires JDK 17, CMake/Ninja and cached Gradle dependencies.
-It compiles the real JNI library and exercises Kotlin callbacks across both
-close orders, sequential/concurrent teardown and clean restart. Plain JavaScript
-arithmetic is insufficient: this regression requires a callback into Kotlin.