node-gtk 1.0.0 → 2.1.0

package/lib/register-class.js

@@ -119,7 +119,7 @@ function findVFuncOnParents(info, name) {
 function findVFuncOnInterfaces(gtype, name) {
   const interfaces = GObject.typeInterfaces(gtype);
 
-  for (i = 0; i < interfaces.length; i++) {
+  for (let i = 0; i < interfaces.length; i++) {
     const interfaceInfo = findInfoByGtype(interfaces[i])
 
     /* The interface doesn't have to exist, it could be private

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "node-gtk",
-  "version": "1.0.0",
+  "version": "2.1.0",
   "description": "GNOME Gtk+ bindings for NodeJS",
   "main": "lib/index.js",
+  "bin": {
+    "node-gtk": "bin/node-gtk.js"
+  },
   "scripts": {
     "install": "npx node-pre-gyp install --fallback-to-build",
+    "build:test-fixtures": "node scripts/build-test-fixtures.js",
+    "pretest": "node scripts/build-test-fixtures.js",
     "test": "mocha tests/__run__.js",
     "build": "npx node-pre-gyp build",
     "build:full": "npx node-pre-gyp rebuild",
@@ -36,7 +41,7 @@
     "lodash.camelcase": "4.3.0",
     "lodash.isequal": "4.5.0",
     "lodash.snakecase": "^4.1.1",
-    "nan": "^2.23.0",
+    "nan": "^2.27.0",
     "node-gyp": "^11.2.0",
     "remove-trailing-spaces": "^1.0.7",
     "unindent": "^2.0.0"
@@ -51,9 +56,11 @@
     "node-pre-gyp-github": "^1.4.5"
   },
   "files": [
+    "/bin",
     "/lib",
     "/src",
     "/scripts",
+    "/tools",
     "binding.gyp"
   ],
   "binary": {

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,8 +105,27 @@ 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) {
+                if (g_arg_info_is_caller_allocates(&arg_info)) {
+                    // Caller-allocated out (e.g. a GdkRectangle in
+                    // GtkOverlay::get-child-position): the GValue already holds a
+                    // pointer to caller (GLib/GTK) memory. Pass a live wrapper so the
+                    // handler fills it in place — it is NOT written back from the
+                    // return value (see the output loop below). #444.
+                    ownership = kNone;
+                } else {
+                    // Callee-allocated out: no meaningful incoming value; the handler
+                    // supplies it through the return value.
+                    memset(&argument, 0, sizeof(argument));
+                    ownership = kNone;
+                }
             }
 
             js_args[i - 1] = GIArgumentToV8(&type_info, &argument, -1, ownership);
@@ -104,7 +158,61 @@ 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;
+
+            // Caller-allocated out structs are filled in place via the wrapper
+            // passed to the handler, so they are not part of the return value.
+            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_INOUT ||
+                    (d == GI_DIRECTION_OUT && !g_arg_info_is_caller_allocates(&out_arg_info)))
+                    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;
+                // Caller-allocated out structs were filled in place by the handler
+                // via their wrapper; nothing to write back from the return value.
+                if (d == GI_DIRECTION_OUT && g_arg_info_is_caller_allocates(&out_arg_info))
+                    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;
         }