koffi 2.2.1 → 2.2.2-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "2.2.1",
+    "version": "2.2.2-beta.2",
     "stable": "2.2.1",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [

package/src/koffi/qemu/qemu.js

@@ -63,6 +63,7 @@ async function main() {
         switch (process.argv[2]) {
             case 'pack': { command = pack; } break;
             case 'publish': { command = publish; } break;
+            case 'prepare': { command = prepare; } break;
             case 'test': { command = test; } break;
             case 'start': { command = start; } break;
             case 'stop': { command = stop; } break;
@@ -190,7 +191,7 @@ async function main() {
     console.log();
 
     try {
-        let success = await command();
+        let success = !!(await command());
         process.exit(!success);
     } catch (err) {
         console.error(err);
@@ -205,6 +206,7 @@ Commands:
     test                         Run the machines and perform the tests (default)
     pack                         Create NPM package with prebuilt Koffi binaries
     publish                      Publish NPM package with prebuilt Koffi binaries
+    prepare                      Prepare distribution-ready NPM package directory
 
     start                        Start the machines but don't run anythingh
     stop                         Stop running machines
@@ -290,10 +292,9 @@ async function start(detach = true) {
 
 async function pack() {
     let pack_dir = script_dir + '/../build';
-    let dist_dir = script_dir + '/../build/dist';
+    let dist_dir = await prepare(dist_dir);
 
-    let success = await prepare(dist_dir);
-    if (!success)
+    if (dist_dir == null)
         return false;
 
     let npm = (process.platform == 'win32') ? 'npm.cmd' : 'npm';
@@ -305,10 +306,9 @@ async function pack() {
 }
 
 async function publish() {
-    let dist_dir = script_dir + '/../build/dist';
+    let dist_dir = await prepare();
 
-    let success = await prepare(dist_dir);
-    if (!success)
+    if (dist_dir == null)
         return false;
 
     let npm = (process.platform == 'win32') ? 'npm.cmd' : 'npm';
@@ -319,7 +319,8 @@ async function publish() {
     });
 }
 
-async function prepare(dist_dir) {
+async function prepare() {
+    let dist_dir = script_dir + '/../build/dist';
     let snapshot_dir = snapshot();
 
     let json = fs.readFileSync(root_dir + '/src/koffi/package.json', { encoding: 'utf-8' });
@@ -457,7 +458,7 @@ async function prepare(dist_dir) {
         if (!success) {
             console.log('');
             console.log('>> Status: ' + chalk.bold.red('FAILED'));
-            return false;
+            return null;
         }
     }
 
@@ -495,7 +496,7 @@ async function prepare(dist_dir) {
         fs.renameSync(dist_dir + '/web/koffi.dev', dist_dir + '/doc');
     }
 
-    return true;
+    return dist_dir;
 }
 
 function snapshot() {
@@ -519,6 +520,7 @@ function snapshot() {
                                        parts[1] == 'miniz' ||
                                        parts[1] == 'node-addon-api' ||
                                        parts[1] == 'raylib' ||
+                                       parts[1] == 'sqlite3' ||
                                        parts[1] == 'sqlite3mc';
         } else if (parts[0] == 'web') {
             return parts[1] == null || parts[1] == 'koffi.dev';

package/src/koffi/src/abi_arm32.cc

@@ -121,8 +121,6 @@ static void *const Trampolines[][2] = {
 };
 RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines * 2);
 
-static RG_THREAD_LOCAL CallData *exec_call;
-
 static inline int IsHFA(const TypeInfo *type)
 {
 #ifdef __ARM_PCS_VFP
@@ -495,9 +493,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
 void CallData::Execute()
 {
-    RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
-    exec_call = this;
-
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
             auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
@@ -863,8 +858,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const TypeInfo *type = proto->ret.type;
 
     // Make the call
-    napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
-                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    napi_value ret;
+    if (async) {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
+    } else {
+        ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
+                              [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    }
     Napi::Value value(env, ret);
 
     if (RG_UNLIKELY(env.IsExceptionPending()))
@@ -1059,11 +1059,6 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][vec];
 }
 
-extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
-{
-    exec_call->Relay(idx, own_sp, caller_sp, out_reg);
-}
-
 }
 
 #endif

package/src/koffi/src/abi_arm64.cc

@@ -123,8 +123,6 @@ static void *const Trampolines[][2] = {
 };
 RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines * 2);
 
-static RG_THREAD_LOCAL CallData *exec_call;
-
 static inline int IsHFA(const TypeInfo *type)
 {
     return IsHFA(type, 1, 4);
@@ -563,9 +561,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
 void CallData::Execute()
 {
-    RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
-    exec_call = this;
-
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
             auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
@@ -1088,8 +1083,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const TypeInfo *type = proto->ret.type;
 
     // Make the call
-    napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
-                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    napi_value ret;
+    if (async) {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
+    } else {
+        ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
+                              [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    }
     Napi::Value value(env, ret);
 
     if (RG_UNLIKELY(env.IsExceptionPending()))
@@ -1252,11 +1252,6 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][vec];
 }
 
-extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
-{
-    exec_call->Relay(idx, own_sp, caller_sp, out_reg);
-}
-
 }
 
 #endif

package/src/koffi/src/abi_riscv64.cc

@@ -131,8 +131,6 @@ static void *const Trampolines[][2] = {
 };
 RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines * 2);
 
-static RG_THREAD_LOCAL CallData *exec_call;
-
 static void AnalyseParameter(ParameterInfo *param, int gpr_avail, int vec_avail)
 {
     gpr_avail = std::min(2, gpr_avail);
@@ -410,9 +408,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
 void CallData::Execute()
 {
-    RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
-    exec_call = this;
-
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
             auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
@@ -762,8 +757,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const TypeInfo *type = proto->ret.type;
 
     // Make the call
-    napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
-                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    napi_value ret;
+    if (async) {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
+    } else {
+        ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
+                              [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    }
     Napi::Value value(env, ret);
 
     if (RG_UNLIKELY(env.IsExceptionPending()))
@@ -925,11 +925,6 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][fp];
 }
 
-extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
-{
-    exec_call->Relay(idx, own_sp, caller_sp, out_reg);
-}
-
 }
 
 #endif

package/src/koffi/src/abi_x64_sysv.cc

@@ -138,8 +138,6 @@ static void *const Trampolines[][2] = {
 };
 RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines * 2);
 
-static RG_THREAD_LOCAL CallData *exec_call;
-
 static inline RegisterClass MergeClasses(RegisterClass cls1, RegisterClass cls2)
 {
     if (cls1 == cls2)
@@ -474,9 +472,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
 void CallData::Execute()
 {
-    RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
-    exec_call = this;
-
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
             auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
@@ -810,8 +805,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const TypeInfo *type = proto->ret.type;
 
     // Make the call
-    napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
-                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    napi_value ret;
+    if (async) {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
+    } else {
+        ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
+                              [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    }
     Napi::Value value(env, ret);
 
     if (RG_UNLIKELY(env.IsExceptionPending()))
@@ -990,11 +990,6 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][xmm];
 }
 
-extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
-{
-    exec_call->Relay(idx, own_sp, caller_sp, out_reg);
-}
-
 }
 
 #endif

package/src/koffi/src/abi_x64_win.cc

@@ -107,8 +107,6 @@ static void *const Trampolines[][2] = {
 };
 RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines * 2);
 
-static RG_THREAD_LOCAL CallData *exec_call;
-
 bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 {
     func->ret.regular = IsRegularSize(func->ret.type->size, 8);
@@ -285,9 +283,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
 void CallData::Execute()
 {
-    RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
-    exec_call = this;
-
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
             auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
@@ -603,8 +598,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const TypeInfo *type = proto->ret.type;
 
     // Make the call
-    napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
-                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    napi_value ret;
+    if (async) {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
+    } else {
+        ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
+                              [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    }
     Napi::Value value(env, ret);
 
     if (RG_UNLIKELY(env.IsExceptionPending()))
@@ -764,11 +764,6 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][xmm];
 }
 
-extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
-{
-    exec_call->Relay(idx, own_sp, caller_sp, out_reg);
-}
-
 }
 
 #endif

package/src/koffi/src/abi_x86.cc

@@ -113,8 +113,6 @@ static void *const Trampolines[][2] = {
 };
 RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines * 2);
 
-static RG_THREAD_LOCAL CallData *exec_call;
-
 bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
 {
     if (!func->lib && func->convention != CallConvention::Cdecl &&
@@ -366,9 +364,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
 void CallData::Execute()
 {
-    RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
-    exec_call = this;
-
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
             auto ret = (func->fast ? ForwardCallR ## Suffix(func->func, new_sp, &old_sp) \
@@ -682,8 +677,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
     const TypeInfo *type = proto->ret.type;
 
     // Make the call
-    napi_value ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
-                                     [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    napi_value ret;
+    if (async) {
+        ret = (napi_value)func.Call(arguments[0], arguments.len - 1, arguments.data + 1);
+    } else {
+        ret = CallSwitchStack(&func, (size_t)arguments.len, arguments.data, old_sp, &mem->stack,
+                              [](Napi::Function *func, size_t argc, napi_value *argv) { return (napi_value)func->Call(argv[0], argc - 1, argv + 1); });
+    }
     Napi::Value value(env, ret);
 
     if (RG_UNLIKELY(env.IsExceptionPending()))
@@ -867,11 +867,6 @@ void *GetTrampoline(Size idx, const FunctionInfo *proto)
     return Trampolines[idx][x87];
 }
 
-extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
-{
-    exec_call->Relay(idx, own_sp, caller_sp, out_reg);
-}
-
 }
 
 #endif

package/src/koffi/src/call.cc

@@ -20,9 +20,23 @@
 
 namespace RG {
 
-CallData::CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func, InstanceMemory *mem)
+struct RelayContext {
+    CallData *call;
+
+    Size idx;
+    uint8_t *own_sp;
+    uint8_t *caller_sp;
+    BackRegisters *out_reg;
+
+    std::mutex mutex;
+    std::condition_variable cv;
+    bool done = false;
+};
+
+CallData::CallData(Napi::Env env, InstanceData *instance,
+                   const FunctionInfo *func, InstanceMemory *mem, bool async)
     : env(env), instance(instance), func(func),
-      mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap)
+      mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap), async(async)
 {
     mem->generation += !mem->depth;
     mem->depth++;
@@ -50,6 +64,41 @@ CallData::~CallData()
     instance = nullptr;
 }
 
+void CallData::RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+{
+    if (async) {
+        RelayContext ctx;
+
+        ctx.call = this;
+        ctx.idx = idx;
+        ctx.own_sp = own_sp;
+        ctx.caller_sp = caller_sp;
+        ctx.out_reg = out_reg;
+
+        napi_call_threadsafe_function(instance->broker, &ctx, napi_tsfn_blocking);
+
+        // Wait until it executes
+        std::unique_lock<std::mutex> lock(ctx.mutex);
+        while (!ctx.done) {
+            ctx.cv.wait(lock);
+        }
+    } else {
+        Relay(idx, own_sp, caller_sp, out_reg);
+    }
+}
+
+void CallData::RelayAsync(napi_env, napi_value, void *, void *udata)
+{
+    RelayContext *ctx = (RelayContext *)udata;
+
+    ctx->call->Relay(ctx->idx, ctx->own_sp, ctx->caller_sp, ctx->out_reg);
+
+    // We're done!
+    std::lock_guard<std::mutex> lock(ctx->mutex);
+    ctx->done = true;
+    ctx->cv.notify_one();
+}
+
 bool CallData::PushString(Napi::Value value, int directions, const char **out_str)
 {
     if (value.IsString()) {

package/src/koffi/src/call.hh

@@ -42,6 +42,8 @@ class alignas(8) CallData {
     Span<uint8_t> old_stack_mem;
     Span<uint8_t> old_heap_mem;
 
+    bool async;
+
     int16_t used_trampolines = 0;
 
     LocalArray<OutArgument, MaxOutParameters> out_arguments;
@@ -68,7 +70,8 @@ class alignas(8) CallData {
     BlockAllocator call_alloc;
 
 public:
-    CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func, InstanceMemory *mem);
+    CallData(Napi::Env env, InstanceData *instance,
+             const FunctionInfo *func, InstanceMemory *mem, bool async);
     ~CallData();
 
 #ifdef UNITY_BUILD
@@ -88,6 +91,8 @@ public:
 #undef INLINE_IF_UNITY
 
     void Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg);
+    void RelaySafe(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg);
+    static void RelayAsync(napi_env, napi_value, void *, void *udata);
 
     void DumpForward() const;
 

package/src/koffi/src/ffi.cc

@@ -44,6 +44,8 @@ namespace RG {
 const int TypeInfoMarker = 0xDEADBEEF;
 const int CastMarker = 0xDEADBEEF;
 
+static RG_THREAD_LOCAL CallData *exec_call;
+
 static bool ChangeSize(const char *name, Napi::Value value, Size min_size, Size max_size, Size *out_size)
 {
     Napi::Env env = value.Env();
@@ -1057,7 +1059,10 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
     }
 
     InstanceMemory *mem = instance->memories[0];
-    CallData call(env, instance, func, mem);
+    CallData call(env, instance, func, mem, false);
+
+    RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
+    exec_call = &call;
 
     if (!RG_UNLIKELY(call.Prepare(info)))
         return env.Null();
@@ -1065,7 +1070,14 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
     if (instance->debug) {
         call.DumpForward();
     }
-    call.Execute();
+
+    // Execute call
+    {
+        RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
+        exec_call = &call;
+
+        call.Execute();
+    }
 
     return call.Complete();
 }
@@ -1124,7 +1136,7 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         return env.Null();
 
     InstanceMemory *mem = instance->memories[0];
-    CallData call(env, instance, &func, mem);
+    CallData call(env, instance, &func, mem, false);
 
     if (!RG_UNLIKELY(call.Prepare(info)))
         return env.Null();
@@ -1132,7 +1144,14 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
     if (instance->debug) {
         call.DumpForward();
     }
-    call.Execute();
+
+    // Execute call
+    {
+        RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
+        exec_call = &call;
+
+        call.Execute();
+    }
 
     return call.Complete();
 }
@@ -1148,7 +1167,7 @@ public:
     AsyncCall(Napi::Env env, InstanceData *instance, const FunctionInfo *func,
               InstanceMemory *mem, Napi::Function &callback)
         : Napi::AsyncWorker(callback), env(env), func(func->Ref()),
-          call(env, instance, func, mem) {}
+          call(env, instance, func, mem, true) {}
     ~AsyncCall() { func->Unref(); }
 
     bool Prepare(const Napi::CallbackInfo &info) {
@@ -1170,6 +1189,9 @@ public:
 void AsyncCall::Execute()
 {
     if (prepared) {
+        RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
+        exec_call = &call;
+
         call.Execute();
     }
 }
@@ -1673,6 +1695,10 @@ InstanceData::~InstanceData()
     for (InstanceMemory *mem: memories) {
         delete mem;
     }
+
+    if (broker) {
+        napi_release_threadsafe_function(broker, napi_tsfn_abort);
+    }
 }
 
 static Napi::Value CastValue(const Napi::CallbackInfo &info)
@@ -1828,6 +1854,30 @@ static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
     return env.Null();
 }
 
+extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
+{
+    exec_call->RelaySafe(idx, own_sp, caller_sp, out_reg);
+}
+
+static InstanceData *CreateInstance(Napi::Env env)
+{
+    InstanceData *instance = new InstanceData();
+    RG_DEFER_N(err_guard) { delete instance; };
+
+    Napi::String resource_name = Napi::String::New(env, "Koffi Async Callback Broker");
+
+    if (napi_create_threadsafe_function(env, nullptr, nullptr, resource_name,
+                                        0, 1, nullptr, nullptr, nullptr,
+                                        CallData::RelayAsync, &instance->broker) != napi_ok) {
+        LogError("Failed to create async callback broker");
+        return nullptr;
+    }
+    napi_unref_threadsafe_function(env, instance->broker);
+
+    err_guard.Disable();
+    return instance;
+}
+
 template <typename Func>
 static void SetExports(Napi::Env env, Func func)
 {
@@ -1906,7 +1956,9 @@ static void InitInternal(v8::Local<v8::Object> target, v8::Local<v8::Value>,
         delete env_napi;
     }, env_napi);
 
-    InstanceData *instance = new InstanceData();
+    InstanceData *instance = CreateInstance(env_cxx);
+    RG_CRITICAL(instance, "Failed to initialize Koffi");
+
     env_cxx.SetInstanceData(instance);
 
     instance->debug = GetDebugFlag("DUMP_CALLS");
@@ -1922,7 +1974,9 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
 {
     using namespace RG;
 
-    InstanceData *instance = new InstanceData();
+    InstanceData *instance = CreateInstance(env);
+    RG_CRITICAL(instance, "Failed to initialize Koffi");
+
     env.SetInstanceData(instance);
 
     instance->debug = GetDebugFlag("DUMP_CALLS");

package/src/koffi/src/ffi.hh

@@ -263,6 +263,8 @@ struct InstanceData {
     int16_t temp_trampolines = 0;
     uint32_t registered_trampolines = 0;
 
+    napi_threadsafe_function broker = nullptr;
+
     BlockAllocator str_alloc;
 
     Size sync_stack_size = DefaultSyncStackSize;

package/src/koffi/src/index.js

@@ -18,6 +18,11 @@
 const util = require('util');
 
 let filename = __dirname + '/../build/koffi.node';
-module.exports = require(filename);
+let native = require(filename);
 
-module.exports.handle = util.deprecate(module.exports.opaque, 'The koffi.handle() function was deprecated in Koffi 2.1, use koffi.opaque() instead', 'KOFFI001');
+module.exports = {
+    ...native,
+
+    // Deprecated functions
+    handle: util.deprecate(native.opaque, 'The koffi.handle() function was deprecated in Koffi 2.1, use koffi.opaque() instead', 'KOFFI001')
+};