koffi 3.0.1 → 3.0.2

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,6 +36,13 @@
 
 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
@@ -45,13 +53,11 @@ napi_status (NAPI_CDECL *node_api_create_object_with_properties)(napi_env env, n
                                                                  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,7 +303,7 @@ 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
@@ -353,7 +357,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)) {
@@ -429,7 +433,8 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         type = replace;
     }
 
-    return WrapType(env, type);
+    napi_value wrapper = WrapType(env, type);
+    return Napi::Value(env, wrapper);
 }
 
 static Napi::Value CreatePaddedStructType(const Napi::CallbackInfo &info)
@@ -445,7 +450,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,7 +502,7 @@ 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
@@ -551,7 +556,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 +597,21 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
         return env.Null();
     err_guard.Disable();
 
-    type->construct = Napi::Persistent(UnionValue::InitClass(env, type));
+    type->construct = Napi::Persistent(UnionValue::InitClass(instance, type));
 
     if (replace) {
         std::swap(*type, *replace);
         type = replace;
     }
 
-    return WrapType(env, type);
+    napi_value wrapper = WrapType(env, 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 +622,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) {
@@ -632,7 +639,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]);
 
@@ -658,13 +665,14 @@ static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
         return env.Null();
     err_guard.Disable();
 
-    return WrapType(env, type);
+    napi_value wrapper = WrapType(env, 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 +689,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();
 
@@ -730,7 +738,8 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
         type = copy;
     }
 
-    return WrapType(env, type);
+    napi_value wrapper = WrapType(env, type);
+    return Napi::Value(env, wrapper);
 }
 
 static Napi::Value EncodePointerDirection(const Napi::CallbackInfo &info, int directions)
@@ -738,13 +747,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 +793,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 +810,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 &&
@@ -829,12 +839,10 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
             InstanceData *instance = env.GetInstanceData<InstanceData>();
             const Napi::FunctionReference &ref = type->dispose_ref;
 
-            Napi::Value p = WrapPointer(env, type->ref.type, (void *)ptr);
-
             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);
+            ref.Call(self, 1, &wrapper);
             instance->stats.disposed++;
         };
         dispose_func = func;
@@ -875,13 +883,14 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     }
     err_guard.Disable();
 
-    return WrapType(env, type);
+    napi_value wrapper = WrapType(env, 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 +901,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 +930,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 +946,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 +958,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 +978,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 +1033,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 +1066,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(env, type);
+    return Napi::Value(env, wrapper);
 }
 
 static bool ParseClassicFunction(const Napi::CallbackInfo &info, bool concrete, FunctionInfo *out_func)
@@ -1056,7 +1075,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 +1118,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 +1145,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 +1171,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); };
@@ -1204,13 +1223,14 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
 
     instance->types_map.Set(type->name, type);
 
-    return WrapType(env, type);
+    napi_value wrapper = WrapType(env, 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());
@@ -1243,7 +1263,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 +1380,19 @@ static Napi::Value CreateEnumType(const Napi::CallbackInfo &info)
         return env.Null();
     err_guard.Disable();
 
-    Napi::Value wrapper = WrapType(env, type, false);
+    napi_value wrapper = WrapType(env, type, false);
     Napi::Object defn = type->defn.Value();
 
     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 +1406,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 +1414,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(env, 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(env, type);
+    return Napi::Value(env, wrapper);
 }
 
 #if defined(EXTERNAL_TYPES)
@@ -1424,7 +1447,7 @@ static Napi::Value GetTypeDefinition(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();
 
@@ -1530,13 +1553,15 @@ void ReleaseMemory(InstanceData *instance, InstanceMemory *mem)
     }
 }
 
