koffi 2.14.0 → 2.15.0

package/src/koffi/src/ffi.cc

@@ -1,29 +1,12 @@
-// Copyright (C) 2025  Niels Martignène <niels.martignene@protonmail.com>
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the “Software”), to deal in
-// the Software without restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
-// Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-
-#include "src/core/base/base.hh"
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
+
+#include "lib/native/base/base.hh"
 #include "ffi.hh"
 #include "call.hh"
 #include "parser.hh"
 #include "util.hh"
+#include "uv.hh"
 #if defined(_WIN32)
     #include "win32.hh"
 #endif
@@ -50,7 +33,7 @@
 
 #include <napi.h>
 
-namespace RG {
+namespace K {
 
 SharedData shared;
 
@@ -147,7 +130,7 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
                 if (!ChangeMemorySize(key.c_str(), value, &new_config.async_heap_size))
                     return env.Null();
             } else if (key == "resident_async_pools") {
-                if (!ChangeAsyncLimit(key.c_str(), value, RG_LEN(instance->memories.data) - 1, &new_config.resident_async_pools))
+                if (!ChangeAsyncLimit(key.c_str(), value, K_LEN(instance->memories.data) - 1, &new_config.resident_async_pools))
                     return env.Null();
             } else if (key == "max_async_calls") {
                 if (!ChangeAsyncLimit(key.c_str(), value, MaxAsyncCalls, &max_async_calls))
@@ -222,7 +205,7 @@ static bool MapType(Napi::Env env, InstanceData *instance, const TypeInfo *type,
     }
 
     bool inserted;
-    instance->types_map.TrySet(name, type, &inserted);
+    instance->types_map.InsertOrGet(name, type, &inserted);
 
     if (!inserted) {
         ThrowError<Napi::Error>(env, "Duplicate type name '%1'", name);
@@ -244,7 +227,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 
     bool skip = (info.Length() > 1);
     bool named = skip && !IsNullOrUndefined(info[0]);
-    bool redefine = named && CheckValueTag(instance, info[0], &TypeInfoMarker);
+    bool redefine = named && CheckValueTag(info[0], &TypeInfoMarker);
 
     if (named && !info[0].IsString() && !redefine) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
@@ -259,7 +242,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
     Napi::Object obj = info[skip].As<Napi::Object>();
     Napi::Array keys = GetOwnPropertyNames(obj);
 
-    RG_DEFER_NC(err_guard, count = instance->types.count) {
+    K_DEFER_NC(err_guard, count = instance->types.count) {
         Size start = count + !skip;
 
         for (Size i = start; i < instance->types.count; i++) {
@@ -364,7 +347,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         }
 
         bool inserted;
-        members.TrySet(member.name, &inserted);
+        members.InsertOrGet(member.name, &inserted);
 
         if (!inserted) {
             ThrowError<Napi::Error>(env, "Duplicate member '%1' in struct '%2'", member.name, type->name);
@@ -414,7 +397,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         type = replace;
     }
 
-    return WrapType(env, instance, type);
+    return WrapType(env, type);
 }
 
 static Napi::Value CreatePaddedStructType(const Napi::CallbackInfo &info)
@@ -439,7 +422,7 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
 
     bool skip = (info.Length() > 1);
     bool named = skip && !IsNullOrUndefined(info[0]);
-    bool redefine = named && CheckValueTag(instance, info[0], &TypeInfoMarker);
+    bool redefine = named && CheckValueTag(info[0], &TypeInfoMarker);
 
     if (named && !info[0].IsString() && !redefine) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
@@ -454,7 +437,7 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
     Napi::Object obj = info[skip].As<Napi::Object>();
     Napi::Array keys = GetOwnPropertyNames(obj);
 
-    RG_DEFER_NC(err_guard, count = instance->types.count) {
+    K_DEFER_NC(err_guard, count = instance->types.count) {
         Size start = count + !skip;
 
         for (Size i = start; i < instance->types.count; i++) {
@@ -554,7 +537,7 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
         }
 
         bool inserted;
-        members.TrySet(member.name, &inserted);
+        members.InsertOrGet(member.name, &inserted);
 
         if (!inserted) {
             ThrowError<Napi::Error>(env, "Duplicate member '%1' in union '%2'", member.name, type->name);
@@ -583,13 +566,12 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
         type = replace;
     }
 
-    return WrapType(env, instance, type);
+    return WrapType(env, type);
 }
 
 Napi::Value InstantiateUnion(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     if (!info.IsConstructCall()) {
         ThrowError<Napi::TypeError>(env, "This function is a constructor and must be called with new");
@@ -609,7 +591,7 @@ Napi::Value InstantiateUnion(const Napi::CallbackInfo &info)
     }
 
     Napi::Object wrapper = type->construct.New({}).As<Napi::Object>();
-    SetValueTag(instance, wrapper, &MagicUnionMarker);
+    SetValueTag(wrapper, &MagicUnionMarker);
 
     return wrapper;
 }
@@ -626,10 +608,10 @@ static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    Napi::String name = info[0].As<Napi::String>();    
+    Napi::String name = info[0].As<Napi::String>();
 
     TypeInfo *type = instance->types.AppendDefault();
-    RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
+    K_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
     type->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr
                        : Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.count).ptr;
@@ -643,7 +625,7 @@ static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
         return env.Null();
     err_guard.Disable();
 
-    return WrapType(env, instance, type);
+    return WrapType(env, type);
 }
 
 static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
@@ -690,13 +672,13 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
     }
 
     TypeInfo *type = MakePointerType(instance, ref, count);
-    RG_ASSERT(type);
+    K_ASSERT(type);
 
     if (named || !countedby.IsEmpty()) {
         TypeInfo *copy = instance->types.AppendDefault();
-        RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
+        K_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
-        memcpy((void *)copy, type, RG_SIZE(*type));
+        memcpy((void *)copy, type, K_SIZE(*type));
         copy->name = named ? DuplicateString(name.c_str(), &instance->str_alloc).ptr : copy->name;
 
         if (!countedby.IsEmpty()) {
@@ -712,15 +694,14 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
         type = copy;
     }
 
-    return WrapType(env, instance, type);
+    return WrapType(env, type);
 }
 
 static Napi::Value EncodePointerDirection(const Napi::CallbackInfo &info, int directions)
 {
-    RG_ASSERT(directions >= 1 && directions <= 3);
+    K_ASSERT(directions >= 1 && directions <= 3);
 
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
@@ -742,7 +723,7 @@ static Napi::Value EncodePointerDirection(const Napi::CallbackInfo &info, int di
     // Embed direction in unused pointer bits
     const TypeInfo *marked = (const TypeInfo *)((uint8_t *)type + directions - 1);
 
-    return WrapType(env, instance, marked);
+    return WrapType(env, marked);
 }
 
 static Napi::Value MarkIn(const Napi::CallbackInfo &info)
@@ -810,14 +791,14 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
             const Napi::FunctionReference &ref = type->dispose_ref;
 
             Napi::External<void> external = Napi::External<void>::New(env, (void *)ptr);
-            SetValueTag(instance, external, type->ref.marker);
+            SetValueTag(external, type->ref.marker);
 
             Napi::Value self = env.Null();
             napi_value args[] = {
                 external
             };
 
-            ref.Call(self, RG_LEN(args), args);
+            ref.Call(self, K_LEN(args), args);
             instance->stats.disposed++;
         };
         dispose_func = func;
@@ -831,9 +812,9 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     }
 
     TypeInfo *type = instance->types.AppendDefault();
-    RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
+    K_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
-    memcpy((void *)type, (const void *)src, RG_SIZE(*src));
+    memcpy((void *)type, (const void *)src, K_SIZE(*src));
     type->members.allocator = GetNullAllocator();
 
     type->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr
@@ -845,7 +826,7 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     // If the insert succeeds, we cannot fail anymore
     if (named) {
         bool inserted;
-        instance->types_map.TrySet(type->name, type, &inserted);
+        instance->types_map.InsertOrGet(type->name, type, &inserted);
 
         if (!inserted) {
             ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
@@ -854,7 +835,7 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     }
     err_guard.Disable();
 
-    return WrapType(env, instance, type);
+    return WrapType(env, type);
 }
 
 static inline bool GetExternalPointer(Napi::Env env, Napi::Value value, void **out_ptr)
@@ -864,9 +845,9 @@ static inline bool GetExternalPointer(Napi::Env env, Napi::Value value, void **o
     if (IsNullOrUndefined(value)) {
         *out_ptr = 0;
         return true;
-    } else if (value.IsExternal() && !CheckValueTag(instance, value, &TypeInfoMarker) &&
-                                     !CheckValueTag(instance, value, &CastMarker) &&
-                                     !CheckValueTag(instance, value, &MagicUnionMarker)) {
+    } else if (value.IsExternal() && !CheckValueTag(value, &TypeInfoMarker) &&
+                                     !CheckValueTag(value, &CastMarker) &&
+                                     !CheckValueTag(value, &MagicUnionMarker)) {
         Napi::External<void> external = value.As<Napi::External<void>>();
         void *ptr = external.Data();
 
@@ -922,7 +903,7 @@ static Napi::Value CallAlloc(const Napi::CallbackInfo &info)
     }
 
     Napi::External<void> external = Napi::External<void>::New(env, ptr);
-    SetValueTag(instance, external, type);
+    SetValueTag(external, type);
 
     return external;
 }
@@ -1047,12 +1028,12 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
         type->countedby = DuplicateString(str.Utf8Value().c_str(), &instance->str_alloc).ptr;
     }
 
