node-gtk 1.0.0 → 2.0.0

package/scripts/build-test-fixtures.js

@@ -0,0 +1,237 @@
+/*
+ * build-test-fixtures.js
+ *
+ * Makes the gobject-introspection test libraries (Utility, GIMarshallingTests,
+ * Regress) available for node-gtk's test suite. These libraries systematically
+ * exercise marshalling of every GObject type in every direction
+ * (in/out/inout/return), so they let us test node-gtk's type conversions
+ * exhaustively instead of ad-hoc.
+ *
+ * Strategy: always build from a single pinned upstream source revision, on
+ * every platform. Distro-shipped copies (the gobject-introspection package's
+ * bundled tests, or prebuilt gjs `installed-tests` typelibs) vary wildly by
+ * version — functions and types present on one machine are absent on another —
+ * which makes the test suite non-portable. Pinning one revision of the
+ * canonical `gobject-introspection-tests` repo and compiling it ourselves gives
+ * every machine (dev, Linux CI, macOS CI) the exact same API surface.
+ *
+ * The pinned sources are downloaded once (as a tarball) and cached under
+ * tests/gi-fixtures/.src/; the compiled output goes to tests/gi-fixtures/
+ * ({NAME}-1.0.typelib + lib{name}.so). Both are git-ignored.
+ *
+ * Run directly (`node scripts/build-test-fixtures.js`) or via `npm test`
+ * (it runs as a pretest step). Idempotent: existing fixtures are reused unless
+ * --force is passed. To bump the upstream revision, change SOURCE_REF.
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { execFileSync, execSync } = require('child_process')
+
+const FIXTURES_DIR = path.join(__dirname, '..', 'tests', 'gi-fixtures')
+const SRC_CACHE_DIR = path.join(FIXTURES_DIR, '.src')
+const FORCE = process.argv.includes('--force')
+const VERBOSE = process.argv.includes('--verbose') || process.env.VERBOSE
+
+// Canonical upstream test sources, pinned to a specific revision so every
+// machine builds the identical API. Bump SOURCE_REF to update.
+const SOURCE_REPO = 'https://gitlab.gnome.org/GNOME/gobject-introspection-tests'
+const SOURCE_REF = '5987255086f59ca271a3a0aa53fbbb15b189be65'
+
+// Each fixture mirrors the upstream meson.build recipe: the GI namespace, its
+// shared-library basename, the source/header files that make it up, the
+// pkg-config packages it links, and the GI namespaces its typelib includes.
+// Order matters: Regress's typelib includes Utility, so Utility is built first.
+const FIXTURES = [
+  {
+    namespace: 'Utility',
+    library: 'utility',
+    identifierPrefix: 'Utility',
+    symbolPrefix: 'utility_',
+    sources: ['utility.c'],
+    headers: ['utility.h'],
+    packages: ['gobject-2.0'],
+    includes: ['GObject-2.0'],
+  },
+  {
+    namespace: 'GIMarshallingTests',
+    library: 'gimarshallingtests',
+    identifierPrefix: 'GIMarshallingTests',
+    symbolPrefix: 'gi_marshalling_tests_',
+    sources: ['gimarshallingtests.c', 'gimarshallingtestsextra.c'],
+    headers: ['gimarshallingtests.h', 'gimarshallingtestsextra.h'],
+    packages: ['gobject-2.0', 'gio-2.0'],
+    includes: ['Gio-2.0'],
+  },
+  {
+    namespace: 'Regress',
+    library: 'regress',
+    identifierPrefix: 'Regress',
+    symbolPrefix: 'regress_',
+    sources: ['annotation.c', 'drawable.c', 'foo.c', 'regress.c', 'regressextra.c'],
+    headers: ['annotation.h', 'drawable.h', 'foo.h', 'regress.h', 'regressextra.h'],
+    packages: ['gobject-2.0', 'gio-2.0', 'cairo', 'cairo-gobject'],
+    includes: ['Gio-2.0', 'cairo-1.0', 'Utility-1.0'],
+  },
+]
+
+function log(...args) {
+  console.log('[fixtures]', ...args)
+}
+function vlog(...args) {
+  if (VERBOSE) console.log('[fixtures]', ...args)
+}
+
+function pkgConfig(args) {
+  return execSync(`pkg-config ${args}`, { encoding: 'utf8' }).trim()
+}
+
+function which(bin) {
+  try {
+    return execFileSync('sh', ['-c', `command -v ${bin}`], { encoding: 'utf8' }).trim()
+  } catch (e) {
+    return null
+  }
+}
+
+function fixtureIsPresent(fixture) {
+  const typelib = path.join(FIXTURES_DIR, `${fixture.namespace}-1.0.typelib`)
+  const lib = path.join(FIXTURES_DIR, `lib${fixture.library}.so`)
+  return fs.existsSync(typelib) && fs.existsSync(lib)
+}
+
+// Download + extract the pinned upstream sources once; return the dir holding
+// the .c/.h files. Cached under SRC_CACHE_DIR/<ref>, keyed by revision.
+function ensureSources() {
+  const destDir = path.join(SRC_CACHE_DIR, SOURCE_REF)
+  // The repo's files live at the tarball root; a marker file confirms a
+  // complete previous extraction.
+  if (fs.existsSync(path.join(destDir, 'gimarshallingtests.c'))) {
+    vlog(`sources present at ${destDir}`)
+    return destDir
+  }
+
+  fs.mkdirSync(SRC_CACHE_DIR, { recursive: true })
+  const tarball = path.join(SRC_CACHE_DIR, `${SOURCE_REF}.tar.gz`)
+  const url = `${SOURCE_REPO}/-/archive/${SOURCE_REF}/src-${SOURCE_REF}.tar.gz`
+
+  log(`downloading test sources @ ${SOURCE_REF.slice(0, 12)}`)
+  execFileSync('curl', ['-fsSL', url, '-o', tarball], { stdio: VERBOSE ? 'inherit' : 'pipe' })
+
+  // The tarball extracts to a single top-level dir; strip it into destDir.
+  fs.mkdirSync(destDir, { recursive: true })
+  execFileSync('tar', ['xzf', tarball, '-C', destDir, '--strip-components=1'],
+    { stdio: VERBOSE ? 'inherit' : 'pipe' })
+  fs.unlinkSync(tarball)
+  return destDir
+}
+
+function buildFixture(fixture, srcDir, tools) {
+  const sources = fixture.sources.map(s => path.join(srcDir, s))
+  const headers = fixture.headers.map(h => path.join(srcDir, h))
+  if (![...sources, ...headers].every(fs.existsSync)) {
+    throw new Error(`sources for ${fixture.namespace} missing in ${srcDir}`)
+  }
+
+  const cflags = pkgConfig(`--cflags ${fixture.packages.join(' ')}`)
+  const libs = pkgConfig(`--libs ${fixture.packages.join(' ')}`)
+  const libPath = path.join(FIXTURES_DIR, `lib${fixture.library}.so`)
+  const girPath = path.join(FIXTURES_DIR, `${fixture.namespace}-1.0.gir`)
+  const typelibPath = path.join(FIXTURES_DIR, `${fixture.namespace}-1.0.typelib`)
+
+  // 1. shared library
+  const cc = process.env.CC || 'cc'
+  const compileCmd =
+    `${cc} -shared -fPIC -I"${srcDir}" ${cflags} ` +
+    `${sources.map(s => `"${s}"`).join(' ')} ${libs} -o "${libPath}"`
+  vlog(compileCmd)
+  execSync(compileCmd, { stdio: VERBOSE ? 'inherit' : 'pipe' })
+
+  // 2. introspection data (.gir)
+  const scanArgs = [
+    ...sources, ...headers,
+    '--warn-all',
+    '--namespace', fixture.namespace,
+    '--nsversion', '1.0',
+    '--identifier-prefix', fixture.identifierPrefix,
+    '--symbol-prefix', fixture.symbolPrefix,
+    '--library', fixture.library,
+    '--library-path', FIXTURES_DIR,
+    // So that --include of an already-built local fixture (e.g. Utility-1.0,
+    // which Regress depends on) resolves its .gir from our output dir.
+    '--add-include-path', FIXTURES_DIR,
+    ...fixture.includes.flatMap(i => ['--include', i]),
+    ...fixture.packages.flatMap(p => ['--pkg', p]),
+    '--cflags-begin', ...cflags.split(/\s+/).filter(Boolean), `-I${srcDir}`, '--cflags-end',
+    '--output', girPath,
+  ]
+  vlog(tools.scanner, scanArgs.join(' '))
+  execFileSync(tools.scanner, scanArgs, {
+    stdio: VERBOSE ? 'inherit' : 'pipe',
+    env: { ...process.env, LD_LIBRARY_PATH: `${FIXTURES_DIR}:${process.env.LD_LIBRARY_PATH || ''}` },
+  })
+
+  // 3. compiled typelib (--includedir resolves locally-built included girs)
+  execFileSync(tools.compiler, [girPath, '--includedir', FIXTURES_DIR, '--output', typelibPath], {
+    stdio: VERBOSE ? 'inherit' : 'pipe',
+  })
+
+  log(`built ${fixture.namespace}`)
+  return true
+}
+
+function main() {
+  fs.mkdirSync(FIXTURES_DIR, { recursive: true })
+
+  const allPresent = FIXTURES.every(fixtureIsPresent)
+  if (!FORCE && allPresent) {
+    vlog('all fixtures already present, skipping (use --force to rebuild)')
+    log(`available fixtures: ${FIXTURES.map(f => f.namespace).join(', ')}`)
+    return
+  }
+
+  const tools = {
+    scanner: which('g-ir-scanner'),
+    compiler: which('g-ir-compiler'),
+  }
+  if (!tools.scanner || !tools.compiler || !which('curl') || !which('tar')) {
+    log('WARNING: g-ir-scanner/g-ir-compiler/curl/tar not all available; ' +
+      'cannot build fixtures. Dependent tests will skip.')
+    return
+  }
+
+  let srcDir
+  try {
+    srcDir = ensureSources()
+  } catch (e) {
+    log(`WARNING: could not fetch test sources: ${e.message.split('\n')[0]}`)
+    log('dependent tests will skip')
+    return
+  }
+
+  const results = []
+  for (const fixture of FIXTURES) {
+    if (!FORCE && fixtureIsPresent(fixture)) {
+      vlog(`${fixture.namespace} already present, skipping`)
+      results.push({ fixture, ok: true })
+      continue
+    }
+    let ok = false
+    try {
+      ok = buildFixture(fixture, srcDir, tools)
+    } catch (e) {
+      log(`failed to build ${fixture.namespace}: ${e.message.split('\n')[0]}`)
+    }
+    if (!ok)
+      log(`WARNING: could not provide ${fixture.namespace}; dependent tests will skip`)
+    results.push({ fixture, ok })
+  }
+
+  const provided = results.filter(r => r.ok).map(r => r.fixture.namespace)
+  log(`available fixtures: ${provided.length ? provided.join(', ') : '(none)'}`)
+}
+
+if (require.main === module)
+  main()
+
+module.exports = { FIXTURES_DIR, FIXTURES }

package/scripts/ci.sh

@@ -42,14 +42,16 @@ function npm_test() {
 
     if [[ $(uname -s) == 'Darwin' ]]; then
         export GST_PLUGIN_SYSTEM_PATH=$(brew --prefix gstreamer)/lib/gstreamer-1.0;
+        # This branch calls mocha directly (not `npm test`), so the pretest
+        # fixture build does not run automatically; do it here. Best-effort:
+        # marshalling tests skip if fixtures cannot be produced on macOS.
+        npm run build:test-fixtures || true;
         npx mocha                                 \
                   --skip=callback                 \
-                  --skip=union__fields            \
                   tests/__run__.js
     else
         xvfb-run -a npm test --                   \
-                  --skip=callback                 \
-                  --skip=union__fields;
+                  --skip=callback;
     fi;
 }
 

package/src/boxed.cc

@@ -43,6 +43,17 @@ size_t Boxed::GetSize (GIBaseInfo *boxed_info) {
     }
 }
 
+gpointer AllocateBoxed (GType gtype, size_t size) {
+    // Registered boxed types are freed via g_boxed_free, which by GLib
+    // convention uses g_slice_free; match that with g_slice so freeing doesn't
+    // corrupt the slice allocator (#290, #213). Non-registered structs are
+    // freed with g_free, so allocate them with g_malloc0.
+    if (G_TYPE_IS_BOXED(gtype))
+        return g_slice_alloc0(size);
+    else
+        return g_malloc0(size);
+}
+
 static bool IsNoArgsConstructor (GIFunctionInfo *info) {
     auto flags = g_function_info_get_flags (info);
     return ((flags & GI_FUNCTION_IS_CONSTRUCTOR) != 0
@@ -162,7 +173,7 @@ static void BoxedConstructor(const Nan::FunctionCallbackInfo<Value> &info) {
         return;
     }
 
-    GIFunctionInfo* constructorInfo = NULL;
+    int n_constructor_args = -1;
 
     void *boxed = NULL;
     unsigned long size = 0;
@@ -201,6 +212,8 @@ static void BoxedConstructor(const Nan::FunctionCallbackInfo<Value> &info) {
 
         if (constructorInfo != NULL) {
 
+            n_constructor_args = g_callable_info_get_n_args(constructorInfo);
+
             FunctionInfo func(constructorInfo);
             GIArgument return_value;
             GError *error = NULL;
@@ -223,7 +236,7 @@ static void BoxedConstructor(const Nan::FunctionCallbackInfo<Value> &info) {
             boxed = return_value.v_pointer;
 
         } else if ((size = Boxed::GetSize(gi_info)) != 0) {
-            boxed = g_malloc0(size);
+            boxed = AllocateBoxed(gtype, size);
 
         } else {
             Nan::ThrowError("Boxed allocation failed: no constructor found");
@@ -250,7 +263,7 @@ static void BoxedConstructor(const Nan::FunctionCallbackInfo<Value> &info) {
 
     SET_OBJECT_GTYPE (self, gtype);
 
-    if (constructorInfo == NULL || g_callable_info_get_n_args(constructorInfo) == 0)
+    if (n_constructor_args <= 0)
         InitBoxedFromObject(self, info[0]);
 }
 
@@ -445,4 +458,21 @@ void* PointerFromWrapper(Local<Value> value) {
     return boxed;
 }
 
+void DisownBoxed(Local<Value> value) {
+    if (!value->IsObject())
+        return;
+
+    Local<Object> object = TO_OBJECT (value);
+    // Boxed wrappers store the data pointer in field 0 and the Boxed* in field 1.
+    if (object->InternalFieldCount() < 2)
+        return;
+
+    Boxed *box = static_cast<Boxed *>(object->GetAlignedPointerFromInternalField(1));
+    if (box != NULL) {
+        box->owns_memory = false;
+        box->data = NULL;
+    }
+    object->SetAlignedPointerInInternalField(0, NULL);
+}
+
 };

package/src/boxed.h

@@ -29,9 +29,22 @@ public:
     static size_t GetSize (GIBaseInfo *boxed_info) ;
 };
 
+// Allocate zero-filled backing memory for a boxed/struct instance. Registered
+// boxed types are freed with g_boxed_free (which, by GLib convention, uses
+// g_slice_free), so they must be allocated with g_slice — allocating them with
+// g_malloc0 and freeing with g_slice_free corrupts the slice allocator on
+// GLib builds where GSlice is a real slab allocator (#290, #213).
+gpointer                AllocateBoxed    (GType gtype, size_t size);
+
 Local<Function>         MakeBoxedClass   (GIBaseInfo *info);
 Local<FunctionTemplate> GetBoxedTemplate (GIBaseInfo *info, GType gtype);
 Local<Value>            WrapperFromBoxed (GIBaseInfo *info, void *data, ResourceOwnership ownership = kNone);
 void *                  PointerFromWrapper (Local<Value>);
 
+// Relinquish ownership of a boxed wrapper's memory: clears owns_memory so the
+// GC finalizer won't free it, and nulls the data pointer so later use fails
+// cleanly instead of touching freed memory. Used after an introspected method
+// that frees the instance itself (e.g. *_free / *_unref) — see #429.
+void                    DisownBoxed (Local<Value>);
+
 };

package/src/callback.cc

@@ -34,8 +34,18 @@ Callback::Callback(Local<Function> fn, GICallableInfo* callback_info, GIScopeTyp
     info = g_base_info_ref (callback_info);
     #ifdef GI_AVAILABLE_IN_1_72
     closure = g_callable_info_create_closure(info, &cif, Callback::Call, this);
+    /* On libffi 3.4+ the executable trampoline is a separate mapping from the
+     * writable ffi_closure, so the closure pointer is not itself callable and
+     * invoking it segfaults (#390, seen on Ubuntu 26 / libffi 3.5). Use the
+     * closure's native (executable) address instead. Fall back to the closure
+     * pointer if introspection can't supply one — passing NULL as the callback
+     * would break startup, since the bindings register callbacks at bootstrap. */
+    native_address = g_callable_info_get_closure_native_address(info, closure);
+    if (native_address == NULL)
+        native_address = (gpointer) closure;
     #else
     closure = g_callable_info_prepare_closure(info, &cif, Callback::Call, this);
