koffi 3.0.1 → 3.1.0

package/src/koffi/src/ffi.cc

@@ -5,6 +5,7 @@
 #include "ffi.hh"
 #include "call.hh"
 #include "parser.hh"
+#include "type.hh"
 #include "util.hh"
 #include "uv.hh"
 #if defined(_WIN32)
@@ -35,23 +36,28 @@
 
 namespace K {
 
+// Value does not matter, the tag system uses memory addresses
+const napi_type_tag LibraryHandleMarker = { 0xdb9b066e6f700474, 0x0aecd7e4c63fbda9 };
+const napi_type_tag TypeObjectMarker = { 0x1cc449675b294374, 0xbb13a50e97dcb017 };
+const napi_type_tag DirectionMarker = { 0xf9c306238b480580, 0xc2e168524a0823f5 };
+const napi_type_tag UnionValueMarker = { 0x5eaf2245526a4c7d, 0x8c86c9ee2b96ffc8 };
+const napi_type_tag CastMarker = { 0x77f459614a0a412f, 0x80b3dda1341dc8df };
+
 SharedData shared;
 
 // Some Node-API functions are loaded dynamically to work around bugs or because they are recent
+napi_status (NAPI_CDECL *node_api_delete_reference)(node_api_basic_env env, napi_ref ref);
 napi_status (NAPI_CDECL *node_api_get_buffer_info)(napi_env env, napi_value value, void **data, size_t *length);
 napi_status (NAPI_CDECL *node_api_create_property_key_utf8)(napi_env env, const char* str, size_t length, napi_value* result);
 napi_status (NAPI_CDECL *node_api_post_finalizer)(node_api_basic_env env, napi_finalize finalize_cb, void* finalize_data, void* finalize_hint);
 napi_status (NAPI_CDECL *node_api_create_object_with_properties)(napi_env env, napi_value prototype_or_null, const napi_value *property_names,
                                                                  const napi_value *property_values, size_t property_count, napi_value *result);
-napi_value (*translate_zero_call)(napi_env env, napi_callback_info info);
 
-static bool ChangeSize(const char *name, Napi::Value value, Size min_size, Size max_size, Size *out_size)
+static bool ChangeSize(InstanceData *instance, const char *name, Napi::Value value, Size min_size, Size max_size, Size *out_size)
 {
-    Napi::Env env = value.Env();
+    Napi::Env env = instance->env;
 
     if (!value.IsNumber()) {
-        InstanceData *instance = env.GetInstanceData<InstanceData>();
-
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for '%2', expected number", GetValueType(instance, value), name);
         return false;
     }
@@ -67,21 +73,19 @@ static bool ChangeSize(const char *name, Napi::Value value, Size min_size, Size
     return true;
 }
 
-static bool ChangeMemorySize(const char *name, Napi::Value value, Size *out_size)
+static bool ChangeMemorySize(InstanceData *instance, const char *name, Napi::Value value, Size *out_size)
 {
     const Size MinSize = Kibibytes(1);
     const Size MaxSize = Mebibytes(16);
 
-    return ChangeSize(name, value, MinSize, MaxSize, out_size);
+    return ChangeSize(instance, name, value, MinSize, MaxSize, out_size);
 }
 
-static bool ChangeAsyncLimit(const char *name, Napi::Value value, int max, int *out_limit)
+static bool ChangeAsyncLimit(InstanceData *instance, const char *name, Napi::Value value, int max, int *out_limit)
 {
     Napi::Env env = value.Env();
 
     if (!value.IsNumber()) {
-        InstanceData *instance = env.GetInstanceData<InstanceData>();
-
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for '%2', expected number", GetValueType(instance, value), name);
         return false;
     }
@@ -100,7 +104,7 @@ static bool ChangeAsyncLimit(const char *name, Napi::Value value, int max, int *
 static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length()) {
         if (instance->memories.len) {
@@ -124,25 +128,25 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
             Napi::Value value = obj[key];
 
             if (key == "sync_stack_size") {
-                if (!ChangeMemorySize(key.c_str(), value, &new_config.sync_stack_size))
+                if (!ChangeMemorySize(instance, key.c_str(), value, &new_config.sync_stack_size))
                     return env.Null();
             } else if (key == "sync_heap_size") {
-                if (!ChangeMemorySize(key.c_str(), value, &new_config.sync_heap_size))
+                if (!ChangeMemorySize(instance, key.c_str(), value, &new_config.sync_heap_size))
                     return env.Null();
             } else if (key == "async_stack_size") {
-                if (!ChangeMemorySize(key.c_str(), value, &new_config.async_stack_size))
+                if (!ChangeMemorySize(instance, key.c_str(), value, &new_config.async_stack_size))
                     return env.Null();
             } else if (key == "async_heap_size") {
-                if (!ChangeMemorySize(key.c_str(), value, &new_config.async_heap_size))
+                if (!ChangeMemorySize(instance, key.c_str(), value, &new_config.async_heap_size))
                     return env.Null();
             } else if (key == "resident_async_pools") {
-                if (!ChangeAsyncLimit(key.c_str(), value, K_LEN(instance->memories.data) - 1, &new_config.resident_async_pools))
+                if (!ChangeAsyncLimit(instance, 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))
+                if (!ChangeAsyncLimit(instance, key.c_str(), value, MaxAsyncCalls, &max_async_calls))
                     return env.Null();
             } else if (key == "max_type_size") {
-                if (!ChangeSize(key.c_str(), value, 32, Mebibytes(512), &new_config.max_type_size))
+                if (!ChangeSize(instance, key.c_str(), value, 32, Mebibytes(512), &new_config.max_type_size))
                     return env.Null();
             } else {
                 ThrowError<Napi::Error>(env, "Unexpected config member '%1'", key.c_str());
@@ -175,7 +179,7 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
 static Napi::Value GetStats(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     Napi::Object obj = Napi::Object::New(env);
 
@@ -228,9 +232,9 @@ static bool FinalizeCompositeType(Napi::Env env, TypeInfo *type, PrimitiveKind p
     if (node_api_create_property_key_utf8) {
         for (RecordMember &member: type->members) {
             napi_value key = nullptr;
-            node_api_create_property_key_utf8(env, member.name, NAPI_AUTO_LENGTH, &key);
 
-            napi_create_reference(env, key, 1, &member.key);
+            NAPI_OK(node_api_create_property_key_utf8(env, member.name, NAPI_AUTO_LENGTH, &key));
+            NAPI_OK(napi_create_reference(env, key, 1, &member.key));
         }
     }
 
@@ -247,7 +251,7 @@ static bool FinalizeCompositeType(Napi::Env env, TypeInfo *type, PrimitiveKind p
 static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 or 2 arguments, got %1", info.Length());
@@ -299,11 +303,12 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         replace = external.Data();
 #else
         TypeObject *defn = nullptr;
-        napi_unwrap(env, name, (void **)&defn);
+        NAPI_OK(napi_unwrap(env, name, (void **)&defn));
 
         replace = (TypeInfo *)defn->GetType();
 #endif
 
+        type->instance = instance;
         type->name = replace->name;
 
         if (replace->primitive != PrimitiveKind::Void || replace == instance->void_type) {
@@ -311,11 +316,13 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
             return env.Null();
         }
     } else if (named) {
+        type->instance = instance;
         type->name = DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr;
 
         if (!MapType(env, instance, type, type->name))
             return env.Null();
     } else {
+        type->instance = instance;
         type->name = Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.count).ptr;
     }
 
@@ -353,7 +360,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
             align = (int16_t)align64;
         }
 
-        member.type = ResolveType(value);
+        member.type = ResolveType(instance, value);
         if (!member.type)
             return env.Null();
         if (!CanStoreType(member.type)) {
@@ -425,11 +432,12 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
     err_guard.Disable();
 
     if (replace) {
-        std::swap(*type, *replace);
+        *replace = std::move(*type);
         type = replace;
     }
 
-    return WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
+    return Napi::Value(env, wrapper);
 }
 
 static Napi::Value CreatePaddedStructType(const Napi::CallbackInfo &info)
@@ -445,7 +453,7 @@ static Napi::Value CreatePackedStructType(const Napi::CallbackInfo &info)
 static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 or 2 arguments, got %1", info.Length());
@@ -497,11 +505,12 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
         replace = external.Data();
 #else
         TypeObject *defn = nullptr;
-        napi_unwrap(env, name, (void **)&defn);
+        NAPI_OK(napi_unwrap(env, name, (void **)&defn));
 
         replace = (TypeInfo *)defn->GetType();
 #endif
 
+        type->instance = instance;
         type->name = replace->name;
 
         if (replace->primitive != PrimitiveKind::Void || replace == instance->void_type) {
@@ -509,11 +518,13 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
             return env.Null();
         }
     } else if (named) {
+        type->instance = instance;
         type->name = DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr;
 
         if (!MapType(env, instance, type, type->name))
             return env.Null();
     } else {
+        type->instance = instance;
         type->name = Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.count).ptr;
     }
 
@@ -551,7 +562,7 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
             align = (int16_t)align64;
         }
 
-        member.type = ResolveType(value);
+        member.type = ResolveType(instance, value);
         if (!member.type)
             return env.Null();
         if (!CanStoreType(member.type)) {
@@ -592,19 +603,22 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
         return env.Null();
     err_guard.Disable();
 
-    type->construct = Napi::Persistent(UnionValue::InitClass(env, type));
+    Napi::Object construct = UnionValue::InitClass(instance, type);
+    NAPI_OK(napi_create_reference(env, construct, 1, &type->construct));
 
     if (replace) {
-        std::swap(*type, *replace);
+        *replace = std::move(*type);
         type = replace;
     }
 
-    return WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
+    return Napi::Value(env, wrapper);
 }
 
 Napi::Value InstantiateUnion(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (!info.IsConstructCall()) {
         ThrowError<Napi::TypeError>(env, "This function is a constructor and must be called with new");
@@ -615,7 +629,7 @@ Napi::Value InstantiateUnion(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    const TypeInfo *type = ResolveType(info[0]);
+    const TypeInfo *type = ResolveType(instance, info[0]);
     if (!type)
         return env.Null();
     if (type->primitive != PrimitiveKind::Union) {
@@ -623,7 +637,15 @@ Napi::Value InstantiateUnion(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    Napi::Object wrapper = type->construct.New({}).As<Napi::Object>();
+    Napi::Function construct;
+    {
+        napi_value value;
+        NAPI_OK(napi_get_reference_value(env, type->construct, &value));
+
+        construct = Napi::Function(env, value);
+    }
+
+    Napi::Object wrapper = construct.New({}).As<Napi::Object>();
     SetValueTag(env, wrapper, &UnionValueMarker);
 
     return wrapper;
@@ -632,7 +654,7 @@ Napi::Value InstantiateUnion(const Napi::CallbackInfo &info)
 static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     bool named = (info.Length() >= 1) && !IsNullOrUndefined(env, info[0]);
 
@@ -646,6 +668,7 @@ static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
     TypeInfo *type = instance->types.AppendDefault();
     K_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
+    type->instance = instance;
     type->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr
                        : Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.count).ptr;
 
@@ -658,13 +681,14 @@ static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
         return env.Null();
     err_guard.Disable();
 
-    return WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
+    return Napi::Value(env, wrapper);
 }
 
 static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 to 3 arguments, got %1", info.Length());
@@ -681,7 +705,7 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
 
     std::string name = named ? info[0].As<Napi::String>() : std::string();
 
-    const TypeInfo *ref = ResolveType(info[skip]);
+    const TypeInfo *ref = ResolveType(instance, info[skip]);
     if (!ref)
         return env.Null();
 
@@ -713,7 +737,7 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
 
         memcpy((void *)copy, type, K_SIZE(*type));
         copy->name = named ? DuplicateString(name.c_str(), &instance->str_alloc).ptr : copy->name;
-        memset((void *)&copy->defn, 0, K_SIZE(copy->defn));
+        copy->defn = nullptr;
 
         static_assert(!std::is_polymorphic_v<Napi::ObjectReference>);
 
@@ -730,7 +754,8 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
         type = copy;
     }
 
-    return WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
+    return Napi::Value(env, wrapper);
 }
 
 static Napi::Value EncodePointerDirection(const Napi::CallbackInfo &info, int directions)
@@ -738,13 +763,14 @@ static Napi::Value EncodePointerDirection(const Napi::CallbackInfo &info, int di
     K_ASSERT(directions >= 1 && directions <= 3);
 
     Napi::Env env = info.Env();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
         return env.Null();
     }
 
-    const TypeInfo *type = ResolveType(info[0]);
+    const TypeInfo *type = ResolveType(instance, info[0]);
     if (!type)
         return env.Null();
 
@@ -783,7 +809,7 @@ static Napi::Value MarkInOut(const Napi::CallbackInfo &info)
 static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 or 2 arguments, got %1", info.Length());
@@ -800,7 +826,7 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
 
     Napi::String name = info[0].As<Napi::String>();
 
-    const TypeInfo *src = ResolveType(info[skip]);
+    const TypeInfo *src = ResolveType(instance, info[skip]);
     if (!src)
         return env.Null();
     if (src->primitive != PrimitiveKind::Pointer &&
@@ -825,23 +851,21 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
             return env.Null();
         }
 
-        dispose = [](Napi::Env env, const TypeInfo *type, const void *ptr) {
-            InstanceData *instance = env.GetInstanceData<InstanceData>();
-            const Napi::FunctionReference &ref = type->dispose_ref;
+        dispose = [](InstanceData *instance, const TypeInfo *type, const void *ptr) {
+            Napi::Env env = instance->env;
 
-            Napi::Value p = WrapPointer(env, type->ref.type, (void *)ptr);
+            napi_value func;
+            NAPI_OK(napi_get_reference_value(env, type->dispose_ref, &func));
 
             napi_value self = env.Null();
-            napi_value args[] = { p };
+            napi_value wrapper = WrapPointer(env, type->ref.type, (void *)ptr);
 
-            ref.Call(self, K_LEN(args), args);
+            NAPI_OK(napi_call_function(env, self, func, 1, &wrapper, nullptr));
             instance->stats.disposed++;
         };
         dispose_func = func;
     } else {
-        dispose = [](Napi::Env env, const TypeInfo *, const void *ptr) {
-            InstanceData *instance = env.GetInstanceData<InstanceData>();
-
+        dispose = [](InstanceData *instance, const TypeInfo *, const void *ptr) {
             free((void *)ptr);
             instance->stats.disposed++;
         };
@@ -851,9 +875,8 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     K_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
     memcpy((void *)type, (const void *)src, K_SIZE(*src));
-    type->members.allocator = GetNullAllocator();
-    type->members.allocator = GetNullAllocator();
-    memset((void *)&type->defn, 0, K_SIZE(type->defn));
+    type->defn = nullptr;
+    K_ASSERT(!type->members.len);
 
     static_assert(!std::is_polymorphic_v<Napi::ObjectReference>);
 
@@ -861,7 +884,7 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
                        : Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.count).ptr;
 
     type->dispose = dispose;
-    type->dispose_ref = Napi::Persistent(dispose_func);
+    NAPI_OK(napi_create_reference(env, dispose_func, 1, &type->dispose_ref));
 
     // If the insert succeeds, we cannot fail anymore
     if (named) {
@@ -875,13 +898,14 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     }
     err_guard.Disable();
 
-    return WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
+    return Napi::Value(env, wrapper);
 }
 
 static Napi::Value CallAlloc(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 2) {
         ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
@@ -892,7 +916,7 @@ static Napi::Value CallAlloc(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    const TypeInfo *type = ResolveType(info[0]);
+    const TypeInfo *type = ResolveType(instance, info[0]);
     if (!type)
         return env.Null();
 
@@ -921,12 +945,14 @@ static Napi::Value CallAlloc(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    return WrapPointer(env, type, ptr);
+    napi_value wrapper = WrapPointer(env, type, ptr);
+    return Napi::Value(env, wrapper);
 }
 
 static Napi::Value CallFree(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
@@ -935,8 +961,6 @@ static Napi::Value CallFree(const Napi::CallbackInfo &info)
 
     void *ptr = nullptr;
     if (!TryPointer(env, info[0], &ptr)) {
-        InstanceData *instance = Napi::Env(env).GetInstanceData<InstanceData>();
-
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected pointer", GetValueType(instance, info[0]));
         return env.Null();
     }
@@ -949,7 +973,7 @@ static Napi::Value CallFree(const Napi::CallbackInfo &info)
 static Napi::Value GetOrSetErrNo(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() >= 1) {
         Napi::Number value = info[0].As<Napi::Number>();
@@ -969,14 +993,14 @@ static Napi::Value GetOrSetErrNo(const Napi::CallbackInfo &info)
 static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 2) {
         ThrowError<Napi::TypeError>(env, "Expected 2 to 4 arguments, got %1", info.Length());
         return env.Null();
     }
 
-    const TypeInfo *ref = ResolveType(info[0]);
+    const TypeInfo *ref = ResolveType(instance, info[0]);
     if (!ref)
         return env.Null();
 
@@ -1024,10 +1048,19 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
             }
 
             hint = ArrayHint::Typed;
+        } else if (str == "Buffer" || str == "buffer") {
+            if (!(ref->flags & (int)TypeFlag::HasTypedArray)) {
+                ThrowError<Napi::Error>(env, "Array hint 'Buffer' cannot be used with type %1", ref->name);
+                return env.Null();
+            }
+
+            hint = ArrayHint::Buffer;
         } else if (str == "Array" || str == "array") {
             hint = ArrayHint::Array;
         } else if (str == "String" || str == "string") {
-            if (ref->primitive != PrimitiveKind::Int8 && ref->primitive != PrimitiveKind::Int16) {
+            if (ref->primitive != PrimitiveKind::Int8 &&
+                    ref->primitive != PrimitiveKind::Int16 &&
+                    ref->primitive != PrimitiveKind::Int32) {
                 ThrowError<Napi::Error>(env, "Array hint 'String' can only be used with 8, 16 and 32-bit signed integer types");
                 return env.Null();
             }
@@ -1048,7 +1081,8 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
         type->countedby = DuplicateString(str.Utf8Value().c_str(), &instance->str_alloc).ptr;
     }
 
-    return WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
+    return Napi::Value(env, wrapper);
 }
 
 static bool ParseClassicFunction(const Napi::CallbackInfo &info, bool concrete, FunctionInfo *out_func)
@@ -1056,7 +1090,7 @@ static bool ParseClassicFunction(const Napi::CallbackInfo &info, bool concrete,
     K_ASSERT(info.Length() >= 2);
 
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     Napi::String name = info[0u].As<Napi::String>();
     Napi::Value ret = info[1u];
@@ -1099,7 +1133,7 @@ static bool ParseClassicFunction(const Napi::CallbackInfo &info, bool concrete,
     // Leave anonymous naming responsibility to caller
     out_func->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr : nullptr;
 
-    out_func->ret.type = ResolveType(ret);
+    out_func->ret.type = ResolveType(instance, ret);
     if (!out_func->ret.type)
         return false;
     if (!CanReturnType(out_func->ret.type)) {
@@ -1126,7 +1160,7 @@ static bool ParseClassicFunction(const Napi::CallbackInfo &info, bool concrete,
     for (uint32_t j = 0; j < parameters_len; j++) {
         ParameterInfo param = {};
 
-        param.type = ResolveType(parameters[j], &param.directions);
+        param.type = ResolveType(instance, parameters[j].AsValue(), &param.directions);
 
         if (!param.type)
             return false;
@@ -1152,7 +1186,7 @@ static bool ParseClassicFunction(const Napi::CallbackInfo &info, bool concrete,
 static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     FunctionInfo *func = instance->callbacks.AppendDefault();
     K_DEFER_N(err_guard) { instance->callbacks.RemoveLast(1); };
@@ -1170,7 +1204,7 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
         }
 
         std::string proto = info[0u].As<Napi::String>();
-        if (!ParsePrototype(env, proto.c_str(), false, func))
+        if (!ParsePrototype(instance, proto.c_str(), false, func))
             return env.Null();
     } else {
         ThrowError<Napi::TypeError>(env, "Expected 1 to 4 arguments, got %1", info.Length());
@@ -1195,6 +1229,7 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
 
     TypeInfo *type = instance->types.AppendDefault();
 
+    type->instance = instance;
     type->name = func->name;
 
     type->primitive = PrimitiveKind::Prototype;
@@ -1204,13 +1239,14 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
 
     instance->types_map.Set(type->name, type);
 
-    return WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
+    return Napi::Value(env, wrapper);
 }
 
 static Napi::Value CreateEnumType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 or 2 arguments, got %1", info.Length());
@@ -1236,6 +1272,7 @@ static Napi::Value CreateEnumType(const Napi::CallbackInfo &info)
     TypeInfo *type = instance->types.AppendDefault();
     K_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
+    type->instance = instance;
     type->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr
                        : Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.count).ptr;
 
@@ -1243,7 +1280,7 @@ static Napi::Value CreateEnumType(const Napi::CallbackInfo &info)
 
     // Determine needed storage type
     if (typed) {
-        const TypeInfo *storage = ResolveType(info[1 + named]);
+        const TypeInfo *storage = ResolveType(instance, info[1 + named]);
         if (!storage)
             return env.Null();
 
@@ -1360,19 +1397,30 @@ static Napi::Value CreateEnumType(const Napi::CallbackInfo &info)
         return env.Null();
     err_guard.Disable();
 
-    Napi::Value wrapper = WrapType(env, type, false);
-    Napi::Object defn = type->defn.Value();
+    napi_value wrapper = WrapType(instance, type, false);
+
+#if defined(EXTERNAL_TYPES)
+    Napi::Object defn;
+    {
+        napi_value value;
+        NAPI_OK(napi_get_reference_value(env, type->defn, &defn));
+
+        defn = Napi::Object(env, value);
+    }
+#else
+    Napi::Object defn(env, wrapper);
+#endif
 
     defn.Set("values", values);
     defn.Freeze();
 
-    return wrapper;
+    return Napi::Value(env, wrapper);
 }
 
 static Napi::Value CreateTypeAlias(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 2) {
         ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
@@ -1386,7 +1434,7 @@ static Napi::Value CreateTypeAlias(const Napi::CallbackInfo &info)
     std::string name = info[0].As<Napi::String>();
     const char *alias = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
 
-    const TypeInfo *type = ResolveType(info[1]);
+    const TypeInfo *type = ResolveType(instance, info[1]);
     if (!type)
         return env.Null();
 
@@ -1394,23 +1442,26 @@ static Napi::Value CreateTypeAlias(const Napi::CallbackInfo &info)
     if (!MapType(env, instance, type, alias))
         return env.Null();
 
-    return WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
+    return Napi::Value(env, wrapper);
 }
 
 static Napi::Value GetResolvedType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
         return env.Null();
     }
 
-    const TypeInfo *type = ResolveType(info[0]);
+    const TypeInfo *type = ResolveType(instance, info[0]);
     if (!type)
         return env.Null();
 
-    return WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
+    return Napi::Value(env, wrapper);
 }
 
 #if defined(EXTERNAL_TYPES)
@@ -1418,20 +1469,24 @@ static Napi::Value GetResolvedType(const Napi::CallbackInfo &info)
 static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
         return env.Null();
     }
 
-    const TypeInfo *type = ResolveType(info[0]);
+    const TypeInfo *type = ResolveType(instance, info[0]);
     if (!type)
         return env.Null();
 
     // Make sure definition is available
-    WrapType(env, type);
+    WrapType(instance, type);
 
-    return type->defn.Value();
+    napi_value defn;
+    NAPI_OK(napi_get_reference_value(env, instance->defn, &defn));
+
+    return defn;
 }
 
 #endif
@@ -1530,13 +1585,32 @@ void ReleaseMemory(InstanceData *instance, InstanceMemory *mem)
     }
 }
 
-Napi::Function LibraryHandle::InitClass(Napi::Env env)
+TypeInfo::~TypeInfo()
+{
+    if (!instance)
+        return;
+
+    Napi::Env env = instance->env;
+
+    for (RecordMember &member: members) {
+        node_api_delete_reference(env, member.key);
+        member.key = nullptr;
+    }
+
+    node_api_delete_reference(env, dispose_ref);
+    node_api_delete_reference(env, construct);
+    node_api_delete_reference(env, defn);
+}
+
+Napi::Function LibraryHandle::InitClass(InstanceData *instance)
 {
+    Napi::Env env = instance->env;
+
     // node-addon-api wants std::vector
     std::vector<Napi::ClassPropertyDescriptor<LibraryHandle>> properties = {
-        InstanceMethod("func", &LibraryHandle::Func),
-        InstanceMethod("symbol", &LibraryHandle::Symbol),
-        InstanceMethod("unload", &LibraryHandle::Unload)
+        InstanceMethod("func", &LibraryHandle::Func, napi_default, instance),
+        InstanceMethod("symbol", &LibraryHandle::Symbol, napi_default, instance),
+        InstanceMethod("unload", &LibraryHandle::Unload, napi_default, instance)
     };
 
     if (Napi::Value dispose = env.RunScript("Symbol.dispose"); !IsNullOrUndefined(env, dispose)) {
@@ -1564,7 +1638,7 @@ LibraryHandle::LibraryHandle(const Napi::CallbackInfo &info)
 
 void LibraryHandle::Finalize(Napi::BasicEnv env)
 {
-    DeleteReferenceSafe(env, *this);
+    node_api_delete_reference(env, *this);
     SuppressDestruct();
 
     lib->Unref();
@@ -1573,7 +1647,7 @@ void LibraryHandle::Finalize(Napi::BasicEnv env)
 Napi::Value LibraryHandle::Func(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     FunctionInfo *func = new FunctionInfo();
     K_DEFER { func->Unref(); };
@@ -1592,7 +1666,7 @@ Napi::Value LibraryHandle::Func(const Napi::CallbackInfo &info)
         }
 
         std::string proto = info[0u].As<Napi::String>();
-        if (!ParsePrototype(env, proto.c_str(), true, func))
+        if (!ParsePrototype(instance, proto.c_str(), true, func))
             return env.Null();
     } else {
         ThrowError<Napi::TypeError>(env, "Expected 1 to 4 arguments, got %1", info.Length());
@@ -1635,28 +1709,40 @@ Napi::Value LibraryHandle::Func(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    return WrapFunction(env, func);
+    napi_value wrapper = WrapFunction(instance, func);
+    return Napi::Value(env, wrapper);
 }
 
 Napi::Value LibraryHandle::Symbol(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
+#if defined(EXTERNAL_POINTERS)
     if (info.Length() < 2) {
-        ThrowError<Napi::TypeError>(env, "Expected 2, got %1", info.Length());
+        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
         return env.Null();
     }
-     if (!info[0].IsString()) {
+#else
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        return env.Null();
+    }
+#endif
+    if (!info[0].IsString()) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
         return env.Null();
     }
 
     std::string name = info[0].As<Napi::String>();
 
-    const TypeInfo *type = ResolveType(info[1]);
+#if defined(EXTERNAL_POINTERS)
+    const TypeInfo *type = ResolveType(instance, info[1]);
     if (!type)
         return env.Null();
+#else
+    const TypeInfo *type = nullptr;
+#endif
 
 #if defined(_WIN32)
     void *ptr = (void *)GetProcAddress((HMODULE)lib->module, name.c_str());
@@ -1668,7 +1754,8 @@ Napi::Value LibraryHandle::Symbol(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    return WrapPointer(env, type, ptr);
+    napi_value wrapper = WrapPointer(env, type, ptr);
+    return Napi::Value(env, wrapper);
 }
 
 Napi::Value LibraryHandle::Unload(const Napi::CallbackInfo &info)
@@ -1683,7 +1770,7 @@ Napi::Value LibraryHandle::Unload(const Napi::CallbackInfo &info)
 static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 or 2 arguments, got %1", info.Length());
@@ -1768,7 +1855,7 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
 static Napi::Value RegisterCallback(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (!InitAsyncBroker(env, instance)) [[unlikely]]
         return env.Null();
@@ -1784,7 +1871,7 @@ static Napi::Value RegisterCallback(const Napi::CallbackInfo &info)
 
     Napi::Function func = info[0].As<Napi::Function>();
 
-    const TypeInfo *type = ResolveType(info[1]);
+    const TypeInfo *type = ResolveType(instance, info[1]);
     if (!type)
         return env.Null();
     if (type->primitive != PrimitiveKind::Callback) {
@@ -1811,20 +1898,21 @@ static Napi::Value RegisterCallback(const Napi::CallbackInfo &info)
     trampoline->instance = instance;
     trampoline->stack0 = instance->memories[0]->stack0;
     trampoline->proto = type->proto;
-    napi_create_reference(env, func, 1, &trampoline->func);
+    NAPI_OK(napi_create_reference(env, func, 1, &trampoline->func));
 
     void *ptr = GetTrampoline(idx);
 
     // Cache index for fast unregistration
     instance->trampolines_map.Set(ptr, idx);
 
-    return WrapPointer(env, type->ref.type, ptr);
+    napi_value wrapper = WrapPointer(env, type->ref.type, ptr);
+    return Napi::Value(env, wrapper);
 }
 
 static Napi::Value UnregisterCallback(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
@@ -1858,7 +1946,7 @@ static Napi::Value UnregisterCallback(const Napi::CallbackInfo &info)
         K_ASSERT(trampoline->func);
 
         trampoline->state = 0;
-        napi_delete_reference(env, trampoline->func);
+        node_api_delete_reference(env, trampoline->func);
         trampoline->func = nullptr;
 
         shared.available.Append(idx);
@@ -1870,6 +1958,7 @@ static Napi::Value UnregisterCallback(const Napi::CallbackInfo &info)
 static Napi::Value CastValue(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 2) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
@@ -1878,7 +1967,7 @@ static Napi::Value CastValue(const Napi::CallbackInfo &info)
 
     Napi::Value value = info[0];
 
-    const TypeInfo *type = ResolveType(info[1]);
+    const TypeInfo *type = ResolveType(instance, info[1]);
     if (!type) [[unlikely]]
         return env.Null();
     if (type->primitive != PrimitiveKind::Pointer &&
@@ -1893,10 +1982,10 @@ static Napi::Value CastValue(const Napi::CallbackInfo &info)
     ValueCast *cast = new ValueCast();
 
     cast->env = env;
-    napi_create_reference(env, value, 1, &cast->ref);
+    NAPI_OK(napi_create_reference(env, value, 1, &cast->ref));
     cast->type = type;
 
-    Napi::External<ValueCast> external = Napi::External<ValueCast>::New(env, cast, [](Napi::Env, ValueCast *cast) { delete cast; });
+    Napi::External<ValueCast> external = Napi::External<ValueCast>::New(env, cast, [](Napi::BasicEnv, ValueCast *cast) { delete cast; });
     SetValueTag(env, external, &CastMarker);
 
     return external;
@@ -1905,6 +1994,7 @@ static Napi::Value CastValue(const Napi::CallbackInfo &info)
 static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     bool has_offset = (info.Length() >= 2 && info[1].IsNumber());
     bool has_len = (info.Length() >= 3u + has_offset && info[2 + has_offset].IsNumber());
@@ -1914,22 +2004,78 @@ static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    const TypeInfo *type = ResolveType(info[1u + has_offset]);
+    const TypeInfo *type = ResolveType(instance, info[1u + has_offset]);
     if (!type) [[unlikely]]
         return env.Null();
 
-    Napi::Value value = info[0];
+    napi_value ref = info[0];
     int64_t offset = has_offset ? info[1].As<Napi::Number>().Int64Value() : 0;
 
+    const void *src = nullptr;
+    Size len = 0;
+
+    if (!TryPointer(env, ref, (void **)&src, &len)) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for reference, expected pointer", GetValueType(instance, ref));
+        return env.Null();
+    }
+
+    if (len >= 0) {
+        if (offset < 0) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "Offset must be >= 0");
+            return env.Null();
+        }
+        if (len - offset < type->size) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "Expected buffer with size superior or equal to type %1 (%2 bytes)",
+                                    type->name, type->size + offset);
+            return env.Null();
+        }
+    }
+
+    if (!src) [[unlikely]] {
+        ThrowError<Napi::Error>(env, "Cannot encode data in NULL pointer");
+        return env.Null();
+    }
+
+    src = (const void *)((const uint8_t *)src + offset);
+
     if (has_len) {
         Size len = info[2 + has_offset].As<Napi::Number>();
 
-        napi_value ret = Decode(value, (Size)offset, type, &len);
-        return Napi::Value(env, ret);
-    } else {
-        napi_value ret = Decode(value, (Size)offset, type);
-        return Napi::Value(env, ret);
+        if (len >= 0) {
+            type = MakeArrayType(instance, type, len);
+        } else {
+            switch (type->primitive) {
+                case PrimitiveKind::Int8:
+                case PrimitiveKind::UInt8: {
+                    Size count = strlen((const char *)src);
+                    type = MakeArrayType(instance, type, count);
+                } break;
+                case PrimitiveKind::Int16:
+                case PrimitiveKind::UInt16: {
+                    Size count = NullTerminatedLength((const char16_t *)src);
+                    type = MakeArrayType(instance, type, count);
+                } break;
+                case PrimitiveKind::Int32:
+                case PrimitiveKind::UInt32: {
+                    Size count = NullTerminatedLength((const char32_t *)src);
+                    type = MakeArrayType(instance, type, count);
+                } break;
+
+                case PrimitiveKind::Pointer: {
+                    Size count = NullTerminatedLength((const void **)src);
+                    type = MakeArrayType(instance, type, count);
+                } break;
+
+                default: {
+                    ThrowError<Napi::TypeError>(env, "Cannot determine null-terminated length for type %1", type->name);
+                    return env.Null();
+                } break;
+            }
+        }
     }
+
+    napi_value ret = Decode(instance, (const uint8_t *)src, type);
+    return Napi::Value(env, ret);
 }
 
 template <typename T>
@@ -1937,9 +2083,9 @@ static FORCE_INLINE napi_value DecodeInteger(napi_env env, napi_callback_info in
 {
     napi_value arg;
     size_t count = 1;
+    InstanceData *instance;
 
-    napi_status status = napi_get_cb_info(env, info, &count, &arg, nullptr, nullptr);
-    K_ASSERT(status == napi_ok);
+    NAPI_OK(napi_get_cb_info(env, info, &count, &arg, nullptr, (void **)&instance));
 
     if (count < 1) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", count);
@@ -1948,8 +2094,6 @@ static FORCE_INLINE napi_value DecodeInteger(napi_env env, napi_callback_info in
 
     void *ptr = nullptr;
     if (!TryPointer(env, arg, &ptr)) [[unlikely]] {
-        InstanceData *instance = Napi::Env(env).GetInstanceData<InstanceData>();
-
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected pointer", GetValueType(instance, arg));
         return Napi::Env(env).Null();
     }
@@ -1960,13 +2104,14 @@ static FORCE_INLINE napi_value DecodeInteger(napi_env env, napi_callback_info in
     return NewInt(env, i);
 }
 
-static napi_value DecodeFloat(napi_env env, napi_callback_info info)
+template <typename T>
+static FORCE_INLINE napi_value DecodeIntegerSwap(napi_env env, napi_callback_info info)
 {
     napi_value arg;
     size_t count = 1;
+    InstanceData *instance;
 
-    napi_status status = napi_get_cb_info(env, info, &count, &arg, nullptr, nullptr);
-    K_ASSERT(status == napi_ok);
+    NAPI_OK(napi_get_cb_info(env, info, &count, &arg, nullptr, (void **)&instance));
 
     if (count < 1) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", count);
@@ -1975,8 +2120,47 @@ static napi_value DecodeFloat(napi_env env, napi_callback_info info)
 
     void *ptr = nullptr;
     if (!TryPointer(env, arg, &ptr)) [[unlikely]] {
-        InstanceData *instance = Napi::Env(env).GetInstanceData<InstanceData>();
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected pointer", GetValueType(instance, arg));
+        return Napi::Env(env).Null();
+    }
+
+    T i;
+    memcpy(&i, ptr, K_SIZE(i));
+
+    return NewInt(env, ReverseBytes(i));
+}
+
+#if defined(K_BIG_ENDIAN)
+
+template <typename T>
+static FORCE_INLINE napi_value DecodeIntegerLE(napi_env env, napi_callback_info info) { return DecodeIntegerSwap<T>(env, info); }
+template <typename T>
+static FORCE_INLINE napi_value DecodeIntegerBE(napi_env env, napi_callback_info info) { return DecodeInteger<T>(env, info); }
+
+#else
 
+template <typename T>
+static FORCE_INLINE napi_value DecodeIntegerLE(napi_env env, napi_callback_info info) { return DecodeInteger<T>(env, info); }
+template <typename T>
+static FORCE_INLINE napi_value DecodeIntegerBE(napi_env env, napi_callback_info info) { return DecodeIntegerSwap<T>(env, info); }
+
+#endif
+
+static napi_value DecodeFloat(napi_env env, napi_callback_info info)
+{
+    napi_value arg;
+    size_t count = 1;
+    InstanceData *instance;
+
+    NAPI_OK(napi_get_cb_info(env, info, &count, &arg, nullptr, (void **)&instance));
+
+    if (count < 1) [[unlikely]] {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", count);
+        return Napi::Env(env).Null();
+    }
+
+    void *ptr = nullptr;
+    if (!TryPointer(env, arg, &ptr)) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected pointer", GetValueType(instance, arg));
         return Napi::Env(env).Null();
     }
@@ -1984,16 +2168,16 @@ static napi_value DecodeFloat(napi_env env, napi_callback_info info)
     float f;
     memcpy(&f, ptr, K_SIZE(f));
 
-    return Napi::Number::New(env, (double)f);
+    return NewFloat(env, f);
 }
 
 static napi_value DecodeDouble(napi_env env, napi_callback_info info)
 {
     napi_value arg;
     size_t count = 1;
+    InstanceData *instance;
 
-    napi_status status = napi_get_cb_info(env, info, &count, &arg, nullptr, nullptr);
-    K_ASSERT(status == napi_ok);
+    NAPI_OK(napi_get_cb_info(env, info, &count, &arg, nullptr, (void **)&instance));
 
     if (count < 1) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", count);
@@ -2002,8 +2186,6 @@ static napi_value DecodeDouble(napi_env env, napi_callback_info info)
 
     void *ptr = nullptr;
     if (!TryPointer(env, arg, &ptr)) [[unlikely]] {
-        InstanceData *instance = Napi::Env(env).GetInstanceData<InstanceData>();
-
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected pointer", GetValueType(instance, arg));
         return Napi::Env(env).Null();
     }
@@ -2011,16 +2193,16 @@ static napi_value DecodeDouble(napi_env env, napi_callback_info info)
     double d;
     memcpy(&d, ptr, K_SIZE(d));
 
-    return Napi::Number::New(env, d);
+    return NewFloat(env, d);
 }
 
 static napi_value DecodeString(napi_env env, napi_callback_info info)
 {
     napi_value args[2];
     size_t count = 2;
+    InstanceData *instance;
 
-    napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, nullptr);
-    K_ASSERT(status == napi_ok);
+    NAPI_OK(napi_get_cb_info(env, info, &count, args, nullptr, (void **)&instance));
 
     if (count < 1) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 1 to 2 arguments, got %1", count);
@@ -2029,8 +2211,6 @@ static napi_value DecodeString(napi_env env, napi_callback_info info)
 
     void *ptr = nullptr;
     if (!TryPointer(env, args[0], &ptr)) [[unlikely]] {
-        InstanceData *instance = Napi::Env(env).GetInstanceData<InstanceData>();
-
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected pointer", GetValueType(instance, args[0]));
         return Napi::Env(env).Null();
     }
@@ -2038,15 +2218,13 @@ static napi_value DecodeString(napi_env env, napi_callback_info info)
     if (count >= 2) {
         Size len;
         if (!TryNumber(env, args[1], &len)) [[unlikely]] {
-            InstanceData *instance = Napi::Env(env).GetInstanceData<InstanceData>();
-
             ThrowError<Napi::TypeError>(env, "Unexpected %1 value for length, expected number", GetValueType(instance, args[1]));
             return Napi::Env(env).Null();
         }
 
-        return Napi::String::New(env, (const char *)ptr, (size_t)len);
+        return NewString(env, (const char *)ptr, (size_t)len);
     } else {
-        return Napi::String::New(env, (const char *)ptr);
+        return NewString(env, (const char *)ptr);
     }
 }
 
@@ -2054,9 +2232,9 @@ static napi_value DecodeString16(napi_env env, napi_callback_info info)
 {
     napi_value args[2];
     size_t count = 2;
+    InstanceData *instance;
 
-    napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, nullptr);
-    K_ASSERT(status == napi_ok);
+    NAPI_OK(napi_get_cb_info(env, info, &count, args, nullptr, (void **)&instance));
 
     if (count < 1) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 1 to 2 arguments, got %1", count);
@@ -2065,8 +2243,6 @@ static napi_value DecodeString16(napi_env env, napi_callback_info info)
 
     void *ptr = nullptr;
     if (!TryPointer(env, args[0], &ptr)) [[unlikely]] {
-        InstanceData *instance = Napi::Env(env).GetInstanceData<InstanceData>();
-
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected pointer", GetValueType(instance, args[0]));
         return Napi::Env(env).Null();
     }
@@ -2074,15 +2250,13 @@ static napi_value DecodeString16(napi_env env, napi_callback_info info)
     if (count >= 2) {
         Size len;
         if (!TryNumber(env, args[1], &len)) [[unlikely]] {
-            InstanceData *instance = Napi::Env(env).GetInstanceData<InstanceData>();
-
             ThrowError<Napi::TypeError>(env, "Unexpected %1 value for length, expected number", GetValueType(instance, args[1]));
             return Napi::Env(env).Null();
         }
 
-        return Napi::String::New(env, (const char16_t *)ptr, (size_t)len);
+        return NewString(env, (const char16_t *)ptr, (size_t)len);
     } else {
-        return Napi::String::New(env, (const char16_t *)ptr);
+        return NewString(env, (const char16_t *)ptr);
     }
 }
 
@@ -2090,9 +2264,9 @@ static napi_value DecodeString32(napi_env env, napi_callback_info info)
 {
     napi_value args[2];
     size_t count = 2;
+    InstanceData *instance;
 
-    napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, nullptr);
-    K_ASSERT(status == napi_ok);
+    NAPI_OK(napi_get_cb_info(env, info, &count, args, nullptr, (void **)&instance));
 
     if (count < 1) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 1 to 2 arguments, got %1", count);
@@ -2101,8 +2275,6 @@ static napi_value DecodeString32(napi_env env, napi_callback_info info)
 
     void *ptr = nullptr;
     if (!TryPointer(env, args[0], &ptr)) [[unlikely]] {
-        InstanceData *instance = Napi::Env(env).GetInstanceData<InstanceData>();
-
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected pointer", GetValueType(instance, args[0]));
         return Napi::Env(env).Null();
     }
@@ -2110,21 +2282,20 @@ static napi_value DecodeString32(napi_env env, napi_callback_info info)
     if (count >= 2) {
         Size len;
         if (!TryNumber(env, args[1], &len)) [[unlikely]] {
-            InstanceData *instance = Napi::Env(env).GetInstanceData<InstanceData>();
-
             ThrowError<Napi::TypeError>(env, "Unexpected %1 value for length, expected number", GetValueType(instance, args[1]));
             return Napi::Env(env).Null();
         }
 
-        return MakeStringFromUTF32(env, (const char32_t *)ptr, len);
+        return NewString(env, (const char32_t *)ptr, len);
     } else {
-        return MakeStringFromUTF32(env, (const char32_t *)ptr);
+        return NewString(env, (const char32_t *)ptr);
     }
 }
 
 static Napi::Value GetPointerAddress(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
@@ -2133,8 +2304,6 @@ static Napi::Value GetPointerAddress(const Napi::CallbackInfo &info)
 
     void *ptr = nullptr;
     if (!TryPointer(env, info[0], &ptr)) {
-        InstanceData *instance = Napi::Env(env).GetInstanceData<InstanceData>();
-
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected pointer", GetValueType(instance, info[0]));
         return env.Null();
     }
@@ -2148,6 +2317,7 @@ static Napi::Value GetPointerAddress(const Napi::CallbackInfo &info)
 static Napi::Value CallPointerSync(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 2) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 2 or more arguments, got %1", info.Length());
@@ -2156,18 +2326,14 @@ static Napi::Value CallPointerSync(const Napi::CallbackInfo &info)
 
     void *ptr = nullptr;
     if (!TryPointer(env, info[0], &ptr)) {
-        InstanceData *instance = Napi::Env(env).GetInstanceData<InstanceData>();
-
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected pointer", GetValueType(instance, info[0]));
         return env.Null();
     }
 
-    const TypeInfo *type = ResolveType(info[1]);
+    const TypeInfo *type = ResolveType(instance, info[1]);
     if (!type) [[unlikely]]
         return env.Null();
     if (type->primitive != PrimitiveKind::Prototype) [[unlikely]] {
-        InstanceData *instance = env.GetInstanceData<InstanceData>();
-
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for type, expected function type", GetValueType(instance, info[1]));
         return env.Null();
     }
@@ -2179,6 +2345,7 @@ static Napi::Value CallPointerSync(const Napi::CallbackInfo &info)
 static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     bool has_offset = (info.Length() >= 2 && info[1].IsNumber());
     bool has_len = (info.Length() >= 4u + has_offset && info[3 + has_offset].IsNumber());
@@ -2188,7 +2355,7 @@ static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    const TypeInfo *type = ResolveType(info[1u + has_offset]);
+    const TypeInfo *type = ResolveType(instance, info[1u + has_offset]);
     if (!type) [[unlikely]]
         return env.Null();
 
@@ -2196,38 +2363,71 @@ static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
     int64_t offset = has_offset ? info[1].As<Napi::Number>().Int64Value() : 0;
     Napi::Value value = info[2 + has_offset];
 
-    if (has_len) {
-        Size len = info[3 + has_offset].As<Napi::Number>();
+    void *dest = nullptr;
+    Size len = 0;
 
-        if (!Encode(ref, (Size)offset, value, type, &len))
+    if (!TryPointer(env, ref, &dest, &len)) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for reference, expected pointer", GetValueType(instance, ref));
+        return env.Null();
+    }
+
+    if (len >= 0) {
+        if (offset < 0) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "Offset must be >= 0");
             return env.Null();
-    } else {
-        if (!Encode(ref, (Size)offset, value, type))
+        }
+        if (len - offset < type->size) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "Expected buffer with size superior or equal to type %1 (%2 bytes)",
+                                    type->name, type->size + offset);
             return env.Null();