-    return WrapType(env, instance, type);
+    return WrapType(env, type);
 }
 
 static bool ParseClassicFunction(const Napi::CallbackInfo &info, bool concrete, FunctionInfo *out_func)
 {
-    RG_ASSERT(info.Length() >= 2);
+    K_ASSERT(info.Length() >= 2);
 
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
@@ -1158,7 +1139,7 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     FunctionInfo *func = instance->callbacks.AppendDefault();
-    RG_DEFER_N(err_guard) { instance->callbacks.RemoveLast(1); };
+    K_DEFER_N(err_guard) { instance->callbacks.RemoveLast(1); };
 
     if (info.Length() >= 2) {
         if (!ParseClassicFunction(info, false, func))
@@ -1205,12 +1186,12 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
 
     type->primitive = PrimitiveKind::Prototype;
     type->align = alignof(void *);
-    type->size = RG_SIZE(void *);
+    type->size = K_SIZE(void *);
     type->ref.proto = func;
 
     instance->types_map.Set(type->name, type);
 
-    return WrapType(env, instance, type);
+    return WrapType(env, type);
 }
 
 static Napi::Value CreateTypeAlias(const Napi::CallbackInfo &info)
@@ -1238,7 +1219,7 @@ static Napi::Value CreateTypeAlias(const Napi::CallbackInfo &info)
     if (!MapType(env, instance, type, alias))
         return env.Null();
 
-    return WrapType(env, instance, type);
+    return WrapType(env, type);
 }
 
 static Napi::Value GetTypeSize(const Napi::CallbackInfo &info)
