@gjsify/node-gi 0.32.0 → 0.34.0

package/gtk-runtime.js

@@ -426,6 +426,35 @@ export function maybeWireGtkWindowingEnv() {
         setIfUnset('FONTCONFIG_PATH', join(bundle.dir, 'etc', 'fonts'));
         setIfUnset('FONTCONFIG_FILE', fontsConf);
     }
+
+    // GStreamer, which finds its plugins the way GTK finds its schemas: by env,
+    // read at init. Without this the bundle can ship every Gst typelib and still
+    // play nothing — `Gst.init()` succeeds against an EMPTY registry, so the
+    // failure surfaces far away as "no element decodebin" rather than as a missing
+    // library. That is the same shape as the 0.27.1 bundles, which carried
+    // `Adw-1.typelib` with no libadwaita behind it.
+    //
+    // SYSTEM_PATH, not GST_PLUGIN_PATH: the latter is the USER's additive override
+    // and the bundle has no business consuming it. SYSTEM_PATH also suppresses the
+    // compiled-in default, which is what we want — that default is the build
+    // machine's prefix, and on a user's box it is either absent or, worse, a
+    // foreign GStreamer whose plugins would be mixed with the bundle's.
+    const gstPlugins = join(bundle.dir, 'lib', 'gstreamer-1.0');
+    if (existsSync(gstPlugins)) {
+        setIfUnset('GST_PLUGIN_SYSTEM_PATH', gstPlugins);
+        // The scanner is a separate EXECUTABLE that GStreamer forks to inspect each
+        // plugin out-of-process, so a plugin that crashes on load cannot take the
+        // app with it. Its compiled-in path is the build machine's too, so without
+        // this GStreamer silently degrades to in-process scanning — which works,
+        // until the first bad plugin takes the process down instead of itself.
+        const scanner = join(bundle.dir, 'libexec', 'gstreamer-1.0', gstScannerLeaf());
+        if (existsSync(scanner)) setIfUnset('GST_PLUGIN_SCANNER', scanner);
+    }
+}
+
+/** The plugin scanner's leaf name — the bundles ship the same tree on both OSes. */
+function gstScannerLeaf() {
+    return process.platform === 'win32' ? 'gst-plugin-scanner.exe' : 'gst-plugin-scanner';
 }
 
 let activated = null; // memoize: the activation result (idempotent)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjsify/node-gi",
-  "version": "0.32.0",
+  "version": "0.34.0",
   "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",

package/src/template.cc

