@gjsify/node-gi 0.64.16 → 0.64.18

package/gi-runtime-pin.js

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: MIT
+// The mixed-sysroot check of the Android GI runtime packages (ADR 0117 § 5).
+//
+// Every package that puts native GI libraries into an APK (`@gjsify/gi-runtime-android` and
+// its add-ons) ships a small manifest under `assets/app/gi-runtime/<package>.json` naming
+// the sysroot it was linked against. Two packages built against different sysroots put two
+// glib copies' worth of symbols into one process: it fails at dlopen or, worse, as a struct
+// layout mismatch far from the cause. Gradle merges both AARs without a word, so the first
+// place anything can notice is the app's own startup.
+//
+// This file is the PURE half — manifests in, a sentence out — so Node can test it. Reading
+// the manifests off the device is `readDeviceManifests`, which needs `java.io`.
+
+/** Where the manifests land, relative to the app's files dir (`assets/app/**` is extracted there). */
+export const MANIFEST_SUBDIR = 'app/gi-runtime';
+
+function pinOf(manifest) {
+    const s = manifest?.sysroot;
+    return { tag: s?.tag, sha256: s?.sha256 ?? {} };
+}
+
+/**
+ * Compare the installed packages' sysroot pins.
+ *
+ * @param {Array<{ package: string, sysroot: { tag: string, sha256: Record<string, string> } }>} manifests
+ * @returns {string | null} a sentence naming both packages, or `null` when they agree
+ */
+export function describePinMismatch(manifests) {
+    if (manifests.length < 2) return null;
+    const [first, ...rest] = [...manifests].sort((a, b) => String(a.package).localeCompare(String(b.package)));
+    const a = pinOf(first);
+    for (const other of rest) {
+        const b = pinOf(other);
+        const aWhat = `${first.package} (sysroot ${a.tag})`;
+        const bWhat = `${other.package} (sysroot ${b.tag})`;
+        if (a.tag !== b.tag) {
+            return (
+                `@gjsify/node-gi: ${aWhat} and ${bWhat} were built against different Android GI ` +
+                'sysroots; two sets of GLib/GTK libraries cannot share one process. Install the ' +
+                'same release of both packages.'
+            );
+        }
+        const abis = new Set([...Object.keys(a.sha256), ...Object.keys(b.sha256)]);
+        for (const abi of [...abis].sort()) {
+            if (a.sha256[abi] !== b.sha256[abi]) {
+                return (
+                    `@gjsify/node-gi: ${first.package} and ${other.package} both name sysroot ` +
+                    `${a.tag} but for ${abi} they disagree on its archive digest ` +
+                    `(${a.sha256[abi] ?? 'none'} vs ${b.sha256[abi] ?? 'none'}); one of them was ` +
+                    'built from a different archive. Install the same release of both packages.'
+                );
+            }
+        }
+    }
+    return null;
+}
+
+/**
+ * Read every manifest in `<filesDir>/app/gi-runtime` through `java.io` — NativeScript's own
+ * file API, not `node:fs`, which does not exist on the device.
+ *
+ * @param {string} filesDir
+ * @param {any} java the runtime's `java` global
+ * @returns {{ manifests: object[], ran: boolean }} `ran` is false when `java.io` is not exposed
+ */
+export function readDeviceManifests(filesDir, java) {
+    const io = java?.io;
+    if (!io?.File || !io?.FileInputStream || !io?.BufferedReader || !io?.InputStreamReader) {
+        return { manifests: [], ran: false };
+    }
+    const dir = new io.File(`${filesDir}/${MANIFEST_SUBDIR}`);
+    const files = dir.exists() ? dir.listFiles() : null;
+    const manifests = [];
+    if (!files) return { manifests, ran: true };
+    for (let i = 0; i < files.length; i++) {
+        const name = String(files[i].getName());
+        if (!name.endsWith('.json')) continue;
+        const reader = new io.BufferedReader(new io.InputStreamReader(new io.FileInputStream(files[i]), 'UTF-8'));
+        let text = '';
+        try {
+            for (let line = reader.readLine(); line !== null; line = reader.readLine()) text += `${line}\n`;
+        } finally {
+            reader.close();
+        }
+        try {
+            manifests.push(JSON.parse(text));
+        } catch (e) {
+            throw new Error(`@gjsify/node-gi: ${name} in ${MANIFEST_SUBDIR} is not valid JSON (${e.message}).`);
+        }
+    }
+    return { manifests, ran: true };
+}
+
+/**
+ * Throw when the installed GI runtime packages disagree on the sysroot; warn when the check
+ * could not run. Never runs without a `java` global, so Node and iOS are untouched.
+ *
+ * @param {string | null} filesDir
+ * @param {any} java
+ */
+export function checkSysrootPins(filesDir, java) {
+    if (typeof filesDir !== 'string' || filesDir === '' || !java) return;
+    const { manifests, ran } = readDeviceManifests(filesDir, java);
+    if (!ran) {
+        console.warn(
+            '@gjsify/node-gi: the mixed-sysroot check of the GI runtime packages was NOT run — ' +
+                'java.io is not exposed to this bundle.',
+        );
+        return;
+    }
+    const problem = describePinMismatch(manifests);
+    if (problem !== null) throw new Error(problem);
+}