@@ -1310,7 +1291,6 @@ static Napi::Value GetMemberOffset(const Napi::CallbackInfo &info)
 static Napi::Value GetResolvedType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
@@ -1321,13 +1301,12 @@ static Napi::Value GetResolvedType(const Napi::CallbackInfo &info)
     if (!type)
         return env.Null();
 
-    return WrapType(env, instance, type);
+    return WrapType(env, type);
 }
 
 static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
@@ -1378,7 +1357,7 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
                 defn.Set("hint", ArrayHintNames[(int)type->hint]);
             } [[fallthrough]];
             case PrimitiveKind::Pointer: {
-                Napi::Value value = WrapType(env, instance, type->ref.type);
+                Napi::Value value = WrapType(env, type->ref.type);
                 defn.Set("ref", value);
             } break;
             case PrimitiveKind::Record:
@@ -1389,7 +1368,7 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
                     Napi::Object obj = Napi::Object::New(env);
 
                     obj.Set("name", member.name);
-                    obj.Set("type", WrapType(env, instance, member.type));
+                    obj.Set("type", WrapType(env, member.type));
                     obj.Set("offset", member.offset);
                     if (member.countedby >= 0) {
                         obj.Set("countedBy", type->members[member.countedby].name);
@@ -1409,9 +1388,9 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
     return type->defn.Value();
 }
 
