@gjsify/node-gi 0.64.11 → 0.64.13

package/gettext.d.ts

@@ -1,6 +1,11 @@
 // SPDX-License-Identifier: MIT
 // @gjsify/node-gi/gettext — types for the GJS `Gettext` module on Node.
 
+/**
+ * Re-derive the process's message languages from the platform. A no-op off Android; on Android
+ * call it after the user switches the app locale. Returns the `LANGUAGE` value set, or null.
+ */
+export function refreshLocale(): string | null;
 /** Look up `msgid` in the default domain. */
 export function gettext(msgid: string): string;
 /** Look up `msgid` in `domain`. */
@@ -63,3 +68,6 @@ export interface GettextModule {
 
 declare const Gettext: GettextModule;
 export default Gettext;
+
+/** Re-derive message languages from the platform (Android); null elsewhere. */
+export function refreshLocale(): string | null;

package/gettext.js

@@ -25,6 +25,14 @@
 import * as native from './index.js';
 import { ensureNative } from './index.js';
 import { requireGi } from './gi.js';
+import { refreshLocale } from '#host';
+
+/**
+ * Re-derive the process's message languages from the platform. A no-op off Android; on
+ * Android call it after the user switches the app locale (LANGUAGE is re-read per lookup).
+ * @returns {string | null}
+ */
+export { refreshLocale };
 
 // GLib is resolved on first lookup, not at import: loading a namespace walks the
 // typelib, and a module imported for its LocaleCategory alone should not pay for

package/gi.js

@@ -1190,8 +1190,11 @@ function runJsPropertySetter(handle, propertyName) {
     const up = instance[USER_PROTO];
     if (up === undefined) return;
     const set = findPropertySetter(up, propertyName);
-    if (set === undefined) return; // no JS accessor: the store is the single backing store
+    // No JS accessor: the store is the single backing store. The `false` tells the engine
+    // so, and it stops crossing for this (class, property) — see NodeGiEnvData::noJsSetter.
+    if (set === undefined) return false;
     set.call(instance, wrapReturn(native.getProperty(handle, propertyName)));
+    return true;
 }
 // Guarded because the addon paired with this JS may PREDATE it, and that pairing is
 // deliberate rather than hypothetical: gtk-os-suites.yml's shipped-closure legs run
@@ -1704,6 +1707,15 @@ function wrapInstance(handle, userProto) {
     // Built fresh, every `obj.m(…)` in a loop allocated a closure and re-asked for
     // the type name across the N-API boundary. Null prototype: `constructor` and
     // friends must not read as a cached thunk.
+    // Positive answers only: a GObject class never loses a property, so a hit is final
+    // and saves one boundary crossing per get/set; a miss stays a live lookup.
+    const knownProps = new Set();
+    const hasProp = (name) => {
+        if (knownProps.has(name)) return true;
+        if (!native.hasProperty(handle, name)) return false;
+        knownProps.add(name);
+        return true;
+    };
     const giMethodThunks = Object.create(null);
     const giMethodThunk = (prop) => {
         let thunk = giMethodThunks[prop];
@@ -1815,7 +1827,7 @@ function wrapInstance(handle, userProto) {
             const shim = objectPrototypeShim(prop);
             if (shim !== undefined) return (...args) => shim(handle, args);
             const propName = toKebab(prop);
-            if (native.hasProperty(handle, propName)) {
+            if (hasProp(propName)) {
                 // A READ materialises a custom property's value, exactly as GJS's generated
                 // getter writes the default into its private field on first look-up — which
                 // is what makes a LATER assignment of that same default silent. See the
@@ -1864,7 +1876,7 @@ function wrapInstance(handle, userProto) {
                     }
                 }
                 const propName = toKebab(prop);
-                if (native.hasProperty(handle, propName)) {
+                if (hasProp(propName)) {
                     // Equal-value guard, GJS's `_generateAccessors` setter verbatim:
                     // `if (value !== this[privateName]) { …; this.notify(name) }`
                     // (refs/gjs/modules/core/_common.js). GJS puts it in the accessor it
@@ -1886,6 +1898,12 @@ function wrapInstance(handle, userProto) {
                     // all three spellings onto it.
                     const custom = up !== undefined && customPropertiesByProto.get(up)?.has(propName) === true;
                     if (custom && materialise(propName)) {
+                        if (typeof native.setPropertyIfChanged === 'function') {
+                            // One crossing: the engine compares and stores. 2 = a value type it
+                            // does not decide (objects, enums…), so take the two-call path.
+                            const done = native.setPropertyIfChanged(handle, propName, unwrapArg(value));
+                            if (done !== 2) return true;
+                        }
                         if (wrapReturn(native.getProperty(handle, propName)) === value) return true;
                     }
                     native.setProperty(handle, propName, unwrapArg(value));
@@ -1903,7 +1921,7 @@ function wrapInstance(handle, userProto) {
                 // GI methods are resolved dynamically and are intentionally not reported.)
                 const up = t[USER_PROTO];
                 if (up !== undefined && findProtoDescriptor(up, prop) !== undefined) return true;
-                if (native.hasProperty(handle, toKebab(prop))) return true;
+                if (hasProp(toKebab(prop))) return true;
             }
             return false;
         },

package/gtk-runtime.d.ts

@@ -13,8 +13,6 @@ export function maybeReexecForGtkRuntime(): void;
 export function maybePrependGtkRuntimeDllPath(): void;
 /** Windows: wire the env for a full-windowing bundle's runtime data — GSettings schemas, gdk-pixbuf loaders, icon themes, fontconfig (no-op off win32 / for a display-free bundle). */
 export function maybeWireGtkWindowingEnv(): void;
-/** darwin: point libgda at the bundle's SQLite provider via `GDA_TOP_BUILD_DIR` (only when unset; no-op for a bundle without `lib/libgda-6.0/providers`). */
-export function wireGdaProviders(bundle: { dir: string }): void;
 /** Activate the bundled GTK runtime for the native engine, if one is present. */
 export function activateBundledGtkRuntime(native: {
     prependSearchPath: (p: string) => void;

package/gtk-runtime.js

@@ -641,26 +641,6 @@ export function maybeWireGtkWindowingEnv() {
     if (existsSync(gioModules)) setIfUnset('GIO_MODULE_DIR', gioModules);
 }
 
-/**
- * Point libgda at the bundle's database providers (darwin; `@gjsify/sqlite` / `node:sqlite`).
- *
- * libgda loads a provider as a GModule from a directory COMPILED IN as the build prefix —
- * `<keg>/lib/libgda-6.0/providers` — and, with that keg absent, `Gda.Connection.new_from_string
- * ('SQLite', …)` throws `No provider 'SQLite' installed`. With the keg PRESENT it is worse: brew's
- * provider loads against brew's libgda and glib beside the bundle's own. The one override libgda
- * has is `GDA_TOP_BUILD_DIR`, read as `<dir>/providers` at the first provider scan, which is long
- * after this runs. In the JS and not in a launcher for the reason `GJSIFY_GI_LIBRARY_PATH` is:
- * a signed app loses `DYLD_*`, never `process.env`.
- * Set only when unset, so an operator pointing libgda elsewhere wins; a no-op for a bundle
- * that carries no provider dir.
- * @param {{ dir: string }} bundle
- */
-export function wireGdaProviders(bundle) {
-    const gdaDir = join(bundle.dir, 'lib', 'libgda-6.0');
-    if (!existsSync(join(gdaDir, 'providers'))) return;
-    if (!process.env.GDA_TOP_BUILD_DIR) process.env.GDA_TOP_BUILD_DIR = gdaDir;
-}
-
 /** 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';
@@ -826,7 +806,6 @@ export function activateBundledGtkRuntime(native) {
             // variable REPLACES rather than extends.
             process.env.DYLD_FALLBACK_LIBRARY_PATH = composeDyldFallback([bundle.libDir]);
         }
-        wireGdaProviders(bundle);
     }
 
     activated = bundle;

package/host.nativescript.js

@@ -116,9 +116,130 @@ function deriveAppDir() {
     }
 }
 
+// A Vite-built app exposes only the `android.*` packages its own code touched, and nothing
+// touches `android.system` — so `android.system.Os` is undefined there and every setenv
+// silently did nothing (LANGUAGE and XDG_* never reached the native process). Reflection
+// reaches the class whatever the bundle referenced.
+function androidSetenv(name, value) {
+    const os = globalThis.android?.system?.Os;
+    if (os) {
+        os.setenv(name, value, true);
+        return;
+    }
+    const java = globalThis.java;
+    if (!java?.lang?.Class) return;
+    try {
+        const types = java.lang.reflect.Array.newInstance(java.lang.Class.class, 3);
+        java.lang.reflect.Array.set(types, 0, java.lang.String.class);
+        java.lang.reflect.Array.set(types, 1, java.lang.String.class);
+        java.lang.reflect.Array.set(types, 2, java.lang.Boolean.TYPE);
+        const args = java.lang.reflect.Array.newInstance(java.lang.Object.class, 3);
+        java.lang.reflect.Array.set(args, 0, name);
+        java.lang.reflect.Array.set(args, 1, value);
+        java.lang.reflect.Array.set(args, 2, java.lang.Boolean.TRUE);
+        java.lang.Class.forName('android.system.Os').getMethod('setenv', types).invoke(null, args);
+    } catch (e) {
+        globalThis.console?.warn?.(`node-gi: setenv(${name}) failed: ${e}`);
+    }
+}
+
 function setNativeEnv(name, value) {
     env[name] = value;
-    globalThis.android?.system?.Os?.setenv(name, value, true);
+    androidSetenv(name, value);
+}
+
+/**
+ * The LANGUAGE value for a list of BCP-47 tags: `de-DE` → `de_DE:de`, `zh-Hans-CN` → `zh_CN:zh`,
+ * de-duplicated, cut after the first English tag, with `C` last as GLib orders it. Bionic's setlocale accepts only C/C.UTF-8
+ * and Android sets no LANG, so GLib's language list (and the libintl in gi-runtime-android,
+ * which reads LANGUAGE on every lookup) has nothing else to go on. Pure — no device needed.
+ * @param {string[]} tags
+ * @returns {string}
+ */
+export function languageFromBcp47(tags) {
+    const out = [];
+    const add = (name) => {
+        if (!out.includes(name)) out.push(name);
+    };
+    for (const tag of tags) {
+        const parts = String(tag).split(/[-_]/).filter(Boolean);
+        if (parts.length === 0 || !/^[A-Za-z]{2,3}$/.test(parts[0])) continue;
+        const lang = parts[0].toLowerCase();
+        const region = parts.slice(1).find((p) => /^([A-Za-z]{2}|\d{3})$/.test(p));
+        if (region) add(`${lang}_${region.toUpperCase()}`);
+        add(lang);
+        // English is the msgid language, so no catalog exists for it and gettext would go on to
+        // the NEXT entry: with the app switched to en-US over a German system the list is
+        // [en-US, de-DE], and every string came back German. Nothing after English may apply.
+        if (lang === 'en') break;
+    }
+    add('C');
+    return out.join(':');
+}
+
+function platformLanguageTags() {
+    const locales = globalThis.android?.content?.res?.Resources?.getSystem?.()?.getConfiguration?.()?.getLocales?.();
+    const tags = [];
+    if (locales) {
+        for (let i = 0; i < locales.size(); i++) tags.push(String(locales.get(i).toLanguageTag()));
+    }
+    if (tags.length === 0) {
+        const one = globalThis.java?.util?.Locale?.getDefault?.();
+        if (one) tags.push(String(one.toLanguageTag()));
+    }
+    return tags;
+}
+
+/**
+ * Point LANGUAGE at the platform's current locale list. Call it again when the user
+ * switches the app's language: libintl and GLib re-read the variable, nothing is cached.
+ * The explicit __NODE_GI_LANGUAGE global wins, for a host that manages its own.
+ * @returns {string | null} the value set, or null when the platform gave nothing
+ */
+export function refreshLocale() {
+    let value = globalThis.__NODE_GI_LANGUAGE;
+    if (typeof value !== 'string' || value === '') {
+        try {
+            const tags = platformLanguageTags();
+            value = tags.length > 0 ? languageFromBcp47(tags) : null;
+        } catch {
+            value = null;
+        }
+    }
+    if (value === null || value === undefined) return null;
+    setNativeEnv('LANGUAGE', value);
+    return value;
+}
+
+let followingSystemLocale = false;
+
+/**
+ * Re-run `refreshLocale()` whenever the system configuration changes — a language switch is
+ * one. The Application-level ComponentCallbacks2 fires whether or not the activity declares
+ * `locale` in `configChanges`. Registered once, from the host that owns the LANGUAGE bridge,
+ * so no consumer has to know the variable exists.
+ * @returns {boolean} whether a callback is registered
+ */
+export function followSystemLocale() {
+    if (followingSystemLocale) return true;
+    try {
+        const app = globalThis.com?.tns?.NativeScriptApplication?.getInstance();
+        const ComponentCallbacks2 = globalThis.android?.content?.ComponentCallbacks2;
+        if (!app || !ComponentCallbacks2) return false;
+        app.registerComponentCallbacks(
+            new ComponentCallbacks2({
+                onConfigurationChanged: () => {
+                    refreshLocale();
+                },
+                onLowMemory: () => {},
+                onTrimMemory: () => {},
+            }),
+        );
+        followingSystemLocale = true;
+    } catch {
+        // A callback missing only costs the live switch; the locale at start is still set.
+    }
+    return followingSystemLocale;
 }
 
 function appDirectory() {
@@ -165,6 +286,8 @@ function ensureJavaVm(native) {
 }
 
 function configureEnvironment() {
+    refreshLocale();
+    followSystemLocale();
     const systemDir = globalThis.__NODE_GI_SYSTEM_DIR;
     if (typeof systemDir === 'string' && systemDir !== '') {
         setNativeEnv('XDG_DATA_DIRS', `${systemDir}/share`);

package/host.node.js

@@ -32,7 +32,21 @@ import { setImmediate, setInterval, clearInterval } from 'node:timers';
 // loop-liveness hooks in gi.js would silently never fire.
 import runtimeProcess from 'node:process';
 
-export { setImmediate, setInterval, clearInterval, runtimeProcess, windowingEnvWrites, bundledLocaleDir };
+// Only Android derives the locale from the platform (host.nativescript.js); a desktop
+// process already has LANG, so there is nothing to refresh.
+function refreshLocale() {
+    return null;
+}
+
+export {
+    setImmediate,
+    setInterval,
+    clearInterval,
+    runtimeProcess,
+    windowingEnvWrites,
+    bundledLocaleDir,
+    refreshLocale,
+};
 
 const require = createRequire(import.meta.url);
 const here = packageRoot;

package/index.d.ts

@@ -307,6 +307,13 @@ export function getProperty(handle: GObjectHandle, name: string): unknown;
 
 /** Write a GObject property. */
 export function setProperty(handle: GObjectHandle, name: string, value: unknown): void;
+/**
+ * `setProperty` with gi.js's equal-value guard folded in, so a guarded write is one crossing.
+ * Returns 0 when the value was stored, 1 when it equals the current one (nothing stored, no
+ * notify), 2 when the property's type is not decided here (objects, enums, …; nothing done).
+ * Absent from an addon older than this JS.
+ */
+export function setPropertyIfChanged(handle: GObjectHandle, name: string, value: unknown): 0 | 1 | 2;
 
 /**
  * Whether the instance's type has a GObject property by this name (kebab- or
@@ -632,6 +639,7 @@ declare const native: {
     getTemplateChild: typeof getTemplateChild;
     getProperty: typeof getProperty;
     setProperty: typeof setProperty;
+    setPropertyIfChanged?: typeof setPropertyIfChanged;
     hasProperty: typeof hasProperty;
     getTypeName: typeof getTypeName;
     classInfoForTypeName: typeof classInfoForTypeName;

package/index.js

@@ -67,6 +67,7 @@ export function ensureNative() {
     getTemplateChild = addon.getTemplateChild;
     getProperty = addon.getProperty;
     setProperty = addon.setProperty;
+    setPropertyIfChanged = addon.setPropertyIfChanged;
     hasProperty = addon.hasProperty;
     getTypeName = addon.getTypeName;
     classInfoForTypeName = addon.classInfoForTypeName;
@@ -177,6 +178,7 @@ export let callClassVfunc;
 export let getTemplateChild;
 export let getProperty;
 export let setProperty;
+export let setPropertyIfChanged;
 export let hasProperty;
 export let getTypeName;
 export let classInfoForTypeName;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjsify/node-gi",
-  "version": "0.64.11",
+  "version": "0.64.13",
   "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",
@@ -10,6 +10,7 @@
   "imports": {
     "#host": {
       "nativescript": "./host.nativescript.js",
+      "wasm": "./host.wasm.js",
       "default": "./host.node.js"
     }
   },

package/src/addon.cc

@@ -109,6 +109,7 @@ static Napi::Object Init(Napi::Env env, Napi::Object exports) {
   exports.Set("getTemplateChild", Napi::Function::New(env, GetTemplateChild));
   exports.Set("getProperty", Napi::Function::New(env, GetProperty));
   exports.Set("setProperty", Napi::Function::New(env, SetProperty));
+  exports.Set("setPropertyIfChanged", Napi::Function::New(env, SetPropertyIfChanged));
   exports.Set("hasProperty", Napi::Function::New(env, HasProperty));
   exports.Set("getTypeName", Napi::Function::New(env, GetTypeName));
   exports.Set("classInfoForTypeName", Napi::Function::New(env, ClassInfoForTypeName));

package/src/calls.cc

@@ -250,7 +250,7 @@ static void NodeGiCallbackTrampoline(ffi_cif* /*cif*/, void* result, void** args
       // napi_make_callback drains nextTick/microtasks around the call (Node; on
       // Bun/Deno the checkpoint is run by NodeGiMaybeDrainMicrotasks below).
       g_loopDispatchDepth++;
-      napi_status st = napi_make_callback(env, nullptr, global, fn, jsArgs.size(), jsArgs.data(), &ret);
+      napi_status st = NodeGiCallIntoJs(env, global, fn, jsArgs.size(), jsArgs.data(), &ret);
       g_loopDispatchDepth--;
       if (st != napi_ok) ret = nullptr;
     }

package/src/class.cc

@@ -264,7 +264,7 @@ static void NodeGiVFuncTrampoline(ffi_cif* /*cif*/, void* result, void** args,
       // wrapped instance is the receiver (`this`).
       g_loopDispatchDepth++;
       napi_status st =
-          napi_make_callback(env, nullptr, recv, fn, jsArgs.size(), jsArgs.data(), &ret);
+          NodeGiCallIntoJs(env, recv, fn, jsArgs.size(), jsArgs.data(), &ret);
       g_loopDispatchDepth--;
       if (st != napi_ok) ret = nullptr;
     }
@@ -387,6 +387,10 @@ static void MaybeRunJsPropertySetter(NodeGiClassData* cd, GObject* obj, const ch
   // Never enter JS during GC / env teardown (same gate as the vfunc trampoline and
   // RunJsConstructorForCObject); the property is already stored either way.
   if (!NodeGiJsAvailable(env)) return;
+  NodeGiEnvData* d = EnvData(env);
+  GParamSpec* pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(obj), name);
+  const std::pair<GType, GParamSpec*> memoKey(G_OBJECT_TYPE(obj), pspec);
+  if (d != nullptr && pspec != nullptr && d->noJsSetter.count(memoKey) != 0) return;
   Napi::Env napiEnv(env);
   Napi::HandleScope scope(napiEnv);
   NodeGiPumpJsDispatchScope pumpWindow;
@@ -394,7 +398,6 @@ static void MaybeRunJsPropertySetter(NodeGiClassData* cd, GObject* obj, const ch
   Napi::Value handle = PeekGObjectHandle(napiEnv, obj);
   if (handle.IsEmpty()) return;  // construction has not reached the wrap yet
 
-  NodeGiEnvData* d = EnvData(env);
   napi_value cb = nullptr;
   if (d == nullptr || d->propertySetCallback == nullptr ||
       napi_get_reference_value(env, d->propertySetCallback, &cb) != napi_ok || cb == nullptr) {
@@ -410,7 +413,19 @@ static void MaybeRunJsPropertySetter(NodeGiClassData* cd, GObject* obj, const ch
   // own frame and must not get a microtask checkpoint in the middle of it — the same
   // reasoning as RunJsConstructorForCObject, and gjs's JS_SetProperty takes no
   // checkpoint either.
-  if (napi_call_function(env, undef, cb, 2, args, &ret) != napi_ok) {
+  napi_status callStatus = napi_call_function(env, undef, cb, 2, args, &ret);
+  if (callStatus == napi_ok && pspec != nullptr && ret != nullptr) {
+    // gi.js answers a literal `false` only once the instance's prototype chain has been
+    // searched and holds no accessor; any other answer (no wrapper yet, a setter ran)
+    // keeps the crossing.
+    bool isBool = false;
+    napi_valuetype vt = napi_undefined;
+    if (napi_typeof(env, ret, &vt) == napi_ok && vt == napi_boolean &&
+        napi_get_value_bool(env, ret, &isBool) == napi_ok && !isBool) {
+      d->noJsSetter.insert(memoKey);
+    }
+  }
+  if (callStatus != napi_ok) {
     // The setter threw. A pending JS exception must never cross back into GObject
     // (g_object_set has no way to report one), so fold it into a g_warning — gjs logs
     // the uncaught exception at the same point (gjs_log_exception_uncaught).

package/src/common.h

@@ -53,6 +53,8 @@
 #include <map>
 #include <memory>
 #include <mutex>
+#include <set>
+#include <unordered_map>
 #include <string>
 #include <thread>
 #include <vector>
@@ -114,6 +116,17 @@ struct NodeGiEnvData {
   // setter from its set_property vfunc (refs/gjs/gi/gobject.cpp jsobj_set_gproperty).
   // Per-env for the same reason as errorBuilder (a napi_ref is env-specific).
   napi_ref propertySetCallback = nullptr;
+  // (instance GType, pspec) pairs for which gi.js answered "this class chain declares
+  // no JS accessor" — the store is then the whole write and NodeGiSetProperty skips the
+  // JS crossing. Keyed by the INSTANCE's GType because a subclass may add an accessor
+  // its parent lacks; mirrors gi.js's per-prototype memo, so the answer is as final as
+  // it is there.
+  std::set<std::pair<GType, GParamSpec*>> noJsSetter;
+  // One JS External per GParamSpec handed out by GValueToJs (a `notify` emission passes
+  // the pspec every time). Minting a finalizable External per emission is the dominant
+  // cost of a notify on Wasm; the ref (count 1) keeps the External, which keeps the
+  // pspec ref, until env teardown.
+  std::unordered_map<GParamSpec*, napi_ref> paramSpecHandles;
 };
 
 void NodeGiEnvDataFinalize(napi_env env, void* data, void* hint);
@@ -702,6 +715,27 @@ extern int g_syncEmitDepth;
 // InternalCallbackScopes and GJS's "drain when the last JS frame exits" do.
 extern int g_loopDispatchDepth;
 
+// Enter JS at a loop-dispatched callback boundary (signals.cc / calls.cc /
+// class.cc / loop.cc / private.cc). On a real Node-API host this is
+// napi_make_callback, which runs the nextTick + microtask checkpoint at the
+// boundary. Under Emscripten the Node-API host is emnapi, whose
+// napi_make_callback is a thin forward to @emnapi/node-binding and returns
+// napi_generic_failure whenever that binding is absent — which it always is
+// outside Node, i.e. in every browser. The call then fails SILENTLY: the GI
+// callback returns FALSE, the GSource is removed, and no handler ever runs.
+// napi_call_function is the portable entry; the checkpoint it skips is the one
+// NodeGiMaybeDrainMicrotasks already performs for Bun/Deno, and the wasm host
+// registers the same drain (host.wasm.js).
+static inline napi_status NodeGiCallIntoJs(napi_env env, napi_value recv, napi_value fn,
+                                           size_t argc, const napi_value* argv,
+                                           napi_value* result) {
+#ifdef __EMSCRIPTEN__
+  return napi_call_function(env, recv, fn, argc, argv, result);
+#else
+  return napi_make_callback(env, nullptr, recv, fn, argc, argv, result);
+#endif
+}
+
 // Cross-runtime microtask checkpoint (Bun/Deno — see loop.cc). Invokes the
 // runtime-native drain registered via setMicrotaskDrain after an outermost
 // loop-dispatched callback returns; a no-op on Node (never registered), with a
@@ -883,6 +917,7 @@ Napi::Value IsFundamentalHandle(const Napi::CallbackInfo& info);
 Napi::Value NewObject(const Napi::CallbackInfo& info);
 Napi::Value GetProperty(const Napi::CallbackInfo& info);
 Napi::Value SetProperty(const Napi::CallbackInfo& info);
+Napi::Value SetPropertyIfChanged(const Napi::CallbackInfo& info);
 Napi::Value HasProperty(const Napi::CallbackInfo& info);
 Napi::Value GetTypeName(const Napi::CallbackInfo& info);
 Napi::Value ClassInfoForTypeName(const Napi::CallbackInfo& info);

package/src/loop.cc

@@ -107,7 +107,7 @@ static void DrainMicrotasks() {
   if (napi_get_reference_value(env, g_process_ref, &process_v) == napi_ok &&
       napi_get_reference_value(env, g_tick_callback_ref, &tick) == napi_ok &&
       process_v != nullptr && tick != nullptr) {
-    napi_make_callback(env, nullptr, process_v, tick, 0, nullptr, &result);
+    NodeGiCallIntoJs(env, process_v, tick, 0, nullptr, &result);
   }
   napi_close_handle_scope(env, scope);
 }

package/src/object.cc

@@ -304,7 +304,24 @@ Napi::Value GValueToJs(Napi::Env env, const GValue* v) {
       // .name/.get_name()/.value_type/.nick/.blurb/.flags/.owner_type — matching
       // gjs. g_value_get_param BORROWS (transfer none).
       GParamSpec* p = g_value_get_param(v);
-      return MakeParamSpecHandle(env, p, GI_TRANSFER_NOTHING);
+      if (p == nullptr) return env.Null();
+      NodeGiEnvData* d = EnvData(env);
+      if (d == nullptr) return MakeParamSpecHandle(env, p, GI_TRANSFER_NOTHING);
+      auto hit = d->paramSpecHandles.find(p);
+      if (hit != d->paramSpecHandles.end()) {
+        napi_value cached = nullptr;
+        if (napi_get_reference_value(env, hit->second, &cached) == napi_ok && cached != nullptr) {
+          return Napi::Value(env, cached);
+        }
+      }
+      Napi::Value fresh = MakeParamSpecHandle(env, p, GI_TRANSFER_NOTHING);
+      if (!fresh.IsEmpty() && fresh.IsExternal()) {
+        napi_ref ref = nullptr;
+        if (napi_create_reference(env, fresh, 1, &ref) == napi_ok && ref != nullptr) {
+          d->paramSpecHandles[p] = ref;
+        }
+      }
+      return fresh;
     }
     default:
       Napi::TypeError::New(env, std::string("Unsupported property GType ") +
@@ -765,7 +782,11 @@ Napi::Value GetProperty(const Napi::CallbackInfo& info) {
 }
 
 // setProperty(handle, name, value) -> void
-Napi::Value SetProperty(const Napi::CallbackInfo& info) {
+// setPropertyIfChanged(handle, name, value) -> 0 stored | 1 equal, nothing done | 2 undecided,
+// nothing done. Folds gi.js's equal-value guard (`wrapReturn(getProperty) === value`) into the
+// store so a guarded set is ONE crossing. Only the types whose JS form compares by value are
+// decided here; anything else (objects, boxed, enums…) answers 2 and gi.js takes the two-call path.
+static Napi::Value SetPropertyImpl(const Napi::CallbackInfo& info, bool guarded) {
   Napi::Env env = info.Env();
   if (info.Length() < 3 || !info[1].IsString()) {
     Napi::TypeError::New(env, "setProperty(handle, name: string, value)").ThrowAsJavaScriptException();
@@ -782,6 +803,26 @@ Napi::Value SetProperty(const Napi::CallbackInfo& info) {
   // gjs refuses an out-of-range value for these property types on assignment
   // (object.cpp, with its own text); JsToGValue below now refuses them too, with the
   // gjs_value_to_g_value text.
+  if (guarded) {
+    switch (G_TYPE_FUNDAMENTAL(pspec->value_type)) {
+      case G_TYPE_BOOLEAN: case G_TYPE_CHAR: case G_TYPE_UCHAR: case G_TYPE_INT:
+      case G_TYPE_UINT: case G_TYPE_LONG: case G_TYPE_ULONG: case G_TYPE_INT64:
+      case G_TYPE_UINT64: case G_TYPE_FLOAT: case G_TYPE_DOUBLE: case G_TYPE_STRING:
+        break;
+      default:
+        return Napi::Number::New(env, 2);
+    }
+    GValue cur = G_VALUE_INIT;
+    g_value_init(&cur, pspec->value_type);
+    g_object_get_property(obj, name.c_str(), &cur);
+    Napi::Value curJs = GValueToJs(env, &cur);
+    g_value_unset(&cur);
+    if (env.IsExceptionPending()) return env.Undefined();
+    bool same = false;
+    if (!curJs.IsEmpty() && napi_strict_equals(env, curJs, info[2], &same) == napi_ok && same) {
+      return Napi::Number::New(env, 1);
+    }
+  }
   GITypeTag intTag = GI_TYPE_TAG_VOID;
   switch (G_TYPE_FUNDAMENTAL(pspec->value_type)) {
     case G_TYPE_CHAR: intTag = GI_TYPE_TAG_INT8; break;
@@ -809,7 +850,12 @@ Napi::Value SetProperty(const Napi::CallbackInfo& info) {
     g_object_set_property(obj, name.c_str(), &v);
   }
   g_value_unset(&v);
-  return env.Undefined();
+  return guarded ? Napi::Number::New(env, 0).As<Napi::Value>() : env.Undefined();
+}
+
+Napi::Value SetProperty(const Napi::CallbackInfo& info) { return SetPropertyImpl(info, false); }
+Napi::Value SetPropertyIfChanged(const Napi::CallbackInfo& info) {
+  return SetPropertyImpl(info, true);
 }
 
 // getTypeName(handle) -> string   (the runtime GType name of an instance)

package/src/private.cc

@@ -109,7 +109,7 @@ static GLogWriterOutput NodeGiLogWriterWrapper(GLogLevelFlags log_level, const G
   napi_get_global(env, &global);
   napi_value args[2] = {Napi::Number::New(napiEnv, static_cast<double>(log_level)), obj};
   napi_value ret = nullptr;
-  napi_status st = napi_make_callback(env, nullptr, global, fn, 2, args, &ret);
+  napi_status st = NodeGiCallIntoJs(env, global, fn, 2, args, &ret);
   if (st != napi_ok || napiEnv.IsExceptionPending()) {
     // A throwing writer must never wedge the logging path (nor leave a pending
     // exception across the C boundary): surface + clear, then default-write.
@@ -209,7 +209,7 @@ static gboolean NodeGiBindingTransformInvoke(GBinding* binding, const GValue* fr
   napi_value global = nullptr;
   napi_get_global(env, &global);
   napi_value ret = nullptr;
-  napi_status st = napi_make_callback(env, nullptr, global, fn, 2, args, &ret);
+  napi_status st = NodeGiCallIntoJs(env, global, fn, 2, args, &ret);
   if (st != napi_ok || napiEnv.IsExceptionPending()) {
     SurfacePendingException(env, "property binding transform");
     return FALSE;

package/src/repo.cc

@@ -19,6 +19,7 @@ void NodeGiEnvDataFinalize(napi_env env, void* data, void* /*hint*/) {
   if (d->microtaskDrain != nullptr) napi_delete_reference(env, d->microtaskDrain);
   if (d->constructCallback != nullptr) napi_delete_reference(env, d->constructCallback);
   if (d->propertySetCallback != nullptr) napi_delete_reference(env, d->propertySetCallback);
+  for (auto& kv : d->paramSpecHandles) napi_delete_reference(env, kv.second);
   delete d;
 }
 

package/src/signals.cc

@@ -142,7 +142,7 @@ static void JsClosureMarshalImpl(GClosure* closure, GValue* return_value, guint
     napi_value global = nullptr;
     napi_get_global(jc->env, &global);
     g_loopDispatchDepth++;
-    st = napi_make_callback(jc->env, nullptr, global, cbv, args.size(), args.data(), &result);
+    st = NodeGiCallIntoJs(jc->env, global, cbv, args.size(), args.data(), &result);
     g_loopDispatchDepth--;
   }
   if (st != napi_ok) {