@gjsify/node-gi 0.63.0 → 0.64.1

package/src/common.h

@@ -35,6 +35,7 @@
 #endif
 
 #ifndef _WIN32
+#include <cmath>
 #include <dlfcn.h>  // dlopen/dlsym the GtkWidgetClass template API (no GTK link)
 #endif
 #include <napi.h>
@@ -83,11 +84,6 @@ GIRepository* DupDefaultRepository();
 // Init, freed by the instance-data finalizer at env teardown.
 struct NodeGiEnvData {
   napi_ref errorBuilder = nullptr;
-  // The CLASS the builder above constructs — L1's `GLib.Error`. Registered with
-  // the builder (one call, so the two cannot drift apart) and read the other way
-  // round: a GError-typed IN arg uses it to recognise an L1 error and rebuild a
-  // real GError from its fields. Per-env for the same reason as errorBuilder.
-  napi_ref errorClass = nullptr;
   // L1-registered resolver for Gtk.Template `<signal handler="…">` callbacks: given
   // (instanceHandle, handlerName) it returns the instance's bound JS method (or
   // undefined). Stored per-env for the same reason as errorBuilder (a napi_ref is
@@ -160,6 +156,13 @@ extern const napi_type_tag kGObjectHandleTag;
 Napi::Value MakeBoxedHandle(Napi::Env env, gpointer ptr, GType gtype, bool owns,
                             GIBaseInfo* info = nullptr, bool rawOwned = false);
 Napi::Value WrapVariant(Napi::Env env, GVariant* var, GITransfer transfer);
+// Wrap a `GError*` as the boxed handle L1's `wrapGError` turns into the error
+// object. ONE helper for both directions a GError reaches JS by — a GError-typed
+// return/OUT and the error a failed invoke THREW — because those used to produce
+// two different JS shapes, and sharing the wrap is what keeps them from drifting
+// apart again. Transfer follows the boxed rule: transfer-everything is adopted,
+// transfer-none is copied, so the handle always owns what it frees.
+Napi::Value MakeGErrorHandle(Napi::Env env, GError* error, GITransfer transfer);
 BoxedHandle* TryGetBoxedHandle(Napi::Value v);
 bool TryGetBoxedPtr(Napi::Value v, gpointer* out);
 Napi::Value MakeGTypeHandle(Napi::Env env, GType gtype);
@@ -278,6 +281,162 @@ inline uint64_t JsValueToUint64(Napi::Value v) {
   return n.IsEmpty() ? 0 : static_cast<uint64_t>(n.Int64Value());
 }
 
+// IN integers, GJS-exact (refs/gjs/gi/js-value-inl.h, arg-inl.h): an integer tag
+// REFUSES an out-of-range value instead of wrapping it. The rule is not uniform and is
+// copied as is, never made stricter: 8/16-bit run ToInt32 first (so it wraps mod 2^32)
+// and then compare against the tag range; int32 is not checked at all; uint32 and the
+// 64-bit tags refuse what falls outside their range. undefined and a non-finite Number
+// become 0. `shown` receives the text GJS prints for the offending value.
+// kPending: a BigInt/Symbol hit ToNumber, the TypeError is already pending — the caller
+// must stop without throwing a second error.
+enum class NodeGiIntResult { kOk, kOutOfRange, kPending };
+inline NodeGiIntResult NodeGiJsToInteger(Napi::Value v, GITypeTag tag, GIArgument* out,
+                                         std::string* shown) {
+  const bool is64 = tag == GI_TYPE_TAG_INT64 || tag == GI_TYPE_TAG_UINT64;
+  if (is64 && v.IsBigInt()) {
+    bool lossless = false;
+    if (tag == GI_TYPE_TAG_INT64) {
+      out->v_int64 = v.As<Napi::BigInt>().Int64Value(&lossless);
+    } else {
+      out->v_uint64 = v.As<Napi::BigInt>().Uint64Value(&lossless);
+    }
+    if (!lossless && shown != nullptr) *shown = "0";
+    return lossless ? NodeGiIntResult::kOk : NodeGiIntResult::kOutOfRange;
+  }
+  Napi::Number n = v.ToNumber();
+  if (n.IsEmpty()) return NodeGiIntResult::kPending;
+  double d = n.DoubleValue();
+  switch (tag) {
+    case GI_TYPE_TAG_INT8:
+    case GI_TYPE_TAG_UINT8:
+    case GI_TYPE_TAG_INT16:
+    case GI_TYPE_TAG_UINT16: {
+      int32_t i = n.Int32Value();
+      int32_t lo = tag == GI_TYPE_TAG_INT8 ? INT8_MIN : tag == GI_TYPE_TAG_INT16 ? INT16_MIN : 0;
+      int32_t hi = tag == GI_TYPE_TAG_INT8 ? INT8_MAX : tag == GI_TYPE_TAG_UINT8 ? UINT8_MAX
+                   : tag == GI_TYPE_TAG_INT16 ? INT16_MAX : UINT16_MAX;
+      if (shown != nullptr) *shown = std::to_string(i);
+      if (i < lo || i > hi) return NodeGiIntResult::kOutOfRange;
+      if (tag == GI_TYPE_TAG_INT8) out->v_int8 = static_cast<int8_t>(i);
+      else if (tag == GI_TYPE_TAG_UINT8) out->v_uint8 = static_cast<uint8_t>(i);
+      else if (tag == GI_TYPE_TAG_INT16) out->v_int16 = static_cast<int16_t>(i);
+      else out->v_uint16 = static_cast<uint16_t>(i);
+      return NodeGiIntResult::kOk;
+    }
+    case GI_TYPE_TAG_INT32:
+      out->v_int32 = n.Int32Value();
+      return NodeGiIntResult::kOk;
+    case GI_TYPE_TAG_UINT32: {
+      bool zero = v.IsUndefined() || (v.IsNumber() && !std::isfinite(d));
+      if (zero) {
+        out->v_uint32 = 0;
+        return NodeGiIntResult::kOk;
+      }
+      if (shown != nullptr) *shown = std::to_string(d);
+      if (std::isnan(d) || d < 0 || d > static_cast<double>(UINT32_MAX))
+        return NodeGiIntResult::kOutOfRange;
+      out->v_uint32 = static_cast<uint32_t>(d);
+      return NodeGiIntResult::kOk;
+    }
+    case GI_TYPE_TAG_INT64: {
+      double t = std::isfinite(d) ? std::trunc(d) : 0;
+      if (t < -9223372036854775808.0 || t >= 9223372036854775808.0) {
+        if (shown != nullptr)
+          *shown = std::to_string(t < 0 ? INT64_MIN : INT64_MAX);
+        return NodeGiIntResult::kOutOfRange;
+      }
+      out->v_int64 = static_cast<int64_t>(t);
+      return NodeGiIntResult::kOk;
+    }
+    case GI_TYPE_TAG_UINT64: {
+      double t = std::isfinite(d) ? std::trunc(d) : 0;
+      if (t < 0 || t >= 18446744073709551616.0) {
+        if (shown != nullptr)
+          *shown = std::to_string(t < 0 ? uint64_t{0} : UINT64_MAX);
+        return NodeGiIntResult::kOutOfRange;
+      }
+      out->v_uint64 = static_cast<uint64_t>(t);
+      return NodeGiIntResult::kOk;
+    }
+    default:
+      return NodeGiIntResult::kOk;
+  }
+}
+
+enum class NodeGiIntContext { kArgument, kField, kReturnValue };
+inline const char* NodeGiIntTagName(GITypeTag tag) {
+  switch (tag) {
+    case GI_TYPE_TAG_INT8: return "int8";
+    case GI_TYPE_TAG_UINT8: return "uint8";
+    case GI_TYPE_TAG_INT16: return "int16";
+    case GI_TYPE_TAG_UINT16: return "uint16";
+    case GI_TYPE_TAG_INT32: return "int32";
+    case GI_TYPE_TAG_UINT32: return "uint32";
+    case GI_TYPE_TAG_INT64: return "int64";
+    default: return "uint64";
+  }
+}
+// GJS's three texts (arg-cache.cpp / arg.cpp), plain Error.
+inline void NodeGiThrowIntOutOfRange(Napi::Env env, GITypeTag tag, NodeGiIntContext ctx,
+                                     const char* name, const std::string& shown) {
+  std::string t = NodeGiIntTagName(tag);
+  std::string msg;
+  if (ctx == NodeGiIntContext::kArgument) {
+    msg = std::string("Argument ") + (name != nullptr ? name : "") + ": value is out of range for " + t;
+  } else {
+    msg = "value " + shown + " is out of range for " +
+          (ctx == NodeGiIntContext::kField ? std::string("Field '") + (name ? name : "") + "'"
+                                           : std::string("Return value")) +
+          " (type " + t + ")";
+  }
+  Napi::Error::New(env, msg).ThrowAsJavaScriptException();
+}
+
+// IN array elements and GValue int/uint, GJS-exact: these WRAP instead of refusing.
+// An array element goes through js_value_to_c_strict (refs/gjs/gi/arg.cpp:543), which
+// is ToInt32/ToUint32 truncated to the tag for 8/16/32 bits and ToInt64/ToUint64 —
+// modulo 2^64 — for 64 bits; a BigInt takes ToBigInt64/ToBigUint64 (also modulo 2^64)
+// on a 64-bit tag and is a TypeError on a narrower one. kPending: that TypeError is
+// already pending, the caller must stop without throwing a second error.
+inline uint64_t NodeGiWrapToUint64(double d) {
+  if (!std::isfinite(d)) return 0;
+  double m = std::fmod(std::trunc(d), 18446744073709551616.0);
+  return m < 0 ? uint64_t{0} - static_cast<uint64_t>(-m) : static_cast<uint64_t>(m);
+}
+inline NodeGiIntResult NodeGiJsToIntegerWrap(Napi::Value v, GITypeTag tag, GIArgument* out) {
+  const bool is64 = tag == GI_TYPE_TAG_INT64 || tag == GI_TYPE_TAG_UINT64;
+  if (is64 && v.IsBigInt()) {
+    bool lossless = false;
+    out->v_uint64 = v.As<Napi::BigInt>().Uint64Value(&lossless);
+    return NodeGiIntResult::kOk;
+  }
+  Napi::Number n = v.ToNumber();
+  if (n.IsEmpty()) return NodeGiIntResult::kPending;
+  switch (tag) {
+    case GI_TYPE_TAG_INT8: out->v_int8 = static_cast<int8_t>(n.Int32Value()); break;
+    case GI_TYPE_TAG_UINT8: out->v_uint8 = static_cast<uint8_t>(n.Uint32Value()); break;
+    case GI_TYPE_TAG_INT16: out->v_int16 = static_cast<int16_t>(n.Int32Value()); break;
+    case GI_TYPE_TAG_UINT16: out->v_uint16 = static_cast<uint16_t>(n.Uint32Value()); break;
+    case GI_TYPE_TAG_INT32: out->v_int32 = n.Int32Value(); break;
+    case GI_TYPE_TAG_UINT32: out->v_uint32 = n.Uint32Value(); break;
+    case GI_TYPE_TAG_INT64:
+    case GI_TYPE_TAG_UINT64: out->v_uint64 = NodeGiWrapToUint64(n.DoubleValue()); break;
+    default: break;
+  }
+  return NodeGiIntResult::kOk;
+}
+
+// GValue char/uchar/int64/uint64: refused out of range with gjs_value_to_g_value's own
+// text (refs/gjs/gi/value.cpp:602-690, throw_expect_type), a plain Error. `what` is the
+// "expected" noun gjs prints; the offending value is its JS ToString.
+inline void NodeGiThrowGValueOutOfRange(Napi::Env env, Napi::Value v, const char* what) {
+  Napi::String s = v.ToString();
+  std::string shown = s.IsEmpty() ? std::string() : s.Utf8Value();
+  Napi::Error::New(env, std::string("Wrong type ") + (v.IsBigInt() ? "bigint" : "number") + "; " +
+                            what + " expected. But it's out of range: " + shown)
+      .ThrowAsJavaScriptException();
+}
+
 // OUT (WarnIfUnsafe{Int,Uint}64): GJS ALWAYS returns a JS Number for a 64-bit int
 // (never a BigInt) and emits this g_warning when the value falls outside the range
 // a double represents exactly (|v| > 2^53 - 1 == Number.MAX_SAFE_INTEGER), because
@@ -317,13 +476,13 @@ struct CreatedClosures {
 
 // ---- C objects this layer SYNTHESISES for one IN argument --------------------
 //
-// Three IN arms build a throw-away C object out of a plain JS value, because the
-// JS side has no handle to hand over: a Uint8Array for a `GLib.Bytes` arg, a
-// number/string for a `GObject.Value` arg, an L1 `GLib.Error` for a `GError` arg.
-// All three carry the SAME lifetime rule, which is why they share one type
-// instead of a third near-identical struct: transfer-none → the callee borrowed
-// (or copied) it, so we release it after the invoke; transfer-full → the callee
-// adopted it, so it is released only when the invoke never ran.
+// Two IN arms build a throw-away C object out of a plain JS value, because the JS
+// side has no handle to hand over: a Uint8Array for a `GLib.Bytes` arg, a
+// number/string for a `GObject.Value` arg. Both carry the SAME lifetime rule,
+// which is why they share one type instead of a second near-identical struct:
+// transfer-none → the callee borrowed (or copied) it, so we release it after the
+// invoke; transfer-full → the callee adopted it, so it is released only when the
+// invoke never ran.
 template <typename T>
 struct CreatedIn {
   std::vector<T*> transferNone;  // release after the invoke (callee borrowed/copied)
@@ -353,17 +512,6 @@ using CreatedBytes = CreatedIn<GBytes>;
 // boxed-handle path and is passed through untouched.
 using CreatedValues = CreatedIn<GValue>;
 
-// An L1 `GLib.Error` (what a `catch` hands you, and what `new GLib.Error(…)`
-// builds) has no `GError*` behind it — it is a JS class, not a boxed handle — so
-// a `GError`-typed IN arg gets a fresh `g_error_new_literal` built from its
-// domain/code/message. Without this, the hand-back direction the OUT direction
-// exists for is only open to errors that came OUT of GI in the first place:
-// `GLib.propagate_error(caught)` and `Gst.Message.new_error(src, caught, dbg)`
-// both refused where gjs accepts, which is the shape an application actually
-// writes. A marshalled GError (a boxed handle) still routes through
-// TransferBoxedIn and is not copied here.
-using CreatedErrors = CreatedIn<GError>;
-
 // 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.
@@ -390,9 +538,6 @@ GClosure* NodeGiMakeGenericJsClosure(Napi::Env env, Napi::Value fn);
 // `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.
-// `errors` (optional): enables the L1-GLib.Error→GError IN-arg build above;
-// nullptr (the default) keeps a marshalled boxed handle working and refuses the
-// L1 class, on paths that cannot release a created GError.
 // `argName` (optional): the introspected argument name, used ONLY in error
 // messages so a refusal reads like gjs's ("Expected type string for argument
 // 'name' but got type number"); nullptr degrades to a message without the name.
@@ -403,8 +548,8 @@ bool JsToGIArgument(Napi::Env env, Napi::Value v, GITypeInfo* type, GIArgument*
                     CreatedClosures* closures = nullptr,
                     CreatedBytes* bytes = nullptr,
                     CreatedValues* values = nullptr,
-                    CreatedErrors* errors = nullptr,
-                    const char* argName = nullptr);
+                    const char* argName = nullptr,
+                    NodeGiIntContext intContext = NodeGiIntContext::kArgument);
 
 // ---- IN container building -----------------------------------------
 //
@@ -671,6 +816,7 @@ Napi::Value FindInfo(const Napi::CallbackInfo& info);
 Napi::Value GetConstantValue(const Napi::CallbackInfo& info);
 Napi::Value GetEnumValues(const Napi::CallbackInfo& info);
 Napi::Value GetErrorDomain(const Napi::CallbackInfo& info);
+Napi::Value ErrorDomainInfo(const Napi::CallbackInfo& info);
 Napi::Value SetErrorBuilder(const Napi::CallbackInfo& info);
 Napi::Value PrependSearchPath(const Napi::CallbackInfo& info);
 Napi::Value PrependLibraryPath(const Napi::CallbackInfo& info);

package/src/marshal.cc

@@ -143,6 +143,22 @@ static Napi::Value WrapBoxed(Napi::Env env, gpointer ptr, GIBaseInfo* structInfo
   return MakeBoxedHandle(env, handlePtr, handleGType, owns, info);
 }
 
+// See common.h. Wrapped through the GLib.Error STRUCT info rather than by GType
+// alone, so `domain`/`code`/`message` resolve as fields — which is how L1 reads
+// them off the GError*.
+Napi::Value MakeGErrorHandle(Napi::Env env, GError* error, GITransfer transfer) {
+  if (error == nullptr) return env.Null();
+  GIRepository* repo = DupDefaultRepository();
+  // GLib is loaded by any namespace require; require defensively anyway so a bare
+  // engine call still resolves the struct info (idempotent, cheap).
+  gi_repository_require(repo, "GLib", "2.0", static_cast<GIRepositoryLoadFlags>(0), nullptr);
+  GIBaseInfo* errInfo = gi_repository_find_by_name(repo, "GLib", "Error");
+  Napi::Value result = WrapBoxed(env, error, errInfo, transfer);
+  if (errInfo != nullptr) gi_base_info_unref(errInfo);
+  g_object_unref(repo);
+  return result;
+}
+
 // Read a boxed handle (ptr + boxed GType) if `v` is one (tag-checked; no deref of
 // ptr). Returns nullptr when `v` is not a node-gi boxed handle. The returned handle
 // is owned by the External — never free it. Callers that need the GType (boxed
@@ -472,47 +488,6 @@ static void ThrowExpectedGLibError(Napi::Env env, const char* argName, const std
       .ThrowAsJavaScriptException();
 }
 
-// Whether `v` is an instance of the L1 `GLib.Error` class — the shape a `catch`
-// around a failed GI invoke hands you, and what `new GLib.Error(domain, code,
-// message)` builds. Recognition is `instanceof` against the class L1 registered
-// alongside its error builder, never duck-typing: a plain object carrying a
-// `code` must still be refused.
-static bool IsL1GLibError(Napi::Env env, Napi::Value v) {
-  if (!v.IsObject()) return false;
-  NodeGiEnvData* d = EnvData(env);
-  if (d == nullptr || d->errorClass == nullptr) return false;
-  napi_value cls = nullptr;
-  if (napi_get_reference_value(env, d->errorClass, &cls) != napi_ok || cls == nullptr) return false;
-  Napi::Value clsValue(env, cls);
-  return clsValue.IsFunction() && v.As<Napi::Object>().InstanceOf(clsValue.As<Napi::Function>());
-}
-
-// Build a real GError out of an L1 `GLib.Error`, which carries no `GError*` of
-// its own. Throws + returns nullptr when its domain is unusable.
-//
-// `.domainQuark` is the numeric GQuark the engine read off the original GError;
-// `.domain` is its NAME (the node-gi divergence documented in
-// docs/node-gi-gjs-surface.md), which is what an error constructed in JS from a
-// quark name carries. Either resolves to the same quark; a value with neither is
-// not a usable GError — quark 0 would produce an error no `matches()` can ever
-// answer for, so it is refused rather than marshalled into a silent mismatch.
-static GError* ErrorFromL1GLibError(Napi::Env env, Napi::Value v, const char* argName) {
-  Napi::Object err = v.As<Napi::Object>();
-  Napi::Value quark = err.Get("domainQuark");
-  Napi::Value domain = err.Get("domain");
-  GQuark gq = 0;
-  if (quark.IsNumber()) gq = static_cast<GQuark>(NodeGiToUint32(quark));
-  else if (domain.IsString())
-    gq = g_quark_from_string(domain.As<Napi::String>().Utf8Value().c_str());
-  if (gq == 0) {
-    ThrowExpectedGLibError(env, argName, "a GLib.Error with no domain");
-    return nullptr;
-  }
-  Napi::Value message = err.Get("message");
-  std::string text = message.IsString() ? message.As<Napi::String>().Utf8Value() : std::string();
-  return g_error_new_literal(gq, NodeGiToInt32(err.Get("code")), text.c_str());
-}
-
 // "Gtk.Box" for an introspected GType, g_type_name() otherwise (a registerClass
 // subtype has no GI info of its own; its C name is still exact). The gjs twin is
 // GIWrapperBase::format_name() (refs/gjs/gi/wrapperutils.h).
@@ -541,8 +516,8 @@ bool JsToGIArgument(Napi::Env env, Napi::Value v, GITypeInfo* type, GIArgument*
                     CreatedClosures* closures,
                     CreatedBytes* bytes,
                     CreatedValues* values,
-                    CreatedErrors* errors,
-                    const char* argName) {
+                    const char* argName,
+                    NodeGiIntContext intContext) {
   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
@@ -562,16 +537,24 @@ bool JsToGIArgument(Napi::Env env, Napi::Value v, GITypeInfo* type, GIArgument*
   GITypeTag tag = gi_type_info_get_tag(type);
   switch (tag) {
     case GI_TYPE_TAG_BOOLEAN: out->v_boolean = NodeGiToBool(v); return true;
-    case GI_TYPE_TAG_INT8: out->v_int8 = static_cast<int8_t>(NodeGiToInt32(v)); return true;
-    case GI_TYPE_TAG_UINT8: out->v_uint8 = static_cast<uint8_t>(NodeGiToUint32(v)); return true;
-    case GI_TYPE_TAG_INT16: out->v_int16 = static_cast<int16_t>(NodeGiToInt32(v)); return true;
-    case GI_TYPE_TAG_UINT16: out->v_uint16 = static_cast<uint16_t>(NodeGiToUint32(v)); return true;
-    case GI_TYPE_TAG_INT32: out->v_int32 = NodeGiToInt32(v); return true;
-    case GI_TYPE_TAG_UINT32: out->v_uint32 = NodeGiToUint32(v); return true;
-    // 64-bit: accept a BigInt losslessly (else a Number, truncated) — never let a
-    // BigInt reach ToNumber() (fatal abort). See JsValueTo{Int,Uint}64 in common.h.
-    case GI_TYPE_TAG_INT64: out->v_int64 = JsValueToInt64(v); return true;
-    case GI_TYPE_TAG_UINT64: out->v_uint64 = JsValueToUint64(v); return true;
+    case GI_TYPE_TAG_INT8:
+    case GI_TYPE_TAG_UINT8:
+    case GI_TYPE_TAG_INT16:
+    case GI_TYPE_TAG_UINT16:
+    case GI_TYPE_TAG_INT32:
+    case GI_TYPE_TAG_UINT32:
+    case GI_TYPE_TAG_INT64:
+    case GI_TYPE_TAG_UINT64: {
+      std::string shown;
+      switch (NodeGiJsToInteger(v, tag, out, &shown)) {
+        case NodeGiIntResult::kOk: return true;
+        case NodeGiIntResult::kPending: return false;
+        case NodeGiIntResult::kOutOfRange:
+          NodeGiThrowIntOutOfRange(env, tag, intContext, argName, shown);
+          return false;
+      }
+      return false;
+    }
     case GI_TYPE_TAG_FLOAT: out->v_float = static_cast<float>(NodeGiToDouble(v)); return true;
     case GI_TYPE_TAG_DOUBLE: out->v_double = NodeGiToDouble(v); return true;
     case GI_TYPE_TAG_UTF8:
@@ -829,43 +812,35 @@ bool JsToGIArgument(Napi::Env env, Napi::Value v, GITypeInfo* type, GIArgument*
         out->v_pointer = nullptr;
         return true;
       }
-      // Shape 1: the boxed handle a GError-typed return/OUT produced. Ownership is
-      // the ordinary boxed one and TransferBoxedIn supplies it: transfer-none is a
-      // borrow, transfer-full hands the callee an independent g_error_copy
-      // (g_propagate_error ADOPTS and frees its `src`) so the JS handle's finalizer
-      // cannot double-free it. Measured against gjs: after `GLib.propagate_error(e)`
-      // the original `e` is still readable there too.
+      // There is exactly ONE shape to accept: the boxed handle every GError reaching
+      // JS carries, whether it was marshalled out, copied, constructed or thrown
+      // (L1's wrapGError puts the same handle on all four). The second arm this used
+      // to need — rebuilding a GError from an L1 Error subclass's JS fields — is gone
+      // with the subclass itself.
+      //
+      // Ownership is the ordinary boxed one and TransferBoxedIn supplies it:
+      // transfer-none is a borrow, transfer-full hands the callee an independent
+      // g_error_copy (g_propagate_error ADOPTS and frees its `src`) so the JS
+      // handle's finalizer cannot double-free it. Measured against gjs: after
+      // `GLib.propagate_error(e)` the original `e` is still readable there too.
       //
       // Type-safety is UNCONDITIONAL here, unlike the struct/boxed arm's "compare
       // only when both sides carry a registered GType": the expected type is known
       // (G_TYPE_ERROR, always), so a handle without it is a wrong pointer — and a
       // wrong pointer in a GError slot is a wild dereference inside GLib.
       BoxedHandle* h = TryGetBoxedHandle(v);
-      if (h != nullptr) {
-        if (h->gtype == G_TYPE_INVALID || !g_type_is_a(h->gtype, G_TYPE_ERROR)) {
-          ThrowExpectedGLibError(env, argName,
-                                 h->gtype != G_TYPE_INVALID ? g_type_name(h->gtype)
-                                                            : InformalValueTypeName(v));
-          return false;
-        }
-        out->v_pointer = TransferBoxedIn(h, transfer);
-        return true;
+      if (h == nullptr) {
+        ThrowExpectedGLibError(env, argName, InformalValueTypeName(v));
+        return false;
       }
-      // Shape 2: the L1 `GLib.Error` JS class — a caught error, or one built with
-      // `new GLib.Error(…)`. It carries no GError*, so build one and release it per
-      // transfer (CreatedErrors, the rule GBytes and GValue already follow). gjs has
-      // ONE object for both shapes and accepts either; refusing this one left the
-      // hand-back the OUT direction exists for closed to exactly the errors an
-      // application has in hand.
-      if (errors != nullptr && IsL1GLibError(env, v)) {
-        GError* built = ErrorFromL1GLibError(env, v, argName);
-        if (built == nullptr) return false;  // ErrorFromL1GLibError already threw
-        out->v_pointer = built;
-        errors->Record(built, transfer);
-        return true;
+      if (h->gtype == G_TYPE_INVALID || !g_type_is_a(h->gtype, G_TYPE_ERROR)) {
+        ThrowExpectedGLibError(
+            env, argName,
+            h->gtype != G_TYPE_INVALID ? g_type_name(h->gtype) : InformalValueTypeName(v));
+        return false;
       }
-      ThrowExpectedGLibError(env, argName, InformalValueTypeName(v));
-      return false;
+      out->v_pointer = TransferBoxedIn(h, transfer);
+      return true;
     }
     default:
       Napi::TypeError::New(
@@ -995,23 +970,10 @@ Napi::Value GIArgumentToJs(Napi::Env env, GITypeInfo* type, GIArgument* arg,
     }
     case GI_TYPE_TAG_ERROR: {
       // A GError-typed value (a `GLib.Error` return like Gtk.GLArea.get_error(),
-      // or a GLib.Error.new_literal construct): GJS surfaces it as a GLib.Error
-      // boxed (G_TYPE_ERROR) with `.domain`/`.code`/`.message` field access +
-      // `.matches()`/`.copy()` methods. Wrap through the GLib.Error struct info
-      // so the boxed handle resolves fields and methods; a NULL GError (the
-      // no-error case) stays null. WrapBoxed handles transfer: a transfer-none
-      // borrow is g_boxed_copy'd into an owned copy, transfer-full is adopted.
-      GError* gerr = static_cast<GError*>(arg->v_pointer);
-      if (gerr == nullptr) return env.Null();
-      GIRepository* repo = DupDefaultRepository();
-      // GLib is loaded by any namespace require; require defensively anyway so a
-      // bare engine call still resolves the struct info (idempotent, cheap).
-      gi_repository_require(repo, "GLib", "2.0", static_cast<GIRepositoryLoadFlags>(0), nullptr);
-      GIBaseInfo* errInfo = gi_repository_find_by_name(repo, "GLib", "Error");
-      Napi::Value result = WrapBoxed(env, gerr, errInfo, transfer);
-      if (errInfo != nullptr) gi_base_info_unref(errInfo);
-      g_object_unref(repo);
-      return result;
+      // or a GLib.Error.new_literal construct). The same handle a THROWN error
+      // carries, so L1 builds the same object from both — a NULL GError (the
+      // no-error case) stays null.
+      return MakeGErrorHandle(env, static_cast<GError*>(arg->v_pointer), transfer);
     }
     default:
       Napi::TypeError::New(env, "Unsupported return type tag " +
@@ -1639,21 +1601,36 @@ Napi::Value ReadOutOrReturn(Napi::Env env, GICallableInfo* callable, GITypeInfo*
 // the element, so it gets a ref (objects) or an independent copy (boxed) instead.
 // Throws + returns false on an unsupported element.
 static bool ElementToGIArgument(Napi::Env env, GITypeInfo* elem, Napi::Value v, GIArgument* a,
-                                GITransfer elemTransfer) {
+                                GITransfer elemTransfer, bool wrapIntegers = false) {
   memset(a, 0, sizeof(*a));
   switch (gi_type_info_get_tag(elem)) {
     // Scalar coercions via the terminate-safe helpers (common.h): a swallowed
     // napi failure mid worker.terminate() must degrade to a zero, not cascade
     // into Error::New(nullptr)'s fatal sites.
     case GI_TYPE_TAG_BOOLEAN: a->v_boolean = NodeGiToBool(v); return true;
-    case GI_TYPE_TAG_INT8: a->v_int8 = static_cast<gint8>(NodeGiToInt32(v)); return true;
-    case GI_TYPE_TAG_UINT8: a->v_uint8 = static_cast<guint8>(NodeGiToUint32(v)); return true;
-    case GI_TYPE_TAG_INT16: a->v_int16 = static_cast<gint16>(NodeGiToInt32(v)); return true;
-    case GI_TYPE_TAG_UINT16: a->v_uint16 = static_cast<guint16>(NodeGiToUint32(v)); return true;
-    case GI_TYPE_TAG_INT32: a->v_int32 = NodeGiToInt32(v); return true;
-    case GI_TYPE_TAG_UINT32: a->v_uint32 = NodeGiToUint32(v); return true;
-    case GI_TYPE_TAG_INT64: a->v_int64 = JsValueToInt64(v); return true;
-    case GI_TYPE_TAG_UINT64: a->v_uint64 = JsValueToUint64(v); return true;
+    // Integers WRAP here, in an array (arg.cpp gjs_array_to_auto_array) — see
+    // NodeGiJsToIntegerWrap (common.h). A GList/GHashTable element keeps the older
+    // coercion: gjs's rule for those is not probed yet.
+    case GI_TYPE_TAG_INT8:
+    case GI_TYPE_TAG_UINT8:
+    case GI_TYPE_TAG_INT16:
+    case GI_TYPE_TAG_UINT16:
+    case GI_TYPE_TAG_INT32:
+    case GI_TYPE_TAG_UINT32:
+    case GI_TYPE_TAG_INT64:
+    case GI_TYPE_TAG_UINT64:
+      if (wrapIntegers)
+        return NodeGiJsToIntegerWrap(v, gi_type_info_get_tag(elem), a) == NodeGiIntResult::kOk;
+      switch (gi_type_info_get_tag(elem)) {
+        case GI_TYPE_TAG_INT8: a->v_int8 = static_cast<gint8>(NodeGiToInt32(v)); return true;
+        case GI_TYPE_TAG_UINT8: a->v_uint8 = static_cast<guint8>(NodeGiToUint32(v)); return true;
+        case GI_TYPE_TAG_INT16: a->v_int16 = static_cast<gint16>(NodeGiToInt32(v)); return true;
+        case GI_TYPE_TAG_UINT16: a->v_uint16 = static_cast<guint16>(NodeGiToUint32(v)); return true;
+        case GI_TYPE_TAG_INT32: a->v_int32 = NodeGiToInt32(v); return true;
+        case GI_TYPE_TAG_UINT32: a->v_uint32 = NodeGiToUint32(v); return true;
+        case GI_TYPE_TAG_INT64: a->v_int64 = JsValueToInt64(v); return true;
+        default: a->v_uint64 = JsValueToUint64(v); return true;
+      }
     case GI_TYPE_TAG_FLOAT: a->v_float = static_cast<gfloat>(NodeGiToDouble(v)); return true;
     case GI_TYPE_TAG_DOUBLE: a->v_double = NodeGiToDouble(v); return true;
     case GI_TYPE_TAG_GTYPE: {
@@ -1861,7 +1838,10 @@ bool JsToAnswerArgument(Napi::Env env, Napi::Value v, GITypeInfo* ti, GITransfer
   }
   std::string held;
   return JsToGIArgument(env, v, ti, out, &held, transfer, nullptr, nullptr, nullptr, nullptr,
-                        nullptr, argName);
+                        argName,
+                        argName != nullptr && strcmp(argName, "return value") == 0
+                            ? NodeGiIntContext::kReturnValue
+                            : NodeGiIntContext::kArgument);
 }
 
 }  // namespace
@@ -2320,7 +2300,8 @@ static bool JsToCArray(Napi::Env env, Napi::Value v, GITypeInfo* type, GITransfe
       continue;
     }
     GIArgument a;
-    ok = ElementToGIArgument(env, elem, arr.Get(static_cast<uint32_t>(i)), &a, elemTransfer);
+    ok = ElementToGIArgument(env, elem, arr.Get(static_cast<uint32_t>(i)), &a, elemTransfer,
+                             /*wrapIntegers=*/true);
     if (!ok) break;
     // Copy the element's storage bytes (LE: the low elemSize bytes of the union
     // alias the active field — v_string/v_pointer for pointers, the scalar
@@ -3020,7 +3001,8 @@ Napi::Value SetBoxedField(const Napi::CallbackInfo& info) {
   GIArgument arg;
   memset(&arg, 0, sizeof(arg));
   std::string heldString;
-  if (JsToGIArgument(env, value, ftype, &arg, &heldString, GI_TRANSFER_NOTHING, nullptr)) {
+  if (JsToGIArgument(env, value, ftype, &arg, &heldString, GI_TRANSFER_NOTHING, nullptr,
+                     nullptr, nullptr, nullptr, name.c_str(), NodeGiIntContext::kField)) {
     if (!gi_field_info_set_field(field, bh->ptr, &arg)) {
       Napi::Error::New(env, std::string("Writing field ") + typeName + "." + name + " is not supported")
           .ThrowAsJavaScriptException();