-static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, Size heap_size)
+InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, Size heap_size)
 {
-    std::lock_guard<std::mutex> lock(instance->memories_mutex);
+    std::lock_guard<std::mutex> lock(instance->mem_mutex);
 
     for (Size i = 1; i < instance->memories.len; i++) {
         InstanceMemory *mem = instance->memories[i];
@@ -1424,11 +1403,11 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
 
     bool temporary = (instance->memories.len > instance->config.resident_async_pools);
 
-    if (temporary && instance->temporaries >= instance->config.max_temporaries) [[unlikely]]
+    if (temporary && instance->temporaries > instance->config.max_temporaries)
         return nullptr;
 
     InstanceMemory *mem = new InstanceMemory();
-    RG_DEFER_N(mem_guard) { delete mem; };
+    K_DEFER_N(mem_guard) { delete mem; };
 
     stack_size = AlignLen(stack_size, Kibibytes(64));
 
@@ -1437,12 +1416,12 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
     mem->stack.len = stack_size;
     mem->stack.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->stack.len, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
 
-    RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
+    K_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
 #else
     mem->stack.len = stack_size;
     mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_STACK, -1, 0);
 
-    RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
+    K_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
 #endif
 
 #if defined(__OpenBSD__)
@@ -1459,7 +1438,7 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
 #else
     mem->heap.ptr = (uint8_t *)mmap(nullptr, mem->heap.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
 #endif
-    RG_CRITICAL(mem->heap.ptr, "Failed to allocate %1 of memory", mem->heap.len);
+    K_CRITICAL(mem->heap.ptr, "Failed to allocate %1 of memory", mem->heap.len);
 
     if (temporary) {
         instance->temporaries++;
@@ -1475,6 +1454,25 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
     return mem;
 }
 
+void ReleaseMemory(InstanceData *instance, InstanceMemory *mem)
+{
+    if (--mem->depth)
+        return;
+
+    // The first InstanceMemory is used for sync calls, no need to manage the async stuff
+    if (mem == instance->memories[0])
+        return;
+
+    std::lock_guard<std::mutex> lock(instance->mem_mutex);
+
+    if (mem->temporary) {
+        instance->temporaries--;
+        delete mem;
+    } else {
+        mem->busy = false;
+    }
+}
+
 static Napi::Value TranslateNormalCall(const FunctionInfo *func, void *native,
                                        const Napi::CallbackInfo &info)
 {
@@ -1498,7 +1496,7 @@ static Napi::Value TranslateNormalCall(const FunctionInfo *func, void *native,
 
     // Execute call
     {
-        RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
+        K_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
         exec_call = &call;
 
         call.Execute(func, native);
@@ -1520,11 +1518,11 @@ static Napi::Value TranslateVariadicCall(const FunctionInfo *func, void *native,
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     FunctionInfo copy;
-    memcpy((void *)&copy, func, RG_SIZE(*func));
+    memcpy((void *)&copy, func, K_SIZE(*func));
     copy.lib = nullptr;
 
     // This makes variadic calls non-reentrant
-    RG_DEFER_C(len = copy.parameters.len) {
+    K_DEFER_C(len = copy.parameters.len) {
         copy.parameters.RemoveFrom(len);
         copy.parameters.Leak();
     };
@@ -1579,7 +1577,7 @@ static Napi::Value TranslateVariadicCall(const FunctionInfo *func, void *native,
 
     // Execute call
     {
-        RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
+        K_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
         exec_call = &call;
 
         call.Execute(&copy, native);
@@ -1629,7 +1627,7 @@ public:
 void AsyncCall::Execute()
 {
     if (prepared) {
-        RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
+        K_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
         exec_call = &call;
 
         call.Execute(func, native);
@@ -1638,7 +1636,7 @@ void AsyncCall::Execute()
 
 void AsyncCall::OnOK()
 {
-    RG_ASSERT(prepared);
+    K_ASSERT(prepared);
 
     Napi::FunctionReference &callback = Callback();
 
@@ -1648,13 +1646,13 @@ void AsyncCall::OnOK()
         call.Complete(func)
     };
 
-    callback.Call(self, RG_LEN(args), args);
+    callback.Call(self, K_LEN(args), args);
 }
 
 static Napi::Value TranslateAsyncCall(const FunctionInfo *func, void *native,
                                       const Napi::CallbackInfo &info)
 {
-    RG_ASSERT(!func->variadic);
+    K_ASSERT(!func->variadic);
 
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
@@ -1712,7 +1710,7 @@ extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, Bac
         }
 
         // Avoid triggering the "use callback beyond FFI" check
-        RG_DEFER_C(generation = trampoline->generation) { trampoline->generation = generation; };
+        K_DEFER_C(generation = trampoline->generation) { trampoline->generation = generation; };
         trampoline->generation = -1;
 
         // We set dispose_call to true so that the main thread will dispose of CallData itself
@@ -1728,7 +1726,7 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info)
     LibraryHolder *lib = (LibraryHolder *)info.Data();
 
     FunctionInfo *func = new FunctionInfo();
-    RG_DEFER { func->Unref(); };
+    K_DEFER { func->Unref(); };
 
     func->lib = lib->Ref();
 
@@ -1825,7 +1823,7 @@ static Napi::Value FindSymbol(const Napi::CallbackInfo &info)
     }
 
     Napi::External<void> external = Napi::External<void>::New(env, ptr);
-    SetValueTag(instance, external, &type);
+    SetValueTag(external, &type);
 
     return external;
 }
@@ -1876,7 +1874,7 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
 
     if (!instance->memories.len) {
         AllocateMemory(instance, instance->config.sync_stack_size, instance->config.sync_heap_size);
-        RG_ASSERT(instance->memories.len);
+        K_ASSERT(instance->memories.len == 1);
     }
 
     // Load shared library
@@ -1890,7 +1888,7 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
             return env.Null();
     } else {
         module = GetModuleHandle(nullptr);
-        RG_ASSERT(module);
+        K_ASSERT(module);
     }
 #else
     if (info[0].IsString()) {
@@ -1917,7 +1915,7 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
 #endif
 
     LibraryHolder *lib = new LibraryHolder(module);
-    RG_DEFER { lib->Unref(); };
+    K_DEFER { lib->Unref(); };
 
     Napi::Object obj = Napi::Object::New(env);
 
@@ -1997,7 +1995,7 @@ static Napi::Value RegisterCallback(const Napi::CallbackInfo &info)
     void *ptr = GetTrampoline(idx, type->ref.proto);
 
     Napi::External<void> external = Napi::External<void>::New(env, ptr);
-    SetValueTag(instance, external, type->ref.marker);
+    SetValueTag(external, type->ref.marker);
 
     // Cache index for fast unregistration
     instance->trampolines_map.Set(ptr, idx);
@@ -2040,7 +2038,7 @@ static Napi::Value UnregisterCallback(const Napi::CallbackInfo &info)
         std::lock_guard<std::mutex> lock(shared.mutex);
 
         TrampolineInfo *trampoline = &shared.trampolines[idx];
-        RG_ASSERT(!trampoline->func.IsEmpty());
+        K_ASSERT(!trampoline->func.IsEmpty());
 
         trampoline->func.Reset();
         trampoline->recv.Reset();
@@ -2054,7 +2052,6 @@ static Napi::Value UnregisterCallback(const Napi::CallbackInfo &info)
 static Napi::Value CastValue(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     if (info.Length() < 2) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
@@ -2081,7 +2078,7 @@ static Napi::Value CastValue(const Napi::CallbackInfo &info)
     cast->type = type;
 
     Napi::External<ValueCast> external = Napi::External<ValueCast>::New(env, cast, [](Napi::Env, ValueCast *cast) { delete cast; });
-    SetValueTag(instance, external, &CastMarker);
+    SetValueTag(external, &CastMarker);
 
     return external;
 }
@@ -2354,8 +2351,8 @@ bool InitAsyncBroker(Napi::Env env, InstanceData *instance)
 static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initializer_list<const char *> names,
                                   PrimitiveKind primitive, int32_t size, int16_t align, const char *ref = nullptr)
 {
-    RG_ASSERT(names.size() > 0);
-    RG_ASSERT(align <= size);
+    K_ASSERT(names.size() > 0);
+    K_ASSERT(align <= size);
 
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
@@ -2379,17 +2376,17 @@ static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initiali
 
     if (ref) {
         const TypeInfo *marker = instance->types_map.FindValue(ref, nullptr);
-        RG_ASSERT(marker);
+        K_ASSERT(marker);
 
         type->ref.marker = marker;
     }
 
-    Napi::Value wrapper = WrapType(env, instance, type);
+    Napi::Value wrapper = WrapType(env, type);
 
     for (const char *name: names) {
         bool inserted;
-        instance->types_map.TrySet(name, type, &inserted);
-        RG_ASSERT(inserted);
+        instance->types_map.InsertOrGet(name, type, &inserted);
+        K_ASSERT(inserted);
 
         if (!EndsWith(name, "*")) {
             map.Set(name, wrapper);
@@ -2406,12 +2403,12 @@ static inline PrimitiveKind GetSignPrimitive(Size len, bool sign)
         case 8: return sign ? PrimitiveKind::Int64 : PrimitiveKind::UInt64;
     }
 
-    RG_UNREACHABLE();
+    K_UNREACHABLE();
 }
 
 static inline PrimitiveKind GetLittleEndianPrimitive(PrimitiveKind kind)
 {
-#if defined(RG_BIG_ENDIAN)
+#if defined(K_BIG_ENDIAN)
     return (PrimitiveKind)((int)kind + 1);
 #else
     return kind;
@@ -2420,7 +2417,7 @@ static inline PrimitiveKind GetLittleEndianPrimitive(PrimitiveKind kind)
 
 static inline PrimitiveKind GetBigEndianPrimitive(PrimitiveKind kind)
 {
-#if defined(RG_BIG_ENDIAN)
+#if defined(K_BIG_ENDIAN)
     return kind;
 #else
     return (PrimitiveKind)((int)kind + 1);
@@ -2430,7 +2427,7 @@ static inline PrimitiveKind GetBigEndianPrimitive(PrimitiveKind kind)
 static InstanceData *CreateInstance()
 {
     InstanceData *instance = new InstanceData();
-    RG_DEFER_N(err_guard) { delete instance; };
+    K_DEFER_N(err_guard) { delete instance; };
 
     instance->main_thread_id = std::this_thread::get_id();
 
@@ -2450,7 +2447,7 @@ static InstanceData *CreateInstance()
 static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
 {
     InstanceData *instance = CreateInstance();
-    RG_CRITICAL(instance, "Failed to initialize Koffi");
+    K_CRITICAL(instance, "Failed to initialize Koffi");
 
     env.SetInstanceData(instance);
 
@@ -2525,16 +2522,16 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
         exports.Set("types", types);
 
         RegisterPrimitiveType(env, types, {"void"}, PrimitiveKind::Void, 0, 0);
-        RegisterPrimitiveType(env, types, {"bool"}, PrimitiveKind::Bool, RG_SIZE(bool), alignof(bool));
+        RegisterPrimitiveType(env, types, {"bool"}, PrimitiveKind::Bool, K_SIZE(bool), alignof(bool));
         RegisterPrimitiveType(env, types, {"int8_t", "int8"}, PrimitiveKind::Int8, 1, 1);
         RegisterPrimitiveType(env, types, {"uint8_t", "uint8"}, PrimitiveKind::UInt8, 1, 1);
         RegisterPrimitiveType(env, types, {"char"}, PrimitiveKind::Int8, 1, 1);
         RegisterPrimitiveType(env, types, {"unsigned char", "uchar"}, PrimitiveKind::UInt8, 1, 1);
         RegisterPrimitiveType(env, types, {"char16_t", "char16"}, PrimitiveKind::Int16, 2, 2);
         RegisterPrimitiveType(env, types, {"char32_t", "char32"}, PrimitiveKind::Int32, 4, 4);
-        if (RG_SIZE(wchar_t) == 2) {
+        if (K_SIZE(wchar_t) == 2) {
             RegisterPrimitiveType(env, types, {"wchar_t", "wchar"}, PrimitiveKind::Int16, 2, 2);
-        } else if (RG_SIZE(wchar_t) == 4) {
+        } else if (K_SIZE(wchar_t) == 4) {
             RegisterPrimitiveType(env, types, {"wchar_t", "wchar"}, PrimitiveKind::Int32, 4, 4);
         }
         RegisterPrimitiveType(env, types, {"int16_t", "int16"}, PrimitiveKind::Int16, 2, 2);
@@ -2559,22 +2556,22 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
         RegisterPrimitiveType(env, types, {"uint64_t", "uint64"}, PrimitiveKind::UInt64, 8, alignof(int64_t));
         RegisterPrimitiveType(env, types, {"uint64_le_t", "uint64_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt64), 8, alignof(int64_t));
         RegisterPrimitiveType(env, types, {"uint64_be_t", "uint64_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt64), 8, alignof(int64_t));
-        RegisterPrimitiveType(env, types, {"intptr_t", "intptr"}, GetSignPrimitive(RG_SIZE(intptr_t), true), RG_SIZE(intptr_t), alignof(intptr_t));
-        RegisterPrimitiveType(env, types, {"uintptr_t", "uintptr"}, GetSignPrimitive(RG_SIZE(intptr_t), false), RG_SIZE(intptr_t), alignof(intptr_t));
-        RegisterPrimitiveType(env, types, {"size_t"}, GetSignPrimitive(RG_SIZE(size_t), false), RG_SIZE(size_t), alignof(size_t));
-        RegisterPrimitiveType(env, types, {"long"}, GetSignPrimitive(RG_SIZE(long), true), RG_SIZE(long), alignof(long));
-        RegisterPrimitiveType(env, types, {"unsigned long", "ulong"}, GetSignPrimitive(RG_SIZE(long), false), RG_SIZE(long), alignof(long));
-        RegisterPrimitiveType(env, types, {"long long", "longlong"}, PrimitiveKind::Int64, RG_SIZE(int64_t), alignof(int64_t));
-        RegisterPrimitiveType(env, types, {"unsigned long long", "ulonglong"}, PrimitiveKind::UInt64, RG_SIZE(uint64_t), alignof(uint64_t));
+        RegisterPrimitiveType(env, types, {"intptr_t", "intptr"}, GetSignPrimitive(K_SIZE(intptr_t), true), K_SIZE(intptr_t), alignof(intptr_t));
+        RegisterPrimitiveType(env, types, {"uintptr_t", "uintptr"}, GetSignPrimitive(K_SIZE(intptr_t), false), K_SIZE(intptr_t), alignof(intptr_t));
+        RegisterPrimitiveType(env, types, {"size_t"}, GetSignPrimitive(K_SIZE(size_t), false), K_SIZE(size_t), alignof(size_t));
+        RegisterPrimitiveType(env, types, {"long"}, GetSignPrimitive(K_SIZE(long), true), K_SIZE(long), alignof(long));
+        RegisterPrimitiveType(env, types, {"unsigned long", "ulong"}, GetSignPrimitive(K_SIZE(long), false), K_SIZE(long), alignof(long));
+        RegisterPrimitiveType(env, types, {"long long", "longlong"}, PrimitiveKind::Int64, K_SIZE(int64_t), alignof(int64_t));
+        RegisterPrimitiveType(env, types, {"unsigned long long", "ulonglong"}, PrimitiveKind::UInt64, K_SIZE(uint64_t), alignof(uint64_t));
         RegisterPrimitiveType(env, types, {"float", "float32"}, PrimitiveKind::Float32, 4, alignof(float));
         RegisterPrimitiveType(env, types, {"double", "float64"}, PrimitiveKind::Float64, 8, alignof(double));
-        RegisterPrimitiveType(env, types, {"char *", "str", "string"}, PrimitiveKind::String, RG_SIZE(void *), alignof(void *), "char");
-        RegisterPrimitiveType(env, types, {"char16_t *", "char16 *", "str16", "string16"}, PrimitiveKind::String16, RG_SIZE(void *), alignof(void *), "char16_t");
-        RegisterPrimitiveType(env, types, {"char32_t *", "char32 *", "str32", "string32"}, PrimitiveKind::String32, RG_SIZE(void *), alignof(void *), "char32_t");
-        if (RG_SIZE(wchar_t) == 2) {
-            RegisterPrimitiveType(env, types, {"wchar_t *", "wchar *"}, PrimitiveKind::String16, RG_SIZE(void *), alignof(void *), "wchar_t");
-        } else if (RG_SIZE(wchar_t) == 4) {
-            RegisterPrimitiveType(env, types, {"wchar_t *", "wchar *"}, PrimitiveKind::String32, RG_SIZE(void *), alignof(void *), "wchar_t");
+        RegisterPrimitiveType(env, types, {"char *", "str", "string"}, PrimitiveKind::String, K_SIZE(void *), alignof(void *), "char");
+        RegisterPrimitiveType(env, types, {"char16_t *", "char16 *", "str16", "string16"}, PrimitiveKind::String16, K_SIZE(void *), alignof(void *), "char16_t");
+        RegisterPrimitiveType(env, types, {"char32_t *", "char32 *", "str32", "string32"}, PrimitiveKind::String32, K_SIZE(void *), alignof(void *), "char32_t");
+        if (K_SIZE(wchar_t) == 2) {
+            RegisterPrimitiveType(env, types, {"wchar_t *", "wchar *"}, PrimitiveKind::String16, K_SIZE(void *), alignof(void *), "wchar_t");
+        } else if (K_SIZE(wchar_t) == 4) {
+            RegisterPrimitiveType(env, types, {"wchar_t *", "wchar *"}, PrimitiveKind::String32, K_SIZE(void *), alignof(void *), "wchar_t");
         }
 
         instance->void_type = instance->types_map.FindValue("void", nullptr);
@@ -2596,12 +2593,15 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
         exports.Set("node", node);
 
         Napi::External<void> external = Napi::External<void>::New(env, (napi_env)env);
-        SetValueTag(instance, external, instance->void_type);
+        SetValueTag(external, instance->void_type);
 
         node.Set("env", external);
+
+        node.Set("poll", Napi::Function::New(env, &Poll, "poll"));
+        node.Set("PollHandle", PollHandle::Define(env));
     }
 
-    exports.Set("version", Napi::String::New(env, RG_STRINGIFY(VERSION)));
+    exports.Set("version", Napi::String::New(env, K_STRINGIFY(VERSION)));
 
     return exports;
 }