package/host.nativescript.js

@@ -41,6 +41,8 @@
 //                           JNI_OnLoad, and without that there is no JavaVM to reach GDK
 //                           with — see ensureJavaVm().
 
+import { checkSysrootPins } from './gi-runtime-pin.js';
+
 /** @type {'nativescript'} */
 export const RUNTIME = 'nativescript';
 
@@ -375,6 +377,7 @@ export function loadNativeHost() {
     }
     const native = load('system_lib://libnode_gi.so');
     const appDir = appDirectory();
+    checkSysrootPins(appDir, globalThis.java);
     // `app/` is where NativeScript extracts the bundled assets under the files dir.
     const typelibs = globalThis.__NODE_GI_TYPELIB_PATH ?? (appDir === null ? null : `${appDir}/app/girepository-1.0`);
     if (typeof typelibs === 'string' && typelibs !== '') native.prependSearchPath(typelibs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjsify/node-gi",
-  "version": "0.64.16",
+  "version": "0.64.18",
   "description": "GObject-Introspection runtime for Node.js — load gi:// namespaces (GLib/GObject/Gio/…) with GJS-compatible semantics. Vendored + rewritten from node-gtk under MIT.",
   "type": "module",
   "license": "MIT",
@@ -51,6 +51,7 @@
     "host.node.js",
     "host.node.foreign.js",
     "host.nativescript.js",
+    "gi-runtime-pin.js",
     "nativescript.webpack.js",
     "index.d.ts",
     "gi.js",

package/src/loop.cc

@@ -219,7 +219,6 @@ static gboolean uv_source_prepare(GSource* base, gint* timeout) {
   }
 
   uv_update_time(s->loop);
-  DrainMicrotasks();
 
   gboolean alive = uv_loop_alive(s->loop);
   // Toggle whether GLib polls uv's backend fd: an unref'd-but-active uv handle
@@ -256,6 +255,28 @@ static gboolean uv_source_dispatch(GSource* base, GSourceFunc /*callback*/, gpoi
 static GSourceFuncs uv_source_funcs = {
     uv_source_prepare, nullptr, uv_source_dispatch, nullptr, nullptr, nullptr,
 };
+
+// Microtask drain, in a source of its own that is only ever PREPARED (never ready).
+// GLib prepares sources in priority order, and the drain runs JS: a source prepared
+// earlier in the same pass may hold a lock until its check() — GDK's Wayland source
+// takes libwayland's reader slot in prepare(). A microtask that then closes a window
+// runs `wl_display_roundtrip` on a slot THIS thread holds and parks forever
+// (`gtk_window_close` -> `gsk_gpu_renderer_unrealize` -> `wsi_wl_swapchain_destroy` ->
+// `wl_display_read_events`: stamped's Node GUI hung after its window closed).
+// GDK's source is prepared even ahead of G_PRIORITY_HIGH, so this one takes G_MININT:
+// it is prepared FIRST and JS runs while nothing is held. It is never dispatched, so it cannot starve GDK redraws the
+// way a high-priority uv source would (see the priority note at the uv source).
+static gboolean drain_source_prepare(GSource* /*base*/, gint* timeout) {
+  *timeout = -1;
+  if (!g_in_uv_pump) DrainMicrotasks();
+  return FALSE;
+}
+static gboolean drain_source_dispatch(GSource*, GSourceFunc, gpointer) {
+  return G_SOURCE_CONTINUE;
+}
+static GSourceFuncs drain_source_funcs = {
+    drain_source_prepare, nullptr, drain_source_dispatch, nullptr, nullptr, nullptr,
+};
 #else  // _WIN32 — the UvLoopSource, readiness-bounded timer instead of uv-backend-fd-driven.
 //
 // Windows/IOCP has no uv backend fd to embed in a GLib GSource, so the co-pump of
@@ -1168,6 +1189,10 @@ Napi::Value StartMainLoop(const Napi::CallbackInfo& info) {
   g_source_set_priority(source, G_PRIORITY_HIGH_IDLE + 30);
   g_source_attach(source, nullptr);  // default GLib main context
   g_source_unref(source);            // the context holds the surviving ref
+  GSource* drain = g_source_new(&drain_source_funcs, sizeof(GSource));
+  g_source_set_priority(drain, G_MININT);
+  g_source_attach(drain, nullptr);
+  g_source_unref(drain);
 #else  // _WIN32 — readiness-bounded UvLoopSource (no uv backend fd on IOCP).
   GSource* source = g_source_new(&uv_source_funcs, sizeof(UvLoopSource));
   UvLoopSource* s = reinterpret_cast<UvLoopSource*>(source);