@@ -5,67 +5,102 @@
 
 namespace nodegi {
 
+namespace {
+
+// The GTK 4 shared library, opened by leaf name. THREE things vary per OS and
+// nothing else does, so only those three are spelled per-OS — the symbol table in
+// the function below is written once and both sides run it.
+//
+// The LEAF NAME is what has bitten, twice. Hardcoding the ELF soname made the
+// whole composite-template API unavailable on macOS: `libgtk-4.so.1` does not
+// exist there, so every `registerClass({ Template })` widget failed with "the
+// libgtk-4 template API is unavailable" on a host with GTK 4 correctly installed.
+// Invisible until v0.27.0 shipped the first darwin-x64 addon.
+#if defined(_WIN32)
+// gvsbuild's leaf — what @gjsify/gtk-runtime-win32-x64 ships — then MSYS2's
+// `lib`-prefixed spelling.
+constexpr const char* kGtkLeaves[] = {"gtk-4-1.dll", "libgtk-4-1.dll"};
+using LibHandle = HMODULE;
+
+// The counterpart of RTLD_NOLOAD, and it is load-bearing rather than an
+// optimisation: `requireGi('Gtk','4.0')` has already loaded the DLL through the
+// typelib's shared_library field, and asking for a handle to THAT copy is what
+// keeps this from pulling a second GTK off PATH.
+inline LibHandle OpenAlreadyLoaded(const char* leaf) { return GetModuleHandleA(leaf); }
+inline LibHandle OpenLibrary(const char* leaf) { return LoadLibraryA(leaf); }
+inline void* FindSymbol(LibHandle lib, const char* name) {
+  return reinterpret_cast<void*>(GetProcAddress(lib, name));
+}
+#else
+#if defined(__APPLE__)
+constexpr const char* kGtkLeaves[] = {"libgtk-4.1.dylib", "libgtk-4.dylib"};
+#else
+constexpr const char* kGtkLeaves[] = {"libgtk-4.so.1", "libgtk-4.so"};
+#endif
+using LibHandle = void*;
+
+// RTLD_NOLOAD first — requireGi('Gtk','4.0') already dlopened libgtk-4 via the
+// typelib, so this only bumps the refcount; the plain dlopen behind it serves a
+// caller that never required Gtk through the typelib.
+inline LibHandle OpenAlreadyLoaded(const char* leaf) {
+  return dlopen(leaf, RTLD_LAZY | RTLD_NOLOAD);
+}
+inline LibHandle OpenLibrary(const char* leaf) { return dlopen(leaf, RTLD_LAZY); }
+inline void* FindSymbol(LibHandle lib, const char* name) { return dlsym(lib, name); }
+#endif
+
+}  // namespace
+
 // Resolve the GTK template API once (C++11 function-local static init is
-// thread-safe; node-gi calls these only on the main thread). How the library
-// handle is obtained — and why the leaf name has to be per-OS — is documented at
-// the dlopen below.
+// thread-safe; node-gi calls these only on the main thread).
+//
+// WINDOWS USED TO BE A STUB HERE — an `#ifdef _WIN32 → return &api` leaving
+// `api.ok` false, on the reasoning that "GTK on Windows is Phase 2". The
+// reasoning went stale without the stub noticing: the `--windowing` runtime
+// bundle now ships GTK and libadwaita for win32-x64 and CI renders the whole
+// Libadwaita gallery on it, while `gjsify showcase three-geometry-teapot
+// --runtime node` still died on Windows with "the libgtk-4 template API is
+// unavailable" — on a machine where GTK 4 was present and working. Nothing was
+// missing but these nine symbols.
+//
+// Same lesson as the macOS soname bug, from the other side: a per-OS branch that
+// cannot be EXECUTED anywhere is not a conservative default, it is an untested
+// claim. So this function has no OS branch left — only a per-OS loader above it.
 const GtkTemplateApi* GetGtkTemplateApi() {
   static GtkTemplateApi api = {};
   static bool initialised = false;
   if (initialised) return &api;
   initialised = true;
-#ifdef _WIN32
-  // The Gtk.Widget composite-template API is resolved lazily via dlsym on POSIX
-  // only. GTK on Windows is Phase 2; the Phase-1 Windows CI proves the display-
-  // free core, which never exercises templates. api.ok stays false → template
-  // callers warn + no-op / throw a clear "template API unavailable" error.
-  return &api;
-#else
-  // The library's LEAF NAME IS PER-OS, and hardcoding the ELF soname made the
-  // whole composite-template API unavailable on macOS: `libgtk-4.so.1` does not
-  // exist there, so every `registerClass({ Template })` widget failed with
-  // "the libgtk-4 template API is unavailable" on a host with GTK 4 correctly
-  // installed. Invisible until v0.27.0 shipped the first darwin-x64 addon.
-  //
-  // Candidates are the leaf names GTK 4 actually installs, newest ABI first.
-#ifdef __APPLE__
-  static const char* const kGtkLeaves[] = {"libgtk-4.1.dylib", "libgtk-4.dylib"};
-#else
-  static const char* const kGtkLeaves[] = {"libgtk-4.so.1", "libgtk-4.so"};
-#endif
-  void* lib = nullptr;
+
+  LibHandle lib = nullptr;
   for (const char* leaf : kGtkLeaves) {
-    // RTLD_NOLOAD first — requireGi('Gtk','4.0') already dlopened libgtk-4 via the
-    // typelib, so this only bumps the refcount; the plain dlopen behind it serves a
-    // caller that never required Gtk through the typelib.
-    lib = dlopen(leaf, RTLD_LAZY | RTLD_NOLOAD);
-    if (lib == nullptr) lib = dlopen(leaf, RTLD_LAZY);
+    lib = OpenAlreadyLoaded(leaf);
+    if (lib == nullptr) lib = OpenLibrary(leaf);
     if (lib != nullptr) break;
   }
   if (lib == nullptr) return &api;  // api.ok stays false → callers warn + no-op
   api.set_template = reinterpret_cast<decltype(api.set_template)>(
-      dlsym(lib, "gtk_widget_class_set_template"));
+      FindSymbol(lib, "gtk_widget_class_set_template"));
   api.set_template_from_resource = reinterpret_cast<decltype(api.set_template_from_resource)>(
-      dlsym(lib, "gtk_widget_class_set_template_from_resource"));
+      FindSymbol(lib, "gtk_widget_class_set_template_from_resource"));
   api.bind_template_child_full = reinterpret_cast<decltype(api.bind_template_child_full)>(
-      dlsym(lib, "gtk_widget_class_bind_template_child_full"));
-  api.set_css_name =
-      reinterpret_cast<decltype(api.set_css_name)>(dlsym(lib, "gtk_widget_class_set_css_name"));
+      FindSymbol(lib, "gtk_widget_class_bind_template_child_full"));
+  api.set_css_name = reinterpret_cast<decltype(api.set_css_name)>(
+      FindSymbol(lib, "gtk_widget_class_set_css_name"));
   api.init_template =
-      reinterpret_cast<decltype(api.init_template)>(dlsym(lib, "gtk_widget_init_template"));
+      reinterpret_cast<decltype(api.init_template)>(FindSymbol(lib, "gtk_widget_init_template"));
   api.get_template_child = reinterpret_cast<decltype(api.get_template_child)>(
-      dlsym(lib, "gtk_widget_get_template_child"));
+      FindSymbol(lib, "gtk_widget_get_template_child"));
   api.set_template_scope = reinterpret_cast<decltype(api.set_template_scope)>(
-      dlsym(lib, "gtk_widget_class_set_template_scope"));
+      FindSymbol(lib, "gtk_widget_class_set_template_scope"));
   api.builder_get_current_object = reinterpret_cast<decltype(api.builder_get_current_object)>(
-      dlsym(lib, "gtk_builder_get_current_object"));
+      FindSymbol(lib, "gtk_builder_get_current_object"));
   api.builder_scope_get_type = reinterpret_cast<decltype(api.builder_scope_get_type)>(
-      dlsym(lib, "gtk_builder_scope_get_type"));
+      FindSymbol(lib, "gtk_builder_scope_get_type"));
   api.ok = api.set_template != nullptr && api.set_template_from_resource != nullptr &&
            api.bind_template_child_full != nullptr && api.set_css_name != nullptr &&
            api.init_template != nullptr && api.get_template_child != nullptr;
   return &api;
-#endif  // _WIN32
 }
 
 // The live JS env stamped on a template-callback scope (refreshed each construct).