+        }
+    }
+
+    if (!dest) [[unlikely]] {
+        ThrowError<Napi::Error>(env, "Cannot encode data in NULL pointer");
+        return env.Null();
+    }
+
+    dest = (void *)((uint8_t *)dest + offset);
+
+    if (has_len) {
+        Size len = info[3 + has_offset].As<Napi::Number>();
+
+        if (type->primitive != PrimitiveKind::String &&
+                type->primitive != PrimitiveKind::String16 &&
+                type->primitive != PrimitiveKind::String32 &&
+                type->primitive != PrimitiveKind::Prototype) {
+            if (len < 0) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Automatic (negative) length is only supported when decoding");
+                return env.Null();
+            }
+
+            type = MakeArrayType(instance, type, len);
+        }
     }
 
+    if (!Encode(instance, (uint8_t *)dest, value, type))
+        return env.Null();
+
     return env.Undefined();
 }
 
 static Napi::Value CreateView(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (info.Length() < 1) {
         ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
         return env.Null();
     }
     if (!info[1].IsNumber()) {
-        InstanceData *instance = env.GetInstanceData<InstanceData>();
-
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for length, expected integer", GetValueType(instance, info[1]));
         return env.Null();
     }
 
     void *ptr = nullptr;
     if (!TryPointer(env, info[0], &ptr)) {
-        InstanceData *instance = Napi::Env(env).GetInstanceData<InstanceData>();
-
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected pointer", GetValueType(instance, info[0]));
         return env.Null();
     }
@@ -2256,7 +2456,7 @@ static Napi::Value CreateView(const Napi::CallbackInfo &info)
 static Napi::Value ResetKoffi(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     if (instance->broker) {
         napi_release_threadsafe_function(instance->broker, napi_tsfn_abort);
@@ -2309,7 +2509,7 @@ void LibraryHolder::Unload()
 
 ValueCast::~ValueCast()
 {
-    DeleteReferenceSafe(env, ref);
+    node_api_delete_reference(env, ref);
 }
 
 FunctionInfo::~FunctionInfo()
@@ -2338,16 +2538,15 @@ InstanceMemory::~InstanceMemory()
 #endif
 }
 
-static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initializer_list<const char *> names,
+static void RegisterPrimitiveType(InstanceData *instance, Napi::Object map, std::initializer_list<const char *> names,
                                   PrimitiveKind primitive, int32_t size, int16_t align, const char *ref = nullptr)
 {
     K_ASSERT(names.size() > 0);
     K_ASSERT(align <= size);
 
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
     TypeInfo *type = instance->types.AppendDefault();
 
+    type->instance = instance;
     type->name = *names.begin();
 
     type->primitive = primitive;
@@ -2369,7 +2568,7 @@ static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initiali
         K_ASSERT(type->ref.type);
     }
 
-    Napi::Value wrapper = WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
 
     for (const char *name: names) {
         bool inserted;
@@ -2428,12 +2627,12 @@ static bool CanCallNapiGetBufferInfoDirectly(const napi_node_version &node, uint
     return false;
 }
 
-static bool CanReferencePrimitiveValues(const napi_node_version &node, uint32_t napi)
+static bool CanReferencePrimitiveValues(const napi_node_version &, uint32_t napi)
 {
     return napi >= 10;
 }
 
-static bool CanDeleteReferenceInFinalizer(const napi_node_version &node, uint32_t napi)
+static bool CanDeleteReferenceInFinalizer(const napi_node_version &node, uint32_t)
 {
     if (node.major >= 24)
         return true;
@@ -2451,12 +2650,12 @@ static bool CanDeleteReferenceInFinalizer(const napi_node_version &node, uint32_
     return false;
 }
 
-static napi_value CreateFunction(napi_env env, napi_callback native, const char *name = nullptr)
+static napi_value CreateFunction(InstanceData *instance, napi_callback native, const char *name = nullptr)
 {
-    napi_value func;
+    Napi::Env env = instance->env;
 
-    napi_status status = napi_create_function(env, name, NAPI_AUTO_LENGTH, native, nullptr, &func);
-    K_ASSERT(status == napi_ok);
+    napi_value func;
+    NAPI_OK(napi_create_function(env, name, NAPI_AUTO_LENGTH, native, instance, &func));
 
     return func;
 }
@@ -2508,6 +2707,21 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
                 // errors out (or even asserts) if it gets called in a finalizer. In this case,
                 // use experimental API to try to run it later.
                 node_api_post_finalizer = SYMBOL(node_api_post_finalizer);
+
+                if (node_api_post_finalizer) {
+                    node_api_delete_reference = [](node_api_basic_env env, napi_ref ref) {
+                        node_api_post_finalizer((napi_env)env, [](napi_env env, void *data, void *) {
+                            napi_ref ref = (napi_ref)data;
+                            napi_delete_reference(env, ref);
+                        }, (void *)ref, nullptr);
+
+                        return napi_ok;
+                    };
+                } else {
+                    node_api_delete_reference = napi_delete_reference;
+                }
+            } else {
+                node_api_delete_reference = napi_delete_reference;
             }
 
             node_api_create_object_with_properties = SYMBOL(node_api_create_object_with_properties);
@@ -2520,85 +2734,102 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     K_CRITICAL(instance, "Failed to initialize Koffi");
 
     instance->env = env;
-    env.SetInstanceData(instance);
 
 #if defined(__clang__)
     // First call to napi_create_double() does some weird stuff I can't explain
     // in clang-cl builds. I don't like this... but this fixes it, somehow ><
-    Napi::Number::New(env, 0.0);
+    NewFloat(env, 0.0);
 #endif
 
-    exports.Set("config", Napi::Function::New(env, GetSetConfig, "config"));
-    exports.Set("stats", Napi::Function::New(env, GetStats, "stats"));
-
-    exports.Set("struct", Napi::Function::New(env, CreatePaddedStructType, "struct"));
-    exports.Set("pack", Napi::Function::New(env, CreatePackedStructType, "pack"));
-    exports.Set("union", Napi::Function::New(env, CreateUnionType, "union"));
-    exports.Set("Union", Napi::Function::New(env, InstantiateUnion, "Union"));
-    exports.Set("opaque", Napi::Function::New(env, CreateOpaqueType, "opaque"));
-    exports.Set("pointer", Napi::Function::New(env, CreatePointerType, "pointer"));
-    exports.Set("array", Napi::Function::New(env, CreateArrayType, "array"));
-    exports.Set("proto", Napi::Function::New(env, CreateFunctionType, "proto"));
-    exports.Set("alias", Napi::Function::New(env, CreateTypeAlias, "alias"));
-    exports.Set("enumeration", Napi::Function::New(env, CreateEnumType, "enumeration"));
-
-    exports.Set("type", Napi::Function::New(env, GetResolvedType, "type"));
+    exports.Set("config", Napi::Function::New(env, GetSetConfig, "config", instance));
+    exports.Set("stats", Napi::Function::New(env, GetStats, "stats", instance));
+
+    exports.Set("struct", Napi::Function::New(env, CreatePaddedStructType, "struct", instance));
+    exports.Set("pack", Napi::Function::New(env, CreatePackedStructType, "pack", instance));
+    exports.Set("union", Napi::Function::New(env, CreateUnionType, "union", instance));
+    exports.Set("Union", Napi::Function::New(env, InstantiateUnion, "Union", instance));
+    exports.Set("opaque", Napi::Function::New(env, CreateOpaqueType, "opaque", instance));
+    exports.Set("pointer", Napi::Function::New(env, CreatePointerType, "pointer", instance));
+    exports.Set("array", Napi::Function::New(env, CreateArrayType, "array", instance));
+    exports.Set("proto", Napi::Function::New(env, CreateFunctionType, "proto", instance));
+    exports.Set("alias", Napi::Function::New(env, CreateTypeAlias, "alias", instance));
+    exports.Set("enumeration", Napi::Function::New(env, CreateEnumType, "enumeration", instance));
+
+    exports.Set("type", Napi::Function::New(env, GetResolvedType, "type", instance));
 #if defined(EXTERNAL_TYPES)
-    exports.Set("introspect", Napi::Function::New(env, GetTypeDefinition, "introspect"));
+    exports.Set("introspect", Napi::Function::New(env, GetTypeDefinition, "introspect", instance));
 #endif
 
-    exports.Set("load", Napi::Function::New(env, LoadSharedLibrary, "load"));
+    exports.Set("load", Napi::Function::New(env, LoadSharedLibrary, "load", instance));
 
-    exports.Set("in", Napi::Function::New(env, MarkIn, "in"));
-    exports.Set("out", Napi::Function::New(env, MarkOut, "out"));
-    exports.Set("inout", Napi::Function::New(env, MarkInOut, "inout"));
+    exports.Set("in", Napi::Function::New(env, MarkIn, "in", instance));
+    exports.Set("out", Napi::Function::New(env, MarkOut, "out", instance));
+    exports.Set("inout", Napi::Function::New(env, MarkInOut, "inout", instance));
 
-    exports.Set("disposable", Napi::Function::New(env, CreateDisposableType, "disposable"));
-    exports.Set("alloc", Napi::Function::New(env, CallAlloc, "alloc"));
-    exports.Set("free", Napi::Function::New(env, CallFree, "free"));
+    exports.Set("disposable", Napi::Function::New(env, CreateDisposableType, "disposable", instance));
+    exports.Set("alloc", Napi::Function::New(env, CallAlloc, "alloc", instance));
+    exports.Set("free", Napi::Function::New(env, CallFree, "free", instance));
 
-    exports.Set("register", Napi::Function::New(env, RegisterCallback, "register"));
-    exports.Set("unregister", Napi::Function::New(env, UnregisterCallback, "unregister"));
+    exports.Set("register", Napi::Function::New(env, RegisterCallback, "register", instance));
+    exports.Set("unregister", Napi::Function::New(env, UnregisterCallback, "unregister", instance));
 
-    exports.Set("as", Napi::Function::New(env, CastValue, "as"));
-    exports.Set("address", Napi::Function::New(env, GetPointerAddress, "address"));
-    exports.Set("call", Napi::Function::New(env, CallPointerSync, "call"));
-    exports.Set("encode", Napi::Function::New(env, EncodeValue, "encode"));
-    exports.Set("view", Napi::Function::New(env, CreateView, "view"));
+    exports.Set("as", Napi::Function::New(env, CastValue, "as", instance));
+    exports.Set("address", Napi::Function::New(env, GetPointerAddress, "address", instance));
+    exports.Set("call", Napi::Function::New(env, CallPointerSync, "call", instance));
+    exports.Set("encode", Napi::Function::New(env, EncodeValue, "encode", instance));
+    exports.Set("view", Napi::Function::New(env, CreateView, "view", instance));
 
     {
-        Napi::Function decode = Napi::Function::New(env, DecodeValue, "decode");
-
-        decode.Set("char", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<char>(env, info); }, "char"));
-        decode.Set("uchar", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<unsigned char>(env, info); }, "uchar"));
-        decode.Set("short", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<short>(env, info); }, "short"));
-        decode.Set("ushort", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<unsigned short>(env, info); }, "ushort"));
-        decode.Set("int", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<int>(env, info); }, "int"));
-        decode.Set("uint", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<unsigned int>(env, info); }, "uint"));
-        decode.Set("long", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<long>(env, info); }, "long"));
-        decode.Set("ulong", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<unsigned long>(env, info); }, "ulong"));
-        decode.Set("longlong", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<long long>(env, info); }, "longlong"));
-        decode.Set("ulonglong", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<unsigned long long>(env, info); }, "ulonglong"));
-        decode.Set("int8", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<int8_t>(env, info); }, "int8"));
-        decode.Set("uint8", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<uint8_t>(env, info); }, "uint8"));
-        decode.Set("int16", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<int16_t>(env, info); }, "int16"));
-        decode.Set("uint16", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<uint16_t>(env, info); }, "uint16"));
-        decode.Set("int32", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<int32_t>(env, info); }, "int32"));
-        decode.Set("uint32", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<uint32_t>(env, info); }, "uint32"));
-        decode.Set("int64", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<int64_t>(env, info); }, "int64"));
-        decode.Set("uint64", CreateFunction(env, [](napi_env env, napi_callback_info info) { return DecodeInteger<uint64_t>(env, info); }, "uint64"));
-        decode.Set("float", CreateFunction(env, DecodeFloat, "float"));
-        decode.Set("double", CreateFunction(env, DecodeDouble, "double"));
-        decode.Set("string", CreateFunction(env, DecodeString, "string"));
-        decode.Set("string16", CreateFunction(env, DecodeString16, "string16"));
-        decode.Set("string32", CreateFunction(env, DecodeString32, "string32"));
+        Napi::Function decode = Napi::Function::New(env, DecodeValue, "decode", instance);
+
+        decode.Set("char", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<char>(env, info); }, "char"));
+        decode.Set("uchar", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<unsigned char>(env, info); }, "uchar"));
+        decode.Set("short", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<short>(env, info); }, "short"));
+        decode.Set("ushort", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<unsigned short>(env, info); }, "ushort"));
+        decode.Set("int", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<int>(env, info); }, "int"));
+        decode.Set("uint", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<unsigned int>(env, info); }, "uint"));
+        decode.Set("long", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<long>(env, info); }, "long"));
+        decode.Set("ulong", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<unsigned long>(env, info); }, "ulong"));
+        decode.Set("longlong", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<long long>(env, info); }, "longlong"));
+        decode.Set("ulonglong", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<unsigned long long>(env, info); }, "ulonglong"));
+        decode.Set("int8", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<int8_t>(env, info); }, "int8"));
+        decode.Set("uint8", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<uint8_t>(env, info); }, "uint8"));
+        decode.Set("int16", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<int16_t>(env, info); }, "int16"));
+        decode.Set("int16le", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeIntegerLE<int16_t>(env, info); }, "int16le"));
+        decode.Set("int16be", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeIntegerBE<int16_t>(env, info); }, "int16be"));
+        decode.Set("uint16", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<uint16_t>(env, info); }, "uint16"));
+        decode.Set("uint16le", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeIntegerLE<uint16_t>(env, info); }, "uint16le"));
+        decode.Set("uint16be", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeIntegerBE<uint16_t>(env, info); }, "uint16be"));
+        decode.Set("int32", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<int32_t>(env, info); }, "int32"));
+        decode.Set("int32le", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeIntegerLE<int32_t>(env, info); }, "int32le"));
+        decode.Set("int32be", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeIntegerBE<int32_t>(env, info); }, "int32be"));
+        decode.Set("uint32", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<uint32_t>(env, info); }, "uint32"));
+        decode.Set("uint32le", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeIntegerLE<uint32_t>(env, info); }, "uint32le"));
+        decode.Set("uint32be", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeIntegerBE<uint32_t>(env, info); }, "uint32be"));
+        decode.Set("int64", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<int64_t>(env, info); }, "int64"));
+        decode.Set("int64le", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeIntegerLE<int64_t>(env, info); }, "int64le"));
+        decode.Set("int64be", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeIntegerBE<int64_t>(env, info); }, "int64be"));
+        decode.Set("uint64", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<uint64_t>(env, info); }, "uint64"));
+        decode.Set("uint64le", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeIntegerLE<uint64_t>(env, info); }, "uint64le"));
+        decode.Set("uint64be", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeIntegerBE<uint64_t>(env, info); }, "uint64be"));
+        decode.Set("float", CreateFunction(instance, DecodeFloat, "float"));
+        decode.Set("double", CreateFunction(instance, DecodeDouble, "double"));
+        decode.Set("string", CreateFunction(instance, DecodeString, "string"));
+        decode.Set("string16", CreateFunction(instance, DecodeString16, "string16"));
+        decode.Set("string32", CreateFunction(instance, DecodeString32, "string32"));
+        if constexpr (K_SIZE(wchar_t) == 2) {
+            decode.Set("wstring", CreateFunction(instance, DecodeString16, "wstring"));
+        } else if constexpr (K_SIZE(wchar_t) == 4) {
+            decode.Set("wstring", CreateFunction(instance, DecodeString32, "wstring"));
+        }
+        static_assert(K_SIZE(wchar_t) == 2 || K_SIZE(wchar_t) == 4);
 
         exports.Set("decode", decode);
     }
 
