@gjsify/node-gi 0.23.0 → 0.24.2

package/gi.d.ts

@@ -93,7 +93,7 @@ export interface GObjectNamespace extends GiNamespace {
   ParamSpec: ParamSpecFactories;
   /**
    * The FULL introspected `GParamFlags` bitfield (READABLE/WRITABLE/READWRITE/
-   * CONSTRUCT/CONSTRUCT_ONLY/LAX_VALIDATION/STATIC_*/EXPLICIT_NOTIFY/DEPRECATED/
+   * CONSTRUCT/CONSTRUCT_ONLY/LAX_VALIDATION/STATIC_.../EXPLICIT_NOTIFY/DEPRECATED/
    * …) — the named members below are the common convenience bits; the index
    * signature covers the remaining introspected members.
    */

package/globals.d.ts

@@ -32,17 +32,11 @@ export interface GjsImports {
 }
 
 declare global {
-  // eslint-disable-next-line no-var
   var print: (...args: unknown[]) => void;
-  // eslint-disable-next-line no-var
   var printerr: (...args: unknown[]) => void;
-  // eslint-disable-next-line no-var
   var log: (...args: unknown[]) => void;
-  // eslint-disable-next-line no-var
   var logError: (error: unknown, prefix?: string) => void;
-  // eslint-disable-next-line no-var
   var ARGV: string[];
-  // eslint-disable-next-line no-var
   var imports: GjsImports;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjsify/node-gi",
-  "version": "0.23.0",
+  "version": "0.24.2",
   "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/marshal.cc

@@ -153,6 +153,43 @@ BoxedHandle* TryGetBoxedHandle(Napi::Value v) {
   return ext.Data();
 }
 
+// The pointer to hand a callee for a boxed/struct IN argument, honouring the
+// arg's TRANSFER annotation.
+//
+// A transfer-full (or -container) IN arg is ADOPTED by the callee: it will free
+// the pointer. Handing over the very block this handle still owns makes both
+// sides free it — the finalizer's g_boxed_free then hits already-released
+// memory (`free(): invalid pointer`, SIGABRT). The canonical case is
+// `GstWebRTC.WebRTCSessionDescription.new(type, sdp)`, whose `sdp` param is
+// `(transfer full)`: the fresh `GstSDPMessage` from
+// `GstSdp.SDPMessage.new_from_text()` (an OUT `(transfer full)`, so our handle
+// owns it) got freed once by `gst_webrtc_session_description_free` and again by
+// its own finalizer.
+//
+// gjs solves this by COPYING on transfer — refs/gjs/gi/wrapperutils.h
+// `GIWrapperBase::transfer_to_gi_argument` (`GI_DIRECTION_IN &&
+// transfer != GI_TRANSFER_NOTHING` → `Instance::copy_ptr`), with
+// refs/gjs/gi/struct.h `StructInstance::copy_ptr` = `g_variant_ref` for
+// GVariant else refs/gjs/gi/boxed.h `BoxedInstance::copy_ptr` = `g_boxed_copy`.
+// Mirror that: the callee owns an independent instance, the handle keeps (and
+// still owns) its own. Transfer-NOTHING is a plain borrow — unchanged.
+//
+// A handle with no copy function (a plain, non-boxed C struct — G_TYPE_INVALID,
+// or a `rawOwned` caller-allocates OUT block) cannot be duplicated. gjs throws
+// there; we instead RELINQUISH ownership so the finalizer stays out of the
+// callee's way — a leak-free hand-over is impossible either way, and not
+// double-freeing is strictly safer than the alternative.
+gpointer TransferBoxedIn(BoxedHandle* h, GITransfer transfer) {
+  if (h == nullptr) return nullptr;
+  if (transfer == GI_TRANSFER_NOTHING || h->ptr == nullptr) return h->ptr;
+  if (h->gtype == G_TYPE_VARIANT) return g_variant_ref(static_cast<GVariant*>(h->ptr));
+  if (h->gtype != G_TYPE_INVALID && G_TYPE_IS_BOXED(h->gtype))
+    return g_boxed_copy(h->gtype, h->ptr);
+  h->owns = false;
+  h->rawOwned = false;
+  return h->ptr;
+}
+
 // Read a boxed handle's pointer if `v` is one (tag-checked; no deref of ptr).
 bool TryGetBoxedPtr(Napi::Value v, gpointer* out) {
   if (!v.IsExternal()) return false;
@@ -440,7 +477,7 @@ bool JsToGIArgument(Napi::Env env, Napi::Value v, GITypeInfo* type, GIArgument*
                     .ThrowAsJavaScriptException();
                 return false;
               }
-              out->v_pointer = h->ptr;
+              out->v_pointer = TransferBoxedIn(h, transfer);
               handled = true;
             }
           }

package/src/object.cc

