koffi 3.0.2 → 3.1.1

package/src/koffi/src/ffi.cc

@@ -46,12 +46,12 @@ 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(InstanceData *instance, const char *name, Napi::Value value, Size min_size, Size max_size, Size *out_size)
 {
@@ -308,6 +308,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         replace = (TypeInfo *)defn->GetType();
 #endif
 
+        type->instance = instance;
         type->name = replace->name;
 
         if (replace->primitive != PrimitiveKind::Void || replace == instance->void_type) {
@@ -315,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;
     }
 
@@ -429,11 +432,11 @@ 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;
     }
 
-    napi_value wrapper = WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
     return Napi::Value(env, wrapper);
 }
 
@@ -507,6 +510,7 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
         replace = (TypeInfo *)defn->GetType();
 #endif
 
+        type->instance = instance;
         type->name = replace->name;
 
         if (replace->primitive != PrimitiveKind::Void || replace == instance->void_type) {
@@ -514,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;
     }
 
@@ -597,14 +603,15 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
         return env.Null();
     err_guard.Disable();
 
-    type->construct = Napi::Persistent(UnionValue::InitClass(instance, 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;
     }
 
-    napi_value wrapper = WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
     return Napi::Value(env, wrapper);
 }
 
@@ -630,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;
@@ -653,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;
 
@@ -665,7 +681,7 @@ static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
         return env.Null();
     err_guard.Disable();
 
-    napi_value wrapper = WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
     return Napi::Value(env, wrapper);
 }
 
@@ -721,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>);
 
@@ -738,7 +754,7 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
         type = copy;
     }
 
-    napi_value wrapper = WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
     return Napi::Value(env, wrapper);
 }
 
@@ -835,21 +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 func;
+            NAPI_OK(napi_get_reference_value(env, type->dispose_ref, &func));
 
             napi_value self = env.Null();
             napi_value wrapper = WrapPointer(env, type->ref.type, (void *)ptr);
 
-            ref.Call(self, 1, &wrapper);
+            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++;
         };
@@ -859,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>);
 
@@ -869,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) {
@@ -883,7 +898,7 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     }
     err_guard.Disable();
 
-    napi_value wrapper = WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
     return Napi::Value(env, wrapper);
 }
 
@@ -1066,7 +1081,7 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
         type->countedby = DuplicateString(str.Utf8Value().c_str(), &instance->str_alloc).ptr;
     }
 
-    napi_value wrapper = WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
     return Napi::Value(env, wrapper);
 }
 
@@ -1189,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());
@@ -1214,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;
@@ -1223,7 +1239,7 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
 
     instance->types_map.Set(type->name, type);
 
-    napi_value wrapper = WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
     return Napi::Value(env, wrapper);
 }
 
@@ -1256,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;
 
@@ -1380,8 +1397,19 @@ 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();
@@ -1414,7 +1442,7 @@ static Napi::Value CreateTypeAlias(const Napi::CallbackInfo &info)
     if (!MapType(env, instance, type, alias))
         return env.Null();
 
-    napi_value wrapper = WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
     return Napi::Value(env, wrapper);
 }
 
@@ -1432,7 +1460,7 @@ static Napi::Value GetResolvedType(const Napi::CallbackInfo &info)
     if (!type)
         return env.Null();
 
-    napi_value wrapper = WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
     return Napi::Value(env, wrapper);
 }
 
@@ -1441,6 +1469,7 @@ 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());
@@ -1452,9 +1481,12 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
         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
@@ -1553,6 +1585,23 @@ void ReleaseMemory(InstanceData *instance, InstanceMemory *mem)
     }
 }
 
+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;
@@ -1589,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();
@@ -1617,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());
@@ -1660,7 +1709,7 @@ Napi::Value LibraryHandle::Func(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    napi_value wrapper = WrapFunction(env, func);
+    napi_value wrapper = WrapFunction(instance, func);
     return Napi::Value(env, wrapper);
 }
 
