@gjsify/gi-runtime-android 0.64.10 → 0.64.11

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/gi-runtime-android",
-    "version": "0.64.10",
+    "version": "0.64.11",
     "description": "NativeScript plugin that puts the GObject-Introspection runtime into an Android APK — libnode_gi.so plus the GLib/GObject/Gio closure and their typelibs, for arm64-v8a and x86_64. Add it as a dependency and @gjsify/node-gi's `requireGi` works on the device; no hand-copied .so, no jniLibs dir in App_Resources.",
     "type": "module",
     "license": "SEE LICENSE IN platforms/THIRD-PARTY-NOTICES.md",
@@ -21,9 +21,12 @@
     ],
     "nativescript": {
         "platforms": {
-            "android": "7.0.0"
+            "android": "9.1.1"
         }
     },
+    "peerDependencies": {
+        "@nativescript/android": ">=9.1.1"
+    },
     "gjsify": {
         "runtimes": {
             "gjs": "none",

package/platforms/android/gi-runtime.json

@@ -1,5 +1,5 @@
 {
-    "builtAt": "2026-10-25T11:49:58.319Z",
+    "builtAt": "2026-10-25T18:57:49.713Z",
     "abis": [
         "arm64-v8a",
         "x86_64"

package/platforms/android/include.gradle

@@ -15,11 +15,20 @@
 // is the one thing in `platforms/` that is COMMITTED, for exactly that reason — a guard
 // that ships with the payload is a guard that is missing whenever it is needed.
 //
+// A SECOND failure this turns into a gradle error is an @nativescript/android too old to
+// have Node-API: 9.1.0-alpha.6's libNativeScript.so exports ZERO `napi_*` symbols, 9.1.1
+// exports 145. libnode_gi.so links against them, so on the older runtime the APK builds,
+// installs and starts, and dies in `dlopen` with `cannot locate symbol
+// napi_create_type_error` — a message that names neither NativeScript nor a version, and
+// that cost a day's bisection in Learn6502. The floor is declared as this package's
+// peerDependency so npm warns at install time; the warning scrolls past, this does not.
+//
 // `buildscript.sourceFile` is this script's own path: `projectDir` here is the APP's, not
 // the plugin's, and hardcoding a `node_modules` path would break under `file:` links,
 // pnpm's store and a gjsify worktree alike.
 def gjsifyGiRuntimeDir = buildscript.sourceFile.parentFile
 def gjsifyGiRuntimeAar = new File(gjsifyGiRuntimeDir, 'gi-runtime-android.aar')
+def gjsifyGiRuntimeRoot = gjsifyGiRuntimeDir.parentFile.parentFile
 
 if (!gjsifyGiRuntimeAar.exists()) {
     throw new GradleException("""
@@ -42,3 +51,77 @@ has a worked invocation. An installed npm tarball always carries the AAR — thi
 only happen against a source checkout.
 """)
 }
+
+// The floor is READ from this package's own `peerDependencies`, not written here: package.json
+// is the only file that reaches an installed tarball AND carries the number (`files` ships
+// `index.js`, `index.d.ts` and `platforms/` — not `build-inputs.json`, which is where the
+// version is maintained and which a test holds equal to this range).
+def gjsifyOwnManifest = new File(gjsifyGiRuntimeRoot, 'package.json')
+def gjsifyNsFloor = null
+if (gjsifyOwnManifest.exists()) {
+    def declared = new groovy.json.JsonSlurper()
+        .parseText(gjsifyOwnManifest.getText('UTF-8'))
+        ?.peerDependencies?.get('@nativescript/android')
+    if (declared) gjsifyNsFloor = declared.replaceFirst(/^[^0-9]+/, '')
+}
+
+// `rootDir` is the GENERATED `platforms/android` project; two levels up is the app root that
+// holds `node_modules` (the same path `settings.gradle` calls USER_PROJECT_ROOT). The app's
+// resolution is the one that matters — the runtime AAR in `libs/runtime-libs` came from it —
+// so it is searched first, and a walk up from the plugin covers pnpm's nesting after that.
+def gjsifyFindNsManifest = { File from ->
+    for (File dir = from; dir != null; dir = dir.parentFile) {
+        def candidate = new File(dir, 'node_modules/@nativescript/android/package.json')
+        if (candidate.exists()) return candidate
+    }
+    return null
+}
+def gjsifyNsManifest = gjsifyFindNsManifest(new File(rootDir, '../..').canonicalFile)
+if (gjsifyNsManifest == null) gjsifyNsManifest = gjsifyFindNsManifest(gjsifyGiRuntimeRoot)
+
+// Prereleases sort BELOW their own release, which is the whole point: the runtime that broke
+// Learn6502 was 9.1.0-alpha.6, and a floor that reads it as "9.1.0, close enough" catches
+// nothing.
+def gjsifyVersionBelow = { String found, String floor ->
+    def parse = { String version ->
+        def halves = version.split('-', 2)
+        def numbers = halves[0].split(/\./).collect { it.isInteger() ? it.toInteger() : 0 }
+        while (numbers.size() < 3) numbers << 0
+        [numbers, halves.size() > 1]
+    }
+    def (foundNumbers, foundPre) = parse(found)
+    def (floorNumbers, floorPre) = parse(floor)
+    for (int i = 0; i < 3; i++) {
+        if (foundNumbers[i] != floorNumbers[i]) return foundNumbers[i] < floorNumbers[i]
+    }
+    return foundPre && !floorPre
+}
+
+// Saying "not checked" out loud is the point of the two quiet branches: a guard that fails to
+// run looks exactly like a guard that passed.
+if (gjsifyNsFloor == null) {
+    println("@gjsify/gi-runtime-android: no @nativescript/android floor in ${gjsifyOwnManifest} — NOT checked.")
+} else if (gjsifyNsManifest == null) {
+    println("@gjsify/gi-runtime-android: found no installed @nativescript/android, so its version was NOT checked against the required >= ${gjsifyNsFloor}.")
+} else {
+    def gjsifyNsVersion = new groovy.json.JsonSlurper()
+        .parseText(gjsifyNsManifest.getText('UTF-8'))?.version
+    if (gjsifyNsVersion == null) {
+        println("@gjsify/gi-runtime-android: ${gjsifyNsManifest} declares no version, so the required >= ${gjsifyNsFloor} was NOT checked.")
+    } else if (gjsifyVersionBelow(gjsifyNsVersion, gjsifyNsFloor)) {
+        throw new GradleException("""
+@nativescript/android ${gjsifyNsVersion} is too old for @gjsify/gi-runtime-android, which needs >= ${gjsifyNsFloor}.
+  resolved from: ${gjsifyNsManifest}
+
+libnode_gi.so calls Node-API, and NativeScript's libNativeScript.so is what provides it on
+Android. Runtimes before ${gjsifyNsFloor} export no `napi_*` symbols at all, so this APK would build,
+install and launch, and then abort in dlopen at the first requireGi with
+
+  cannot locate symbol "napi_create_type_error" referenced by "libnode_gi.so"
+
+— a message that names neither NativeScript nor a version. Raise the dependency in the app:
+
+  npm install --save-dev @nativescript/android@^${gjsifyNsFloor}
+""")
+    }
+}