-Napi::Function LibraryHandle::InitClass(Napi::Env env)
+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)) {
@@ -1573,7 +1598,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(); };
@@ -1635,13 +1660,14 @@ Napi::Value LibraryHandle::Func(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    return WrapFunction(env, func);
+    napi_value wrapper = WrapFunction(env, 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 (info.Length() < 2) {
         ThrowError<Napi::TypeError>(env, "Expected 2, got %1", info.Length());
@@ -1654,7 +1680,7 @@ Napi::Value LibraryHandle::Symbol(const Napi::CallbackInfo &info)
 
     std::string name = info[0].As<Napi::String>();
 
-    const TypeInfo *type = ResolveType(info[1]);
+    const TypeInfo *type = ResolveType(instance, info[1]);
     if (!type)
         return env.Null();
 
@@ -1668,7 +1694,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 +1710,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 +1795,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 +1811,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 +1838,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());
@@ -1870,6 +1898,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 +1907,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,7 +1922,7 @@ 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; });
@@ -1905,6 +1934,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 +1944,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>
@@ -1938,8 +2024,7 @@ static FORCE_INLINE napi_value DecodeInteger(napi_env env, napi_callback_info in
     napi_value arg;
     size_t count = 1;
 
-    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, nullptr));
 
     if (count < 1) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", count);
@@ -1965,8 +2050,7 @@ static napi_value DecodeFloat(napi_env env, napi_callback_info info)
     napi_value arg;
     size_t count = 1;
 
-    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, nullptr));
 
     if (count < 1) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", count);
@@ -1992,8 +2076,7 @@ static napi_value DecodeDouble(napi_env env, napi_callback_info info)
     napi_value arg;
     size_t count = 1;
 
-    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, nullptr));
 
     if (count < 1) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", count);
@@ -2019,8 +2102,7 @@ static napi_value DecodeString(napi_env env, napi_callback_info info)
     napi_value args[2];
     size_t count = 2;
 
-    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, nullptr));
 
     if (count < 1) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 1 to 2 arguments, got %1", count);
@@ -2055,8 +2137,7 @@ static napi_value DecodeString16(napi_env env, napi_callback_info info)
     napi_value args[2];
     size_t count = 2;
 
-    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, nullptr));
 
     if (count < 1) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 1 to 2 arguments, got %1", count);
@@ -2091,8 +2172,7 @@ static napi_value DecodeString32(napi_env env, napi_callback_info info)
     napi_value args[2];
     size_t count = 2;
 
-    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, nullptr));
 
     if (count < 1) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected 1 to 2 arguments, got %1", count);
@@ -2125,6 +2205,7 @@ static napi_value DecodeString32(napi_env env, napi_callback_info info)
 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 +2214,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 +2227,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 +2236,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 +2255,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 +2265,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 +2273,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 +2366,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);
@@ -2338,13 +2448,13 @@ 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>();
+    Napi::Env env = instance->env;
 
     TypeInfo *type = instance->types.AppendDefault();
 
@@ -2369,7 +2479,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(env, type);
 
     for (const char *name: names) {
         bool inserted;
@@ -2451,12 +2561,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;
 }
@@ -2528,77 +2638,77 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     Napi::Number::New(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("uint16", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<uint16_t>(env, info); }, "uint16"));
+        decode.Set("int32", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<int32_t>(env, info); }, "int32"));
+        decode.Set("uint32", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<uint32_t>(env, info); }, "uint32"));
+        decode.Set("int64", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<int64_t>(env, info); }, "int64"));
+        decode.Set("uint64", CreateFunction(instance, [](napi_env env, napi_callback_info info) { return DecodeInteger<uint64_t>(env, info); }, "uint64"));
+        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"));
 
         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
     {
@@ -2625,11 +2735,11 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     // 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,57 +2753,57 @@ 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);
+        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 (K_SIZE(wchar_t) == 2) {
-            RegisterPrimitiveType(env, types, {"wchar_t", "wchar"}, PrimitiveKind::Int16, 2, 2);
+            RegisterPrimitiveType(instance, 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");
+            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 (K_SIZE(wchar_t) == 2) {
-            RegisterPrimitiveType(env, types, {"wchar_t *", "wchar *"}, PrimitiveKind::String16, K_SIZE(void *), alignof(void *), "wchar_t");
+            RegisterPrimitiveType(instance, 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, {"wchar_t *", "wchar *"}, PrimitiveKind::String32, K_SIZE(void *), alignof(void *), "wchar_t");
         }
 
         instance->void_type = instance->types_map.FindValue("void", nullptr);
@@ -2714,7 +2824,7 @@ 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());
     }