@@ -258,7 +258,32 @@ Napi::Value GValueToJs(Napi::Env env, const GValue* v) {
       // NOT special-cased here: gjs leaves it as a GLib.Bytes boxed handle
       // (value.cpp has no GBytes case → the generic boxed branch), which is what the
       // MakeBoxedHandle below already produces (verified: a GBytes signal param →
-      // `instanceof GLib.Bytes`). A GStrv-as-array read stays a follow-up.
+      // `instanceof GLib.Bytes`).
+      //
+      // G_TYPE_STRV (a NULL-terminated gchar**, e.g. Gtk.Widget:css-classes,
+      // Gio.ThemedIcon:names, or any Vala `public string[] x { get; }` property —
+      // valac emits g_param_spec_boxed(…, G_TYPE_STRV) for those). This is the READ
+      // half of the pair JsToGValue's GStrv branch opened: without it a GStrv
+      // property fell through to MakeBoxedHandle and JS got an opaque boxed handle
+      // instead of an array — SILENTLY, because a handle is a truthy object whose
+      // `.length` is undefined, so `arr ?? []` keeps it and every index/`for` over it
+      // yields nothing (this is how @gjsify/http lost every request header on the
+      // node-gi bridge: `bridgeReq.header_pairs` became a handle and the pair loop
+      // ran zero times). Mirrors GJS gjs_value_from_g_value_internal
+      // (refs/gjs/gi/value.cpp:1082 `gtype == G_TYPE_STRV` → gjs_array_from_strv).
+      // NULL → an EMPTY ARRAY, not null: GJS explicitly excludes G_TYPE_STRV from its
+      // "pointer-valued NULL → JS null" pre-check (value.cpp:1023) and documents the
+      // choice in gjs_array_from_strv (arg.cpp:2267) — "clients would need to always
+      // check for both an empty array and null" otherwise. g_value_get_boxed BORROWS;
+      // every string is copied into JS, so nothing is owned here.
+      if (G_VALUE_HOLDS(v, G_TYPE_STRV)) {
+        const gchar* const* strv = static_cast<const gchar* const*>(g_value_get_boxed(v));
+        guint len = 0;
+        while (strv != nullptr && strv[len] != nullptr) len++;
+        Napi::Array arr = Napi::Array::New(env, len);
+        for (guint i = 0; i < len; i++) arr.Set(i, Napi::String::New(env, strv[i]));
+        return arr;
+      }
       if (G_VALUE_HOLDS(v, G_TYPE_BYTE_ARRAY)) {
         GByteArray* ba = static_cast<GByteArray*>(g_value_get_boxed(v));
         if (ba == nullptr) return env.Null();

package/system.js

@@ -20,25 +20,61 @@
 // returning the same shape GJS does — they exist so GJS source that calls them
 // keeps running unmodified, not to reproduce SpiderMonkey internals.
 
+// The RUNTIME's own `process`, bound ONCE at module evaluation.
+//
+// `globalThis.process` is NOT a safe source for this module: a GJS program run
+// through the reverse bridge routinely installs the gjsify `@gjsify/process`
+// polyfill over it (`@gjsify/node-globals/register` defines it unconditionally),
+// and that polyfill's `exit()` takes its GJS path whenever `imports.system.exit`
+// exists — i.e. it delegates back into THIS module. Reading `globalThis.process`
+// in `exit()` closes that loop into an infinite, GLib-idle-driven recursion
+// (exit → polyfill → system.exit → polyfill → …) that spins at 100 % CPU and
+// never terminates. `getBuiltinModule('node:process')` (Node ≥ 22.3 / Bun /
+// Deno 2) returns the real builtin regardless of what the global currently is;
+// the module-evaluation capture is the fallback for hosts without it — this
+// module is loaded from `@gjsify/node-gi/globals`, before any bundle body (and
+// therefore before any register side effect) runs.
+const runtimeProcess = (() => {
+  const hostProcess = typeof process !== 'undefined' ? process : undefined;
+  try {
+    const builtin = hostProcess?.getBuiltinModule?.('node:process');
+    if (builtin && typeof builtin.exit === 'function') return builtin;
+  } catch {
+    // getBuiltinModule missing or refusing the specifier — use the captured one.
+  }
+  return hostProcess;
+})();
+
+const runtimeExit = typeof runtimeProcess?.exit === 'function' ? runtimeProcess.exit.bind(runtimeProcess) : undefined;
+
 // `programArgs` mirrors GJS's ARGV: the script arguments, excluding the
 // interpreter (argv[0]) and the script path (argv[1]).
 function readProgramArgs() {
-  return typeof process !== 'undefined' && Array.isArray(process.argv) ? process.argv.slice(2) : [];
+  return Array.isArray(runtimeProcess?.argv) ? runtimeProcess.argv.slice(2) : [];
 }
 
 // `programInvocationName` / `programPath` track the running script — Node's
 // `process.argv[1]`.
 function readProgramInvocationName() {
-  return (typeof process !== 'undefined' && process.argv[1]) || '';
+  return runtimeProcess?.argv?.[1] || '';
 }
 
 function readProgramPath() {
-  return (typeof process !== 'undefined' && process.argv[1]) || null;
+  return runtimeProcess?.argv?.[1] || null;
 }
 
-/** Exit the process (GJS `System.exit`). */
+/**
+ * Exit the process (GJS `System.exit`).
+ *
+ * Terminal by contract: under gjs this is the `exit()` syscall — it never
+ * returns and nothing a program installs can intercept it. The Node/Bun/Deno
+ * equivalent is the RUNTIME's own `process.exit`, resolved above; routing
+ * through `globalThis.process` instead is what produced the never-exiting
+ * reverse-bridge process (see the `runtimeProcess` note and
+ * `conformance/programs/system-exit-lifetime.conf.mjs`).
+ */
 export function exit(code) {
-  if (typeof process !== 'undefined') process.exit(code ?? 0);
+  if (runtimeExit !== undefined) runtimeExit(code ?? 0);
 }
 
 /** Trigger a garbage collection if the host exposed `globalThis.gc` (`--expose-gc`). */