@gjsify/node-gi 0.24.1 → 0.25.1

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/index.js

@@ -179,11 +179,32 @@ if (!isNodeRuntime && RUNTIME !== 'gjs') {
       // (Bun's own processTicksAndRejections calls it from JS).
       ({ drainMicrotasks: drain } = require('bun:jsc'));
     } else if (typeof globalThis.Deno?.internal === 'symbol') {
-      // V8: core.runMicrotasks → op_run_microtasks →
-      // Isolate::PerformMicrotaskCheckpoint (a reentrant op, explicitly
-      // safe with JS frames on the stack).
+      // V8: the checkpoint needs BOTH queues. core.runMicrotasks is only
+      // Isolate::PerformMicrotaskCheckpoint; Deno's node-compat
+      // process.nextTick queue is a SEPARATE deno_core queue
+      // (ext:deno_node/_next_tick.ts → core.queueNextTick) that only the
+      // runtime's own event loop drains — and that loop is paused for the
+      // whole lifetime of a blocking run(). node:stream delivers stream
+      // 'end' via process.nextTick (endReadableNT), so with a
+      // microtask-only drain any body consumption over a Readable
+      // (@gjsify/fetch consumeBody → XHR arrayBuffer/text) got its chunks
+      // (microtask-delivered) but never the end: every asset load hung at
+      // readyState 3 forever on Deno while the SAME bundle settled on Bun,
+      // whose nextTick rides JSC's microtask queue (bun:jsc
+      // drainMicrotasks covers it). core.runNextTicks mirrors node's
+      // task_queues.js runNextTicks: microtask checkpoint when no ticks
+      // are scheduled, full processTicksAndRejections (ticks + microtasks
+      // interleaved) when there are — one call, both queues. Regression:
+      // test/blocking-run-checkpoint.test.mjs.
       const core = globalThis.Deno[globalThis.Deno.internal]?.core;
-      if (typeof core?.runMicrotasks === 'function') drain = () => core.runMicrotasks();
+      if (typeof core?.runNextTicks === 'function') {
+        drain = () => core.runNextTicks();
+      } else if (typeof core?.runMicrotasks === 'function') {
+        // Older deno_core without runNextTicks: microtask-only drain
+        // (pre-fix behaviour — promise continuations settle, nextTick
+        // consumers like node:stream 'end' still starve).
+        drain = () => core.runMicrotasks();
+      }
     }
     if (typeof drain === 'function') native.setMicrotaskDrain(drain);
   } catch {

package/package.json

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

@@ -545,6 +545,7 @@ static Napi::Value InvokeFunctionInfo(Napi::Env env, GIFunctionInfo* func, gpoin
   // the invoke (the callee ref'd the GBytes if it kept it), transfer-full refs
   // belong to the callee (dropped only when the callee never ran).
   CreatedBytes createdBytes;
+  CreatedValues createdValues;
   bool ok = true;
   size_t jsCursor = 0;
   for (unsigned int i = 0; i < n_args && ok; i++) {
@@ -800,7 +801,7 @@ static Napi::Value InvokeFunctionInfo(Napi::Env env, GIFunctionInfo* func, gpoin
       } else {
         GITransfer tr = gi_arg_info_get_ownership_transfer(ai);
         ok = JsToGIArgument(env, v, ti, &in_args[inPos[i]], &held[i], tr, &ownedInStrings,
-                            &createdClosures, &createdBytes);
+                            &createdClosures, &createdBytes, &createdValues);
       }
     }
 
@@ -818,6 +819,9 @@ static Napi::Value InvokeFunctionInfo(Napi::Env env, GIFunctionInfo* func, gpoin
     // Likewise every fresh GBytes built from a JS typed array — never adopted.
     for (GBytes* b : createdBytes.transferNone) g_bytes_unref(b);
     for (GBytes* b : createdBytes.transferFull) g_bytes_unref(b);
+    // Likewise every GValue boxed from a plain JS value — never adopted.
+    for (GValue* gv : createdValues.transferNone) NodeGiFreeBoxedGValue(gv);
+    for (GValue* gv : createdValues.transferFull) NodeGiFreeBoxedGValue(gv);
     // Likewise the transfer-full-instance ref: the callee never consumed it.
     if (instanceRefTaken) g_object_unref(static_cast<GObject*>(instance));
     for (gpointer s : ownedInStrings) g_free(s);  // never reached the callee (#658)
@@ -857,6 +861,11 @@ static Napi::Value InvokeFunctionInfo(Napi::Env env, GIFunctionInfo* func, gpoin
   // paths). A callee that kept the bytes (GdkPixbuf.Pixbuf.new_from_bytes) holds
   // its own ref. Transfer-full GBytes were adopted by the callee — no release.
   for (GBytes* b : createdBytes.transferNone) g_bytes_unref(b);
+  // Transfer-none GValue IN-args boxed from plain JS values: the callee copied
+  // whatever it needed (g_object_set_property copies into the property), so the
+  // box is ours to free — success AND error paths, mirroring the GBytes rule.
+  // Transfer-full GValues were adopted by the callee — no release.
+  for (GValue* gv : createdValues.transferNone) NodeGiFreeBoxedGValue(gv);
   if (!success) {
     for (const InContainer& c : inContainers) FreeInContainer(c);
     // A failed invoke did not adopt the transfer-full IN/INOUT strings we g_strdup'd

package/src/common.h

@@ -295,6 +295,33 @@ struct CreatedBytes {
   std::vector<GBytes*> transferFull;  // callee adopts; unref only when the callee never ran
 };
 
+// A plain JS value handed to a `GObject.Value` IN-arg is BOXED into a fresh
+// GValue whose GType is guessed from the JS value — exactly what GJS does
+// (refs/gjs/gi/arg-cache.cpp GValueIn::in → gjs_value_to_g_value, whose
+// gjs_value_guess_g_type supplies the type for an uninitialized GValue). Without
+// it, the single most common GObject call in existence —
+// `obj.set_property('name', 0.5)`, whose second GI argument is a GValue — fails
+// with "Unsupported interface IN argument", because a JS number is not a boxed
+// handle. An existing GObject.Value boxed handle still routes through the
+// boxed-handle path and is passed through untouched.
+//
+// Lifetime mirrors CreatedBytes: the box is freed after the invoke for
+// transfer-none (the callee copied whatever it needed — g_object_set_property
+// copies into the property), and left with the callee for transfer-full.
+struct CreatedValues {
+  std::vector<GValue*> transferNone;  // free after the invoke (callee borrowed)
+  std::vector<GValue*> transferFull;  // callee adopts; free only when it never ran
+};
+
+// Release a GValue this layer boxed: unset the held value (dropping the ref an
+// object/boxed/string GValue took) and free the struct. A plain `g_free` would
+// leak whatever the GValue owns.
+inline void NodeGiFreeBoxedGValue(GValue* gv) {
+  if (gv == nullptr) return;
+  if (G_IS_VALUE(gv)) g_value_unset(gv);
+  g_free(gv);
+}
+
 // Build the (floating) marshaled GClosure for a JS function (signals.cc — shares
 // the battle-tested JsClosure marshal/finalize machinery with `.connect()`).
 GClosure* NodeGiMakeGenericJsClosure(Napi::Env env, Napi::Value fn);
@@ -309,12 +336,16 @@ GClosure* NodeGiMakeGenericJsClosure(Napi::Env env, Napi::Value fn);
 // `bytes` (optional): enables the JS-bytes→GBytes IN-arg marshalling above;
 // nullptr (the default) keeps the previous behaviour (typed array → TypeError) on
 // paths that cannot release a created GBytes.
+// `values` (optional): enables the JS-value→GValue IN-arg boxing above; nullptr
+// (the default) keeps the previous behaviour (plain value → TypeError) on paths
+// that cannot release a created GValue.
 bool JsToGIArgument(Napi::Env env, Napi::Value v, GITypeInfo* type, GIArgument* out,
                     std::string* heldString,
                     GITransfer transfer = GI_TRANSFER_NOTHING,
                     std::vector<gpointer>* ownedStrings = nullptr,
                     CreatedClosures* closures = nullptr,
-                    CreatedBytes* bytes = nullptr);
+                    CreatedBytes* bytes = nullptr,
+                    CreatedValues* values = nullptr);
 
 // ---- IN container building -----------------------------------------
 //

package/src/loop.cc

@@ -108,8 +108,14 @@ static void DrainMicrotasks() {
 //
 // Portable fix: N-API exposes no engine microtask checkpoint, but both runtimes
 // expose their OWN drain primitive to JS (Bun: `bun:jsc` drainMicrotasks —
-// JSC's VM drain, callable mid-stack by design; Deno: core.runMicrotasks →
-// Isolate::PerformMicrotaskCheckpoint via a reentrant op). index.js registers
+// JSC's VM drain, callable mid-stack by design, and Bun's process.nextTick
+// rides that same queue; Deno: core.runNextTicks — node's task_queues.js
+// runNextTicks shape, draining the node-compat process.nextTick queue AND the
+// V8 microtask checkpoint. core.runMicrotasks alone is NOT enough on Deno:
+// its nextTick queue is separate from V8's microtasks, and node:stream's
+// 'end' is nextTick-delivered (endReadableNT), so a microtask-only drain hung
+// every fetch/XHR body consumption at readyState 3 during a blocking run —
+// see test/blocking-run-checkpoint.test.mjs). index.js registers
 // it here on non-Node runtimes only; the loop-dispatched trampolines
 // (signals.cc / calls.cc / class.cc) invoke NodeGiMaybeDrainMicrotasks at their
 // OUTERMOST boundary (g_loopDispatchDepth == 0). Node never registers — its

package/src/marshal.cc

@@ -3,6 +3,7 @@
 
 #include "common.h"
 
+#include <cmath>
 #include <unordered_map>
 #include <utility>
 
@@ -190,6 +191,101 @@ gpointer TransferBoxedIn(BoxedHandle* h, GITransfer transfer) {
   return h->ptr;
 }
 
+// Whether `v` is a boxed handle that ALREADY holds a GValue — the one shape a
+// `GObject.Value` IN-arg takes as-is (gjs GValueIn::in passes it through when the
+// JS object's own gtype is G_TYPE_VALUE, and boxes EVERYTHING else, including
+// other boxed handles: a GVariant handed to `set_property('state', …)` becomes a
+// G_TYPE_VARIANT GValue, it does not become the GValue).
+static bool NodeGiIsGValueHandle(Napi::Value v) {
+  BoxedHandle* h = TryGetBoxedHandle(v);
+  return h != nullptr && h->gtype != G_TYPE_INVALID && g_type_is_a(h->gtype, G_TYPE_VALUE);
+}
+
+// Initialise `out` from a plain JS value, guessing the GType the way gjs does
+// for an uninitialized GValue (refs/gjs/gi/value.cpp gjs_value_guess_g_type +
+// gjs_value_to_g_value_internal). Returns false with a pending JS exception when
+// the value has no sensible GValue representation.
+//
+// The int32-vs-double split matches gjs exactly (`value.isInt32()` →
+// `G_TYPE_INT`, `value.isDouble()` → `G_TYPE_DOUBLE`); JS has no such tag at the
+// N-API boundary, so an integral number in int32 range stands in for isInt32.
+// That distinction is not load-bearing for correctness — `g_object_set_property`
+// transforms between the numeric fundamentals — but staying bit-for-bit with gjs
+// keeps a property that reads the GValue's own type behaving identically.
+static bool JsToFreshGValue(Napi::Env env, Napi::Value v, GValue* out) {
+  if (v.IsNull() || v.IsUndefined()) {
+    // gjs guesses G_TYPE_POINTER for null. A real GValue holding NULL is also
+    // the only thing a callee can safely dereference — passing a NULL GValue*
+    // (the plain boxed-null path) would crash g_object_set_property.
+    g_value_init(out, G_TYPE_POINTER);
+    g_value_set_pointer(out, nullptr);
+    return true;
+  }
+  if (v.IsBoolean()) {
+    g_value_init(out, G_TYPE_BOOLEAN);
+    g_value_set_boolean(out, v.As<Napi::Boolean>().Value() ? TRUE : FALSE);
+    return true;
+  }
+  if (v.IsString()) {
+    g_value_init(out, G_TYPE_STRING);
+    g_value_set_string(out, v.As<Napi::String>().Utf8Value().c_str());
+    return true;
+  }
+  if (v.IsBigInt()) {
+    bool lossless = false;
+    int64_t i64 = v.As<Napi::BigInt>().Int64Value(&lossless);
+    if (lossless || i64 < 0) {
+      g_value_init(out, G_TYPE_INT64);
+      g_value_set_int64(out, i64);
+    } else {
+      bool ulossless = false;
+      g_value_init(out, G_TYPE_UINT64);
+      g_value_set_uint64(out, v.As<Napi::BigInt>().Uint64Value(&ulossless));
+    }
+    return true;
+  }
+  if (v.IsNumber()) {
+    double d = v.As<Napi::Number>().DoubleValue();
+    if (d == std::trunc(d) && d >= static_cast<double>(G_MININT32) &&
+        d <= static_cast<double>(G_MAXINT32)) {
+      g_value_init(out, G_TYPE_INT);
+      g_value_set_int(out, static_cast<gint>(d));
+    } else {
+      g_value_init(out, G_TYPE_DOUBLE);
+      g_value_set_double(out, d);
+    }
+    return true;
+  }
+  if (v.IsExternal()) {
+    // A GObject handle → a G_TYPE_OBJECT GValue carrying its own GType, so a
+    // property typed against a subclass still accepts it.
+    Napi::External<GObject> objExt = v.As<Napi::External<GObject>>();
+    if (objExt.CheckTypeTag(&kGObjectHandleTag)) {
+      GObject* obj = objExt.Data();
+      GType gt = obj != nullptr ? G_OBJECT_TYPE(obj) : G_TYPE_OBJECT;
+      g_value_init(out, gt);
+      g_value_set_object(out, obj);
+      return true;
+    }
+    // A boxed handle → its own registered GType (GVariant has its own
+    // fundamental; a non-registered C struct has no GType to name and is
+    // rejected rather than guessed at).
+    BoxedHandle* h = TryGetBoxedHandle(v);
+    if (h != nullptr && h->gtype != G_TYPE_INVALID) {
+      g_value_init(out, h->gtype);
+      if (h->gtype == G_TYPE_VARIANT) g_value_set_variant(out, static_cast<GVariant*>(h->ptr));
+      else if (G_TYPE_IS_BOXED(h->gtype)) g_value_set_boxed(out, h->ptr);
+      else g_value_set_pointer(out, h->ptr);
+      return true;
+    }
+  }
+  Napi::TypeError::New(
+      env, "Cannot convert this value to a GObject.Value (expected a boolean, number, bigint, "
+           "string, null, or a GObject/boxed handle)")
+      .ThrowAsJavaScriptException();
+  return false;
+}
+
 // 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;
@@ -337,7 +433,8 @@ bool JsToGIArgument(Napi::Env env, Napi::Value v, GITypeInfo* type, GIArgument*
                     GITransfer transfer,
                     std::vector<gpointer>* ownedStrings,
                     CreatedClosures* closures,
-                    CreatedBytes* bytes) {
+                    CreatedBytes* bytes,
+                    CreatedValues* values) {
   if (v.IsEmpty()) {
     // Residue of a swallowed napi failure (a fallible Get()/coercion upstream
     // failed on a terminating env, or a throwing getter left the exception
@@ -399,7 +496,31 @@ bool JsToGIArgument(Napi::Env env, Napi::Value v, GITypeInfo* type, GIArgument*
             out->v_pointer = nullptr;
             handled = true;
           } else if (v.IsExternal()) {
-            out->v_pointer = v.As<Napi::External<GObject>>().Data();
+            GObject* obj = v.As<Napi::External<GObject>>().Data();
+            // A (transfer full) GObject IN arg CONSUMES a reference: the callee
+            // takes over the one it is handed. Passing the handle's own ref
+            // makes the callee and the JS wrapper share a single ref that BOTH
+            // release — the wrapper's finalize then frees an object the callee
+            // still owns, and the callee is left dereferencing freed memory.
+            //
+            // `gtk_widget_add_controller()` is the canonical case and the one
+            // that surfaced it: GTK keeps the controller in the widget's list,
+            // the JS wrapper for it goes out of scope, and the next pointer
+            // motion over the widget hits
+            //
+            //   Gtk-CRITICAL **: gtk_event_controller_handle_crossing:
+            //   assertion 'GTK_IS_EVENT_CONTROLLER (controller)' failed
+            //
+            // NONDETERMINISTICALLY — it needs a GC between the add and the
+            // event, which is why it looked unrelated to anything nearby.
+            //
+            // gjs takes the ref here (wrapperutils.h
+            // `transfer_to_gi_argument`: `GI_DIRECTION_IN && transfer !=
+            // GI_TRANSFER_NOTHING` → `copy_ptr` → `g_object_ref`), and this
+            // file already does the equivalent for BOXED args via
+            // `TransferBoxedIn`. Objects were simply never given the same rule.
+            if (transfer != GI_TRANSFER_NOTHING && obj != nullptr) g_object_ref(obj);
+            out->v_pointer = obj;
             handled = true;
           }
         } else if (GI_IS_ENUM_INFO(iface) || GI_IS_FLAGS_INFO(iface)) {
@@ -454,6 +575,29 @@ bool JsToGIArgument(Napi::Env env, Napi::Value v, GITypeInfo* type, GIArgument*
             if (transfer == GI_TRANSFER_NOTHING) bytes->transferNone.push_back(b);
             else bytes->transferFull.push_back(b);
             handled = true;
+          } else if (values != nullptr && !NodeGiIsGValueHandle(v) &&
+                     gi_registered_type_info_get_g_type(
+                         reinterpret_cast<GIRegisteredTypeInfo*>(iface)) == G_TYPE_VALUE) {
+            // A plain JS value for a `GObject.Value` IN-arg → a fresh GValue whose
+            // GType is guessed from the value, exactly as gjs (refs/gjs
+            // gi/arg-cache.cpp GValueIn::in → gjs_value_to_g_value). This is what
+            // makes `obj.set_property('volume', 0.5)` — whose GI signature takes a
+            // GValue — work at all; a JS number is not a boxed handle, so it used
+            // to fall through to the "Unsupported interface IN argument" throw.
+            //
+            // An EXISTING GObject.Value handle is excluded here and routes through
+            // the boxed-handle branch below untouched, matching gjs's pass-through
+            // for an already-typed GValue.
+            GValue* boxed = g_new0(GValue, 1);
+            if (!JsToFreshGValue(env, v, boxed)) {
+              g_free(boxed);
+              gi_base_info_unref(iface);
+              return false;  // JsToFreshGValue already threw
+            }
+            out->v_pointer = boxed;
+            if (transfer == GI_TRANSFER_NOTHING) values->transferNone.push_back(boxed);
+            else values->transferFull.push_back(boxed);
+            handled = true;
           } else if (v.IsNull() || v.IsUndefined()) {
             // Boxed/struct IN args arrive as boxed handles; null/undefined maps to
             // a NULL pointer (e.g. GLib.MainLoop.new(null, false)).