+    native_address = (gpointer) closure;
     #endif
     scope_type = scope_type_;
 }
@@ -171,6 +181,7 @@ void Callback::Execute (GIArgument *result, GIArgument **args, Callback *callbac
             if (jsReturnArray->Length() != n_js_return_values) {
                 Throw::Error("Virtual function must return %u arguments but returned %u",
                         n_js_return_values, jsReturnArray->Length());
+                goto out;
             }
 
             if (hasVoidReturn)
@@ -194,6 +205,7 @@ void Callback::Execute (GIArgument *result, GIArgument **args, Callback *callbac
 
                 if (!success) {
                     Throw::InvalidReturnValue (&return_type_info, jsReturnValue);
+                    goto out;
                 }
             }
         }

package/src/callback.h

@@ -16,6 +16,7 @@ namespace GNodeJS {
 struct Callback {
     ffi_cif cif;
     ffi_closure *closure;
+    gpointer native_address; /* callable trampoline; may differ from closure on libffi 3.4+ */
     Nan::Persistent<Function> persistent;
     GICallableInfo *info;
     GIScopeType scope_type;

package/src/closure.cc

@@ -19,6 +19,41 @@ using Nan::Persistent;
 
 namespace GNodeJS {
 
+/*
+ * An (out)/(inout) signal parameter arrives as a GValue holding a *pointer* to
+ * the value (e.g. a gint* for an `(inout) (type int)` parameter), not the value
+ * itself. Dereference it in place so the argument holds the pointed-to value.
+ */
+static void LoadGIArgumentFromPointer (GITypeInfo *type_info, GIArgument *arg) {
+    gpointer ptr = arg->v_pointer;
+
+    if (ptr == NULL) {
+        memset(arg, 0, sizeof(*arg));
+        return;
+    }
+
+    switch (g_type_info_get_tag(type_info)) {
+        case GI_TYPE_TAG_BOOLEAN: arg->v_boolean = *(gboolean*) ptr; break;
+        case GI_TYPE_TAG_INT8:    arg->v_int8    = *(gint8*)    ptr; break;
+        case GI_TYPE_TAG_UINT8:   arg->v_uint8   = *(guint8*)   ptr; break;
+        case GI_TYPE_TAG_INT16:   arg->v_int16   = *(gint16*)   ptr; break;
+        case GI_TYPE_TAG_UINT16:  arg->v_uint16  = *(guint16*)  ptr; break;
+        case GI_TYPE_TAG_INT32:   arg->v_int32   = *(gint32*)   ptr; break;
+        case GI_TYPE_TAG_UNICHAR:
+        case GI_TYPE_TAG_UINT32:  arg->v_uint32  = *(guint32*)  ptr; break;
+        case GI_TYPE_TAG_INT64:   arg->v_int64   = *(gint64*)   ptr; break;
+        case GI_TYPE_TAG_UINT64:  arg->v_uint64  = *(guint64*)  ptr; break;
+        case GI_TYPE_TAG_FLOAT:   arg->v_float   = *(gfloat*)   ptr; break;
+        case GI_TYPE_TAG_DOUBLE:  arg->v_double  = *(gdouble*)  ptr; break;
+        case GI_TYPE_TAG_GTYPE:   arg->v_size    = *(gsize*)    ptr; break;
+        default:
+            // Pointer-like types (utf8, interface, array, list, ...): the value
+            // is itself a pointer stored at *ptr.
+            arg->v_pointer = *(gpointer*) ptr;
+            break;
+    }
+}
+
 GClosure *Closure::New (Local<Function> function, GICallableInfo* info, guint signalId) {
     Closure *closure = (Closure *) g_closure_new_simple (sizeof (*closure), GUINT_TO_POINTER(signalId));
     closure->persistent.Reset(function);
@@ -70,7 +105,16 @@ void Closure::Execute(GICallableInfo *info, guint signal_id,
                     ownership = kNone;
                 }
             }
-            if (g_arg_info_get_direction(&arg_info) == GI_DIRECTION_OUT) {
+
+            GIDirection direction = g_arg_info_get_direction(&arg_info);
+            if (direction == GI_DIRECTION_INOUT) {
+                // The GValue holds a pointer to the in/out value; dereference it
+                // so the handler receives the actual value (#405).
+                LoadGIArgumentFromPointer(&type_info, &argument);
+                ownership = kNone;
+            } else if (direction == GI_DIRECTION_OUT) {
+                // Pure out: there is no meaningful incoming value.
+                memset(&argument, 0, sizeof(argument));
                 ownership = kNone;
             }
 
@@ -104,7 +148,54 @@ void Closure::Execute(GICallableInfo *info, guint signal_id,
     if (!try_catch.HasCaught()
             && result.ToLocal(&return_value)) {
 
-        if (g_return_value) {
+        if (info) {
+            // Distribute the handler's return value across the signal's return
+            // value and its (out)/(inout) parameters, writing each back (#405).
+            // When there is more than one output the handler returns an array,
+            // mirroring how out-arguments are returned from a function call.
+            GIArgInfo  out_arg_info;
+            GITypeInfo out_type_info;
+
+            int n_outputs = (g_return_value != NULL) ? 1 : 0;
+            for (guint i = 1; i < n_param_values; i++) {
+                g_callable_info_load_arg(info, i - 1, &out_arg_info);
+                GIDirection d = g_arg_info_get_direction(&out_arg_info);
+                if (d == GI_DIRECTION_OUT || d == GI_DIRECTION_INOUT)
+                    n_outputs++;
+            }
+
+            bool from_array = n_outputs > 1 && return_value->IsArray();
+            int output_index = 0;
+
+            #define NEXT_OUTPUT() ( \
+                n_outputs <= 1 \
+                    ? return_value \
+                    : (from_array \
+                        ? Nan::Get(return_value.As<v8::Array>(), output_index++).ToLocalChecked() \
+                        : (output_index++, Nan::Undefined().As<Value>())))
+
+            if (g_return_value) {
+                if (!V8ToGValue (g_return_value, NEXT_OUTPUT(), kCopy))
+                    goto throw_exception;
+            }
+
+            for (guint i = 1; i < n_param_values; i++) {
+                g_callable_info_load_arg(info, i - 1, &out_arg_info);
+                GIDirection d = g_arg_info_get_direction(&out_arg_info);
+                if (d != GI_DIRECTION_OUT && d != GI_DIRECTION_INOUT)
+                    continue;
+
+                g_arg_info_load_type(&out_arg_info, &out_type_info);
+
+                GIArgument out_arg;
+                memcpy(&out_arg, &param_values[i].data[0], sizeof(GIArgument));
+                if (out_arg.v_pointer != NULL)
+                    V8ToOutGIArgument(&out_type_info, &out_arg, NEXT_OUTPUT(), true);
+            }
+
+            #undef NEXT_OUTPUT
+        }
+        else if (g_return_value) {
             if (!V8ToGValue (g_return_value, return_value, kCopy))
                 goto throw_exception;
         }

package/src/function.cc

@@ -55,7 +55,9 @@ static void* AllocateArgument (GIBaseInfo *arg_info) {
 
     GIBaseInfo* base_info = g_type_info_get_interface (&arg_type);
     size_t size = Boxed::GetSize (base_info);
-    void* pointer = g_malloc0(size);
+    GType gtype = g_registered_type_info_get_g_type (base_info);
+    // Match g_boxed_free's allocator for registered boxed types (#290, #213).
+    void* pointer = AllocateBoxed(gtype, size);
 
     g_base_info_unref(base_info);
     return pointer;
@@ -67,6 +69,35 @@ static bool IsMethod (GIBaseInfo *info) {
             (flags & GI_FUNCTION_IS_CONSTRUCTOR) == 0);
 }
 
+static bool EndsWith (const char *str, const char *suffix) {
+    size_t str_len = strlen (str);
+    size_t suffix_len = strlen (suffix);
+    return str_len >= suffix_len && strcmp (str + str_len - suffix_len, suffix) == 0;
+}
+
+/* True for an instance method that deallocates the instance itself — a *_free
+ * or *_unref on a boxed/struct/union. node-gtk's wrapper owns the memory and
+ * frees it on GC, so after such a call the wrapper must disown it or GC will
+ * double-free (#429). Restricted to boxed-like containers: GObject lifetime is
+ * handled separately, and gtk_widget_destroy() etc. don't free the wrapper. */
+static bool FreesInstance (GIFunctionInfo *info) {
+    if (!IsMethod (info))
+        return false;
+
+    const char *symbol = g_function_info_get_symbol (info);
+    if (symbol == NULL || !(EndsWith (symbol, "_free") || EndsWith (symbol, "_unref")))
+        return false;
+
+    GIBaseInfo *container = g_base_info_get_container (info);
+    if (container == NULL)
+        return false;
+
+    GIInfoType type = g_base_info_get_type (container);
+    return type == GI_INFO_TYPE_STRUCT
+        || type == GI_INFO_TYPE_UNION
+        || type == GI_INFO_TYPE_BOXED;
+}
+
 static bool ShouldSkipReturn(GIBaseInfo *info, GITypeInfo *return_type) {
     return g_type_info_get_tag(return_type) == GI_TYPE_TAG_VOID
         || g_callable_info_skip_return(info) == TRUE;
@@ -134,6 +165,7 @@ bool FunctionInfo::Init() {
 
     is_method = IsMethod(info);
     can_throw = g_callable_info_can_throw_gerror (info);
+    frees_instance = FreesInstance(info);
 
     n_callable_args = g_callable_info_get_n_args (info);
     n_total_args = n_callable_args;
@@ -208,14 +240,14 @@ bool FunctionInfo::Init() {
                     if (closure_i >= 0 && closure_i < n_callable_args)
                         call_parameters[closure_i].type = ParameterType::kSKIP;
 
-                    if (destroy_i < i) {
+                    if (destroy_i >= 0 && destroy_i < i) {
                         if (IsDirectionIn(call_parameters[destroy_i].direction))
                             n_in_args--;
                         if (IsDirectionOut(call_parameters[destroy_i].direction))
                             n_out_args--;
                     }
 
-                    if (closure_i < i) {
+                    if (closure_i >= 0 && closure_i < i) {
                         if (IsDirectionIn(call_parameters[closure_i].direction))
                             n_in_args--;
                         if (IsDirectionOut(call_parameters[closure_i].direction))
@@ -388,16 +420,16 @@ Local<Value> FunctionCall (
         }
         else if (param.type == ParameterType::kCALLBACK) {
             Callback *callback;
-            ffi_closure *closure;
+            gpointer callable; /* executable trampoline address (see Callback) */
 
             if (info[in_arg]->IsNullOrUndefined()) {
-                closure  = nullptr;
+                callable = nullptr;
                 callback = nullptr;
             } else {
                 GICallableInfo *callback_info = g_type_info_get_interface (&type_info);
                 GIScopeType scope_type = g_arg_info_get_scope(&arg_info);
                 callback = new Callback(info[in_arg].As<Function>(), callback_info, scope_type);
-                closure = callback->closure;
+                callable = callback->native_address;
                 g_base_info_unref (callback_info);
             }
 
@@ -414,7 +446,7 @@ Local<Value> FunctionCall (
                 callable_arg_values[closure_i].v_pointer = callback;
             }
 
-            callable_arg_values[i].v_pointer = closure;
+            callable_arg_values[i].v_pointer = callable;
             func->call_parameters[i].data.v_pointer = callback;
         }
 
@@ -440,6 +472,22 @@ Local<Value> FunctionCall (
                     param.data.v_pointer = callable_arg_values[i].v_pointer;
                     callable_arg_values[i].v_pointer = &param.data;
                 }
+                // For a transfer-container IN GList/GSList/GHashTable the callee
+                // frees the container; snapshot the (caller-owned) element
+                // pointers now so they can be freed after the call (#399).
+                else if (IsTransferContainerInList(&type_info,
+                            g_arg_info_get_ownership_transfer(&arg_info), direction)) {
+                    param.data = {};
+                    param.data.v_pointer = CaptureTransferContainerElements(
+                            &type_info, callable_arg_values[i].v_pointer);
+                }
+                // For a transfer-full IN boxed (or array of boxed) the callee
+                // frees the memory; hand it a copy so the JS wrapper's own
+                // memory isn't double-freed when it's finalized (#409).
+                else if (direction == GI_DIRECTION_IN
+                        && g_arg_info_get_ownership_transfer(&arg_info) == GI_TRANSFER_EVERYTHING) {
+                    CopyBoxedForTransferFullIn(&type_info, &callable_arg_values[i], param.length);
+                }
             }
 
             in_arg++;
@@ -538,6 +586,11 @@ Local<Value> FunctionCall (
                 delete callback;
             }
         }
+        else if (IsTransferContainerInList (&arg_type, transfer, direction)) {
+            // The callee already freed the container structure; free only the
+            // captured (caller-owned) elements, never the freed container (#399).
+            FreeTransferContainerElements (&arg_type, param.data.v_pointer);
+        }
         else {
             if (direction == GI_DIRECTION_INOUT || (direction == GI_DIRECTION_OUT && !g_arg_info_is_caller_allocates (&arg_info)))
                 FreeGIArgument (&arg_type, (GIArgument*)arg_value.v_pointer, transfer, direction);
@@ -546,6 +599,11 @@ Local<Value> FunctionCall (
         }
     }
 
+    // If this method freed the instance, drop node-gtk's ownership of it so the
+    // GC finalizer won't free it a second time (#429).
+    if (func->frees_instance && !didThrow)
+        DisownBoxed (info.This());
+
     #ifndef __linux__
         delete[] total_arg_values;
     #endif

package/src/function.h

@@ -33,6 +33,7 @@ struct FunctionInfo {
 
     bool is_method;
     bool can_throw;
+    bool frees_instance; /* a *_free/*_unref method that deallocates the instance (#429) */
 
     int n_callable_args;
     int n_total_args;