Signal callbacks prevents GC

I bumped into the problem that setting callbacks for an lgi object appears to prevent any references from within the callback to be garbage collected.

My use case is this:

I have an object o containing a lgi object. For the lgi object I provide a signal handler; a closure that references said object o. This unfortunately seems to prevent any garbage collection of o. This is a problem since o and its siblings are dynamically created objects that could be created in any number during the applications lifetime, and that also have other resource cleanup tasks associated with GC. Any thoughts regarding this?

Below you'll find a self contained stripped down example of the problem:

local lgi = require('lgi')

local function gen()
  -- local a = { ref = {} } -- this works fine
  local a = { ref = lgi.Gtk.Entry() } -- but lgi objects does not
  a.callback = function() return a end
  a.ref.on_focus_in_event = a.callback
  return a
end

local cache = setmetatable({}, {__mode = 'v'})
cache[1] = gen()
collectgarbage()
assert(cache[1] == nil, "reference was not collected")

The reproducer uses gen(), lgi.Gtk.Entry(), on_focus_in_event, the callback closure, and collectgarbage(); start by running it to confirm the retained reference. Trace the signal callback lifecycle and garbage-collection behavior. Done means cache[1] becomes nil after collectgarbage() while signal handling still works.