-    exports.Set("reset", Napi::Function::New(env, ResetKoffi, "reset"));
+    exports.Set("reset", Napi::Function::New(env, ResetKoffi, "reset", instance));
 
-    exports.Set("errno", Napi::Function::New(env, GetOrSetErrNo, "errno"));
+    exports.Set("errno", Napi::Function::New(env, GetOrSetErrNo, "errno", instance));
 
     // Export useful OS info
     {
@@ -2615,21 +2846,21 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     }
 
 #if defined(_WIN32)
-    exports.Set("extension", Napi::String::New(env, ".dll"));
+    exports.Set("extension", NewString(env, ".dll"));
 #elif defined(__APPLE__)
-    exports.Set("extension", Napi::String::New(env, ".dylib"));
+    exports.Set("extension", NewString(env, ".dylib"));
 #else
-    exports.Set("extension", Napi::String::New(env, ".so"));
+    exports.Set("extension", NewString(env, ".so"));
 #endif
 
     // Init object classes and symbols
     {
         instance->object_constructor = Napi::Persistent(env.RunScript("Object.prototype").As<Napi::Object>());
-        instance->construct_lib = Napi::Persistent(LibraryHandle::InitClass(env));
+        instance->construct_lib = Napi::Persistent(LibraryHandle::InitClass(instance));
 #if !defined(EXTERNAL_TYPES)
-        instance->construct_type = Napi::Persistent(TypeObject::InitClass(env));
+        instance->construct_type = Napi::Persistent(TypeObject::InitClass(instance));
 #endif
-        instance->construct_poll = Napi::Persistent(PollHandle::InitClass(env));
+        instance->construct_poll = Napi::Persistent(PollHandle::InitClass(instance));
         instance->active_symbol = Napi::Persistent(Napi::Symbol::New(env, "active"));
 
         exports.Set("LibraryHandle", instance->construct_lib.Value());
@@ -2643,58 +2874,59 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
         Napi::Object types = Napi::Object::New(env);
         exports.Set("types", types);
 
-        RegisterPrimitiveType(env, types, {"void"}, PrimitiveKind::Void, 0, 0);
-        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 (K_SIZE(wchar_t) == 2) {
-            RegisterPrimitiveType(env, types, {"wchar_t", "wchar"}, PrimitiveKind::Int16, 2, 2);
-        } 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);
-        RegisterPrimitiveType(env, types, {"int16_le_t", "int16_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int16), 2, 2);
-        RegisterPrimitiveType(env, types, {"int16_be_t", "int16_be"}, GetBigEndianPrimitive(PrimitiveKind::Int16), 2, 2);
-        RegisterPrimitiveType(env, types, {"uint16_t", "uint16"}, PrimitiveKind::UInt16, 2, 2);
-        RegisterPrimitiveType(env, types, {"uint16_le_t", "uint16_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt16), 2, 2);
-        RegisterPrimitiveType(env, types, {"uint16_be_t", "uint16_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt16), 2, 2);
-        RegisterPrimitiveType(env, types, {"short"}, PrimitiveKind::Int16, 2, 2);
-        RegisterPrimitiveType(env, types, {"unsigned short", "ushort"}, PrimitiveKind::UInt16, 2, 2);
-        RegisterPrimitiveType(env, types, {"int32_t", "int32"}, PrimitiveKind::Int32, 4, 4);
-        RegisterPrimitiveType(env, types, {"int32_le_t", "int32_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int32), 4, 4);
-        RegisterPrimitiveType(env, types, {"int32_be_t", "int32_be"}, GetBigEndianPrimitive(PrimitiveKind::Int32), 4, 4);
-        RegisterPrimitiveType(env, types, {"uint32_t", "uint32"}, PrimitiveKind::UInt32, 4, 4);
-        RegisterPrimitiveType(env, types, {"uint32_le_t", "uint32_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt32), 4, 4);
-        RegisterPrimitiveType(env, types, {"uint32_be_t", "uint32_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt32), 4, 4);
-        RegisterPrimitiveType(env, types, {"int"}, PrimitiveKind::Int32, 4, 4);
-        RegisterPrimitiveType(env, types, {"unsigned int", "uint"}, PrimitiveKind::UInt32, 4, 4);
-        RegisterPrimitiveType(env, types, {"int64_t", "int64"}, PrimitiveKind::Int64, 8, alignof(int64_t));
-        RegisterPrimitiveType(env, types, {"int64_le_t", "int64_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int64), 8, alignof(int64_t));
-        RegisterPrimitiveType(env, types, {"int64_be_t", "int64_be"}, GetBigEndianPrimitive(PrimitiveKind::Int64), 8, alignof(int64_t));
-        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(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, 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");
+        RegisterPrimitiveType(instance, types, {"void"}, PrimitiveKind::Void, 0, 0);
+        RegisterPrimitiveType(instance, types, {"bool"}, PrimitiveKind::Bool, K_SIZE(bool), alignof(bool));
+        RegisterPrimitiveType(instance, types, {"int8_t", "int8"}, PrimitiveKind::Int8, 1, 1);
+        RegisterPrimitiveType(instance, types, {"uint8_t", "uint8"}, PrimitiveKind::UInt8, 1, 1);
+        RegisterPrimitiveType(instance, types, {"char"}, PrimitiveKind::Int8, 1, 1);
+        RegisterPrimitiveType(instance, types, {"unsigned char", "uchar"}, PrimitiveKind::UInt8, 1, 1);
+        RegisterPrimitiveType(instance, types, {"char16_t", "char16"}, PrimitiveKind::Int16, 2, 2);
+        RegisterPrimitiveType(instance, types, {"char32_t", "char32"}, PrimitiveKind::Int32, 4, 4);
+        if constexpr (K_SIZE(wchar_t) == 2) {
+            RegisterPrimitiveType(instance, types, {"wchar_t", "wchar"}, PrimitiveKind::Int16, 2, 2);
+        } else if constexpr (K_SIZE(wchar_t) == 4) {
+            RegisterPrimitiveType(instance, types, {"wchar_t", "wchar"}, PrimitiveKind::Int32, 4, 4);
+        }
+        RegisterPrimitiveType(instance, types, {"int16_t", "int16"}, PrimitiveKind::Int16, 2, 2);
+        RegisterPrimitiveType(instance, types, {"int16_le_t", "int16_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int16), 2, 2);
+        RegisterPrimitiveType(instance, types, {"int16_be_t", "int16_be"}, GetBigEndianPrimitive(PrimitiveKind::Int16), 2, 2);
+        RegisterPrimitiveType(instance, types, {"uint16_t", "uint16"}, PrimitiveKind::UInt16, 2, 2);
+        RegisterPrimitiveType(instance, types, {"uint16_le_t", "uint16_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt16), 2, 2);
+        RegisterPrimitiveType(instance, types, {"uint16_be_t", "uint16_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt16), 2, 2);
+        RegisterPrimitiveType(instance, types, {"short"}, PrimitiveKind::Int16, 2, 2);
+        RegisterPrimitiveType(instance, types, {"unsigned short", "ushort"}, PrimitiveKind::UInt16, 2, 2);
+        RegisterPrimitiveType(instance, types, {"int32_t", "int32"}, PrimitiveKind::Int32, 4, 4);
+        RegisterPrimitiveType(instance, types, {"int32_le_t", "int32_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int32), 4, 4);
+        RegisterPrimitiveType(instance, types, {"int32_be_t", "int32_be"}, GetBigEndianPrimitive(PrimitiveKind::Int32), 4, 4);
+        RegisterPrimitiveType(instance, types, {"uint32_t", "uint32"}, PrimitiveKind::UInt32, 4, 4);
+        RegisterPrimitiveType(instance, types, {"uint32_le_t", "uint32_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt32), 4, 4);
+        RegisterPrimitiveType(instance, types, {"uint32_be_t", "uint32_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt32), 4, 4);
+        RegisterPrimitiveType(instance, types, {"int"}, PrimitiveKind::Int32, 4, 4);
+        RegisterPrimitiveType(instance, types, {"unsigned int", "uint"}, PrimitiveKind::UInt32, 4, 4);
+        RegisterPrimitiveType(instance, types, {"int64_t", "int64"}, PrimitiveKind::Int64, 8, alignof(int64_t));
+        RegisterPrimitiveType(instance, types, {"int64_le_t", "int64_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int64), 8, alignof(int64_t));
+        RegisterPrimitiveType(instance, types, {"int64_be_t", "int64_be"}, GetBigEndianPrimitive(PrimitiveKind::Int64), 8, alignof(int64_t));
+        RegisterPrimitiveType(instance, types, {"uint64_t", "uint64"}, PrimitiveKind::UInt64, 8, alignof(int64_t));
+        RegisterPrimitiveType(instance, types, {"uint64_le_t", "uint64_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt64), 8, alignof(int64_t));
+        RegisterPrimitiveType(instance, types, {"uint64_be_t", "uint64_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt64), 8, alignof(int64_t));
+        RegisterPrimitiveType(instance, types, {"intptr_t", "intptr"}, GetSignPrimitive(K_SIZE(intptr_t), true), K_SIZE(intptr_t), alignof(intptr_t));
+        RegisterPrimitiveType(instance, types, {"uintptr_t", "uintptr"}, GetSignPrimitive(K_SIZE(intptr_t), false), K_SIZE(intptr_t), alignof(intptr_t));
+        RegisterPrimitiveType(instance, types, {"size_t"}, GetSignPrimitive(K_SIZE(size_t), false), K_SIZE(size_t), alignof(size_t));
+        RegisterPrimitiveType(instance, types, {"long"}, GetSignPrimitive(K_SIZE(long), true), K_SIZE(long), alignof(long));
+        RegisterPrimitiveType(instance, types, {"unsigned long", "ulong"}, GetSignPrimitive(K_SIZE(long), false), K_SIZE(long), alignof(long));
+        RegisterPrimitiveType(instance, types, {"long long", "longlong"}, PrimitiveKind::Int64, K_SIZE(int64_t), alignof(int64_t));
+        RegisterPrimitiveType(instance, types, {"unsigned long long", "ulonglong"}, PrimitiveKind::UInt64, K_SIZE(uint64_t), alignof(uint64_t));
+        RegisterPrimitiveType(instance, types, {"float", "float32"}, PrimitiveKind::Float32, 4, alignof(float));
+        RegisterPrimitiveType(instance, types, {"double", "float64"}, PrimitiveKind::Float64, 8, alignof(double));
+        RegisterPrimitiveType(instance, types, {"char *", "str", "string"}, PrimitiveKind::String, K_SIZE(void *), alignof(void *), "char");
+        RegisterPrimitiveType(instance, types, {"char16_t *", "char16 *", "str16", "string16"}, PrimitiveKind::String16, K_SIZE(void *), alignof(void *), "char16_t");
+        RegisterPrimitiveType(instance, types, {"char32_t *", "char32 *", "str32", "string32"}, PrimitiveKind::String32, K_SIZE(void *), alignof(void *), "char32_t");
+        if constexpr (K_SIZE(wchar_t) == 2) {
+            RegisterPrimitiveType(instance, types, {"wchar_t *", "wchar *", "wstring"}, PrimitiveKind::String16, K_SIZE(void *), alignof(void *), "wchar_t");
+        } else if constexpr (K_SIZE(wchar_t) == 4) {
+            RegisterPrimitiveType(instance, types, {"wchar_t *", "wchar *", "wstring"}, PrimitiveKind::String32, K_SIZE(void *), alignof(void *), "wchar_t");
         }
+        static_assert(K_SIZE(wchar_t) == 2 || K_SIZE(wchar_t) == 4);
 
         instance->void_type = instance->types_map.FindValue("void", nullptr);
         instance->char_type = instance->types_map.FindValue("char", nullptr);
@@ -2714,11 +2946,11 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
 
         node.Set("env", WrapPointer(env, instance->void_type, (napi_env)env));
 
-        node.Set("poll", Napi::Function::New(env, &Poll, "poll"));
+        node.Set("poll", Napi::Function::New(env, &Poll, "poll", instance));
         node.Set("PollHandle", instance->construct_poll.Value());
     }
 
-    exports.Set("version", Napi::String::New(env, K_STRINGIFY(VERSION)));
+    exports.Set("version", NewString(env, K_STRINGIFY(VERSION)));
 
 #if defined(_WIN32)
     {
@@ -2729,7 +2961,6 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     }
 #endif
 
-    instance->translate_zero_call = translate_zero_call;
     instance->main_thread_id = std::this_thread::get_id();
 
     napi_add_env_cleanup_hook(env, [](void *udata) {
@@ -2764,7 +2995,7 @@ InstanceData::~InstanceData()
             if (trampoline->instance == this) {
                 trampoline->instance = nullptr;
                 if (trampoline->func) {
-                    napi_delete_reference(env, trampoline->func);
+                    node_api_delete_reference(env, trampoline->func);
                     trampoline->func = nullptr;
                 }
                 trampoline->state = 0;