@@ -1669,20 +1718,31 @@ Napi::Value LibraryHandle::Symbol(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     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>();
 
+#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());
@@ -1886,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);
@@ -1925,7 +1985,7 @@ static Napi::Value CastValue(const Napi::CallbackInfo &info)
     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;
@@ -2023,8 +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_OK(napi_get_cb_info(env, info, &count, &arg, nullptr, nullptr));
+    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);
@@ -2033,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();
     }
@@ -2045,12 +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_OK(napi_get_cb_info(env, info, &count, &arg, nullptr, nullptr));
+    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);
@@ -2059,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();
     }
@@ -2068,15 +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_OK(napi_get_cb_info(env, info, &count, &arg, nullptr, nullptr));
+    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);
@@ -2085,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();
     }
@@ -2094,15 +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_OK(napi_get_cb_info(env, info, &count, args, nullptr, nullptr));
+    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);
@@ -2111,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();
     }
@@ -2120,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);
     }
 }
 
@@ -2136,8 +2232,9 @@ static napi_value DecodeString16(napi_env env, napi_callback_info info)
 {
     napi_value args[2];
     size_t count = 2;
+    InstanceData *instance;
 
-    NAPI_OK(napi_get_cb_info(env, info, &count, args, nullptr, nullptr));
+    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);
@@ -2146,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();
     }
@@ -2155,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);
     }
 }
 
@@ -2171,8 +2264,9 @@ static napi_value DecodeString32(napi_env env, napi_callback_info info)
 {
     napi_value args[2];
     size_t count = 2;
+    InstanceData *instance;
 
-    NAPI_OK(napi_get_cb_info(env, info, &count, args, nullptr, nullptr));
+    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);
@@ -2181,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();
     }
@@ -2190,15 +2282,13 @@ 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);
     }
 }
 
@@ -2419,7 +2509,7 @@ void LibraryHolder::Unload()
 
 ValueCast::~ValueCast()
 {
-    DeleteReferenceSafe(env, ref);
+    node_api_delete_reference(env, ref);
 }
 
 FunctionInfo::~FunctionInfo()
@@ -2454,10 +2544,9 @@ static void RegisterPrimitiveType(InstanceData *instance, Napi::Object map, std:
     K_ASSERT(names.size() > 0);
     K_ASSERT(align <= size);
 
-    Napi::Env env = instance->env;
-
     TypeInfo *type = instance->types.AppendDefault();
 
+    type->instance = instance;
     type->name = *names.begin();
 
     type->primitive = primitive;
@@ -2479,7 +2568,7 @@ static void RegisterPrimitiveType(InstanceData *instance, Napi::Object map, std:
         K_ASSERT(type->ref.type);
     }
 
-    napi_value wrapper = WrapType(env, type);
+    napi_value wrapper = WrapType(instance, type);
 
     for (const char *name: names) {
         bool inserted;
@@ -2538,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;
@@ -2618,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);
@@ -2630,12 +2734,11 @@ 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", instance));
@@ -2692,16 +2795,34 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
         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);
     }
@@ -2725,11 +2846,11 @@ 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
@@ -2761,9 +2882,9 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
         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) {
+        if constexpr (K_SIZE(wchar_t) == 2) {
             RegisterPrimitiveType(instance, types, {"wchar_t", "wchar"}, PrimitiveKind::Int16, 2, 2);
-        } else if (K_SIZE(wchar_t) == 4) {
+        } 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);
@@ -2800,11 +2921,12 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
         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(instance, types, {"wchar_t *", "wchar *"}, PrimitiveKind::String16, K_SIZE(void *), alignof(void *), "wchar_t");
-        } else if (K_SIZE(wchar_t) == 4) {
-            RegisterPrimitiveType(instance, types, {"wchar_t *", "wchar *"}, PrimitiveKind::String32, K_SIZE(void *), alignof(void *), "wchar_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);
@@ -2828,7 +2950,7 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
         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)
     {
@@ -2839,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) {
@@ -2874,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;