koffi 2.16.1 → 3.0.0-alpha.2

package/src/koffi/src/ffi.cc

@@ -32,14 +32,18 @@
 #include <wchar.h>
 
 #include <napi.h>
+#include <uv.h>
 
 namespace K {
 
-SharedData shared;
+extern "C" napi_value SwitchAndRelay(CallData *call, Size idx, uint8_t *sp, uint8_t *saved_sp, MemoryRange<uint8_t> *new_stack);
 
-static thread_local CallData *exec_call;
+SharedData shared;
 
-extern "C" napi_value SwitchAndRelay(CallData *call, Size idx, uint8_t *sp, uint8_t *saved_sp, Span<uint8_t> *new_stack);
+// Recent N-API functions are loaded dynamically
+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_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)
 {
@@ -104,7 +108,7 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
             return env.Null();
         }
 
-        if (!info[0].IsObject()) {
+        if (!IsObject(env, info[0])) {
             ThrowError<Napi::TypeError>(env, "Unexpected %1 value for config, expected object", GetValueType(instance, info[0]));
             return env.Null();
         }
@@ -113,7 +117,7 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
         int max_async_calls = new_config.resident_async_pools + new_config.max_temporaries;
 
         Napi::Object obj = info[0].As<Napi::Object>();
-        Napi::Array keys = GetOwnPropertyNames(obj);
+        Napi::Array keys = GetOwnPropertyNames(env, obj);
 
         for (uint32_t i = 0; i < keys.Length(); i++) {
             std::string key = keys.Get(i).As<Napi::String>();
@@ -140,6 +144,20 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
             } else if (key == "max_type_size") {
                 if (!ChangeSize(key.c_str(), value, 32, Mebibytes(512), &new_config.max_type_size))
                     return env.Null();
+            } else if (key == "fast_pointers") {
+                if (!value.IsBoolean()) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for '%2', expected boolean", GetValueType(instance, value), key.c_str());
+                    return env.Null();
+                }
+
+                new_config.fast_pointers = value.As<Napi::Boolean>();
+            } else if (key == "fast_callbacks") {
+                if (!value.IsBoolean()) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for '%2', expected boolean", GetValueType(instance, value), key.c_str());
+                    return env.Null();
+                }
+
+                new_config.fast_callbacks = value.As<Napi::Boolean>();
             } else {
                 ThrowError<Napi::Error>(env, "Unexpected config member '%1'", key.c_str());
                 return env.Null();
@@ -164,6 +182,8 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
     obj.Set("resident_async_pools", instance->config.resident_async_pools);
     obj.Set("max_async_calls", instance->config.resident_async_pools + instance->config.max_temporaries);
     obj.Set("max_type_size", instance->config.max_type_size);
+    obj.Set("fast_pointers", instance->config.fast_pointers);
+    obj.Set("fast_callbacks", instance->config.fast_callbacks);
 
     return obj;
 }
@@ -217,6 +237,29 @@ static bool MapType(Napi::Env env, InstanceData *instance, const TypeInfo *type,
     return true;
 }
 
+static bool FinalizeCompositeType(Napi::Env env, TypeInfo *type, Size size)
+{
+    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);
+        }
+    }
+
+    size = AlignLen(size, type->align);
+    if (!size) {
+        ThrowError<Napi::Error>(env, "Empty type '%1' is not allowed in C", type->name);
+        return false;
+    }
+    type->size = (int32_t)size;
+
+    type->flags &= ~(int)TypeFlag::IsIncomplete;
+
+    return true;
+}
+
 static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 {
     Napi::Env env = info.Env();
@@ -228,21 +271,21 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
     }
 
     bool skip = (info.Length() > 1);
-    bool named = skip && !IsNullOrUndefined(info[0]);
-    bool redefine = named && CheckValueTag(info[0], &TypeInfoMarker);
+    bool named = skip && !IsNullOrUndefined(env, info[0]);
+    bool redefine = named && info[0].IsExternal() && CheckValueTag(env, info[0], &TypeInfoMarker);
 
     if (named && !info[0].IsString() && !redefine) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
         return env.Null();
     }
-    if (!IsObject(info[skip])) {
+    if (!IsObject(env, info[skip])) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for members, expected object", GetValueType(instance, info[1]));
         return env.Null();
     }
 
     Napi::String name = info[0].As<Napi::String>();
     Napi::Object obj = info[skip].As<Napi::Object>();
-    Napi::Array keys = GetOwnPropertyNames(obj);
+    Napi::Array keys = GetOwnPropertyNames(env, obj);
 
     K_DEFER_NC(err_guard, count = instance->types.count) {
         Size start = count + !skip;
@@ -287,7 +330,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
     type->flags = (int)TypeFlag::IsIncomplete;
 
     HashSet<const char *> members;
-    int64_t size = 0;
+    Size size = 0;
 
     for (uint32_t i = 0; i < keys.Length(); i++) {
         RecordMember member = {};
@@ -384,14 +427,8 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         }
     }
 
-    size = (int32_t)AlignLen(size, type->align);
-    if (!size) {
-        ThrowError<Napi::Error>(env, "Empty struct '%1' is not allowed in C", type->name);
+    if (!FinalizeCompositeType(env, type, size))
         return env.Null();
-    }
-    type->size = (int32_t)size;
-
-    type->flags &= ~(int)TypeFlag::IsIncomplete;
     err_guard.Disable();
 
     if (replace) {
@@ -423,21 +460,21 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
     }
 
     bool skip = (info.Length() > 1);
-    bool named = skip && !IsNullOrUndefined(info[0]);
-    bool redefine = named && CheckValueTag(info[0], &TypeInfoMarker);
+    bool named = skip && !IsNullOrUndefined(env, info[0]);
+    bool redefine = named && info[0].IsExternal() && CheckValueTag(env, info[0], &TypeInfoMarker);
 
     if (named && !info[0].IsString() && !redefine) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
         return env.Null();
     }
-    if (!IsObject(info[skip])) {
+    if (!IsObject(env, info[skip])) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for members, expected object", GetValueType(instance, info[1]));
         return env.Null();
     }
 
     Napi::String name = info[0].As<Napi::String>();
     Napi::Object obj = info[skip].As<Napi::Object>();
-    Napi::Array keys = GetOwnPropertyNames(obj);
+    Napi::Array keys = GetOwnPropertyNames(env, obj);
 
     K_DEFER_NC(err_guard, count = instance->types.count) {
         Size start = count + !skip;
@@ -549,18 +586,12 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
         type->members.Append(member);
     }
 
-    size = (int32_t)AlignLen(size, type->align);
-    if (!size) {
-        ThrowError<Napi::Error>(env, "Empty union '%1' is not allowed in C", type->name);
+    if (!FinalizeCompositeType(env, type, size))
         return env.Null();
-    }
-    type->size = (int32_t)size;
-
-    type->flags &= ~(int)TypeFlag::IsIncomplete;
     err_guard.Disable();
 
     // Union constructor
-    Napi::Function constructor = MagicUnion::InitClass(env, type);
+    Napi::Function constructor = UnionClass::InitClass(env, type);
     type->construct.Reset(constructor, 1);
 
     if (replace) {
@@ -593,7 +624,7 @@ Napi::Value InstantiateUnion(const Napi::CallbackInfo &info)
     }
 
     Napi::Object wrapper = type->construct.New({}).As<Napi::Object>();
-    SetValueTag(wrapper, &MagicUnionMarker);
+    SetValueTag(env, wrapper, &UnionClassMarker);
 
     return wrapper;
 }
@@ -603,7 +634,7 @@ static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    bool named = (info.Length() >= 1) && !IsNullOrUndefined(info[0]);
+    bool named = (info.Length() >= 1) && !IsNullOrUndefined(env, info[0]);
 
     if (named && !info[0].IsString()) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
@@ -641,7 +672,7 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
     }
 
     bool skip = (info.Length() > 1) && !info[1].IsNumber();
-    bool named = skip && !IsNullOrUndefined(info[0]);
+    bool named = skip && !IsNullOrUndefined(env, info[0]);
 
     if (named && !info[0].IsString()) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
@@ -754,7 +785,7 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     }
 
     bool skip = (info.Length() > 1) && !info[1].IsFunction();
-    bool named = skip && !IsNullOrUndefined(info[0]);
+    bool named = skip && !IsNullOrUndefined(env, info[0]);
 
     if (named && !info[0].IsString()) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
@@ -780,7 +811,7 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
 
     DisposeFunc *dispose;
     Napi::Function dispose_func;
-    if (info.Length() >= 2u + skip && !IsNullOrUndefined(info[1 + skip])) {
+    if (info.Length() >= 2u + skip && !IsNullOrUndefined(env, info[1 + skip])) {
         Napi::Function func = info[1 + skip].As<Napi::Function>();
 
         if (!func.IsFunction()) {
@@ -792,13 +823,10 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
             InstanceData *instance = env.GetInstanceData<InstanceData>();
             const Napi::FunctionReference &ref = type->dispose_ref;
 
-            Napi::External<void> external = Napi::External<void>::New(env, (void *)ptr);
-            SetValueTag(external, type->ref.marker);
+            Napi::Value p = WrapPointer(env, type->ref.type, (void *)ptr);
 
-            Napi::Value self = env.Null();
-            napi_value args[] = {
-                external
-            };
+            napi_value self = env.Null();
+            napi_value args[] = { p };
 
             ref.Call(self, K_LEN(args), args);
             instance->stats.disposed++;
@@ -826,37 +854,30 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     type->dispose_ref = Napi::Persistent(dispose_func);
 
     // If the insert succeeds, we cannot fail anymore
-    if (named && !MapType(env, instance, type, type->name))
-        return env.Null();
+    if (named) {
+        bool inserted;
+        instance->types_map.InsertOrGet(type->name, type, &inserted);
+
+        if (!inserted) {
+            ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
+            return env.Null();
+        }
+    }
     err_guard.Disable();
 
     return WrapType(env, type);
 }
 
-static inline bool GetExternalPointer(Napi::Env env, Napi::Value value, void **out_ptr)
+static inline bool GetExternalPointer(napi_env env, napi_value value, void **out_ptr)
 {
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
-    if (IsNullOrUndefined(value)) {
-        *out_ptr = 0;
-        return true;
-    } else if (IsRawBuffer(value)) {
-        Span<uint8_t> buffer = GetRawBuffer(value);
+    if (!TryPointer(env, value, out_ptr)) {
+        InstanceData *instance = Napi::Env(env).GetInstanceData<InstanceData>();
 
-        *out_ptr = buffer.ptr;
-        return true;
-    } else if (value.IsExternal() && !CheckValueTag(value, &TypeInfoMarker) &&
-                                     !CheckValueTag(value, &CastMarker) &&
-                                     !CheckValueTag(value, &MagicUnionMarker)) {
-        Napi::External<void> external = value.As<Napi::External<void>>();
-        void *ptr = external.Data();
-
-        *out_ptr = ptr;
-        return true;
-    } else {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected external pointer", GetValueType(instance, value));
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected pointer", GetValueType(instance, value));
         return false;
     }
+
+    return true;
 }
 
 static Napi::Value CallAlloc(const Napi::CallbackInfo &info)
@@ -902,10 +923,7 @@ static Napi::Value CallAlloc(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    Napi::External<void> external = Napi::External<void>::New(env, ptr);
-    SetValueTag(external, type);
-
-    return external;
+    return WrapPointer(env, type, ptr);
 }
 
 static Napi::Value CallFree(const Napi::CallbackInfo &info)
@@ -942,8 +960,7 @@ static Napi::Value GetOrSetErrNo(const Napi::CallbackInfo &info)
         errno = value;
     }
 
-    Napi::Number ret = Napi::Number::New(env, errno);
-    return ret;
+    return NewInt(env, (int32_t)errno);
 }
 
 static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
@@ -988,7 +1005,7 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
 
     TypeInfo *type = nullptr;
 
-    if (info.Length() >= 3u + dynamic && !IsNullOrUndefined(info[2 + dynamic])) {
+    if (info.Length() >= 3u + dynamic && !IsNullOrUndefined(env, info[2 + dynamic])) {
         if (!info[2 + dynamic].IsString()) {
             ThrowError<Napi::TypeError>(env, "Unexpected %1 value for hint, expected string", GetValueType(instance, info[2]));
             return env.Null();
@@ -1008,7 +1025,7 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
             hint = ArrayHint::Array;
         } else if (str == "String" || str == "string") {
             if (ref->primitive != PrimitiveKind::Int8 && ref->primitive != PrimitiveKind::Int16) {
-                ThrowError<Napi::Error>(env, "Array hint 'String' can only be used with 8 and 16-bit signed integer types");
+                ThrowError<Napi::Error>(env, "Array hint 'String' can only be used with 8, 16 and 32-bit signed integer types");
                 return env.Null();
             }
 
@@ -1018,9 +1035,9 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
             return env.Null();
         }
 
-        type = MakeArrayType(instance, ref, len, hint);
+        type = MakeArrayType(instance, ref, (Size)len, hint);
     } else {
-        type = MakeArrayType(instance, ref, len);
+        type = MakeArrayType(instance, ref, (Size)len);
     }
 
     if (dynamic) {
@@ -1064,7 +1081,7 @@ static bool ParseClassicFunction(const Napi::CallbackInfo &info, bool concrete,
         }
 #endif
         if (!name.IsString()) {
-            if (!concrete && IsNullOrUndefined(name)) {
+            if (!concrete && IsNullOrUndefined(env, name)) {
                 named = false;
             } else {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string or integer", GetValueType(instance, name));
@@ -1118,10 +1135,6 @@ static bool ParseClassicFunction(const Napi::CallbackInfo &info, bool concrete,
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
             return false;
         }
-        if ((param.directions & 2) && ++out_func->out_parameters >= MaxParameters) {
-            ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 output parameters", MaxParameters);
-            return false;
-        }
 
         param.offset = (int8_t)j;
 
@@ -1139,12 +1152,10 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     FunctionInfo *func = instance->callbacks.AppendDefault();
-    TypeInfo *type = instance->types.AppendDefault();
+    K_DEFER_N(err_guard) { instance->callbacks.RemoveLast(1); };
 
-    K_DEFER_N(err_guard) {
-        instance->callbacks.RemoveLast(1);
-        instance->types.RemoveLast(1);
-    };
+    func->env = env;
+    func->instance = instance;
 
     if (info.Length() >= 2) {
         if (!ParseClassicFunction(info, false, func))
@@ -1172,11 +1183,14 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
     if (!AnalyseFunction(env, instance, func))
         return env.Null();
 
-    // Adjust parameter offsets for koffi.call()
-    for (ParameterInfo &param: func->parameters) {
-        param.offset += 2;
+    // We cannot fail after this check
+    if (named && instance->types_map.Find(func->name)) {
+        ThrowError<Napi::Error>(env, "Duplicate type name '%1'", func->name);
+        return env.Null();
     }
-    func->required_parameters += 2;
+    err_guard.Disable();
+
+    TypeInfo *type = instance->types.AppendDefault();
 
     type->name = func->name;
 
@@ -1185,10 +1199,7 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
     type->size = K_SIZE(void *);
     type->ref.proto = func;
 
-    // If the insert succeeds, we cannot fail anymore
-    if (named && !MapType(env, instance, type, type->name))
-        return env.Null();
-    err_guard.Disable();
+    instance->types_map.Set(type->name, type);
 
     return WrapType(env, type);
 }
@@ -1234,7 +1245,7 @@ static Napi::Value GetTypeSize(const Napi::CallbackInfo &info)
     if (!type)
         return env.Null();
 
-    return Napi::Number::New(env, type->size);
+    return NewInt(env, type->size);
 }
 
 static Napi::Value GetTypeAlign(const Napi::CallbackInfo &info)
@@ -1250,7 +1261,7 @@ static Napi::Value GetTypeAlign(const Napi::CallbackInfo &info)
     if (!type)
         return env.Null();
 
-    return Napi::Number::New(env, type->align);
+    return NewInt(env, type->align);
 }
 
 static Napi::Value GetMemberOffset(const Napi::CallbackInfo &info)
@@ -1284,7 +1295,7 @@ static Napi::Value GetMemberOffset(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    return Napi::Number::New(env, member->offset);
+    return NewInt(env, member->offset);
 }
 
 static Napi::Value GetResolvedType(const Napi::CallbackInfo &info)
@@ -1321,8 +1332,8 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
 
         defn.Set("name", Napi::String::New(env, type->name));
         defn.Set("primitive", PrimitiveKindNames[(int)type->primitive]);
-        defn.Set("size", Napi::Number::New(env, (double)type->size));
-        defn.Set("alignment", Napi::Number::New(env, (double)type->align));
+        defn.Set("size", NewInt(env, type->size));
+        defn.Set("alignment", NewInt(env, type->align));
         defn.Set("disposable", Napi::Boolean::New(env, !!type->dispose));
 
         switch (type->primitive) {
@@ -1352,7 +1363,7 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
 
             case PrimitiveKind::Array: {
                 uint32_t len = type->size / type->ref.type->size;
-                defn.Set("length", Napi::Number::New(env, (double)len));
+                defn.Set("length", NewInt(env, len));
                 defn.Set("hint", ArrayHintNames[(int)type->hint]);
             } [[fallthrough]];
             case PrimitiveKind::Pointer: {
@@ -1412,44 +1423,48 @@ InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, Size hea
 
 #if defined(_WIN32)
     // Allocate stack memory
-    mem->stack.len = stack_size;
-    mem->stack.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->stack.len, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+    mem->stack.ptr = (uint8_t *)VirtualAlloc(nullptr, stack_size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+    mem->stack.end = mem->stack.ptr + stack_size;
 
-    K_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
+    K_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", stack_size);
 #else
-    mem->stack.len = stack_size;
-    mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_STACK, -1, 0);
+    mem->stack.ptr = (uint8_t *)mmap(nullptr, stack_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_STACK, -1, 0);
+    mem->stack.end = mem->stack.ptr + stack_size;
 
-    K_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
+    K_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", stack_size);
 #endif
 
 #if defined(__OpenBSD__)
     // Make sure the SP points inside the MAP_STACK area, or (void) functions may crash on OpenBSD i386
-    mem->stack.len -= 16;
+    mem->stack.end -= 16;
 #endif
 
     // Keep real stack limits intact, in case we need them
     mem->stack0 = mem->stack;
 
 #if defined(_WIN32) && !defined(_WIN64)
-    mem->stack.len -= K_SIZE(SehFrame);
+    mem->stack.end -= K_SIZE(SehFrame);
 
     // Prepare at the top SEH frame record
     {
-        SehFrame *seh = (SehFrame *)mem->stack.end();
+        SehFrame *seh = (SehFrame *)mem->stack.end;
 
         seh->Next = (void *)-1;
         seh->Handler = (void *)SehHandler;
     }
 #endif
 
-    mem->heap.len = heap_size;
 #if defined(_WIN32)
-    mem->heap.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->heap.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+    mem->heap.ptr = (uint8_t *)VirtualAlloc(nullptr, heap_size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+    mem->heap.end = mem->heap.ptr + heap_size;
+
+    K_CRITICAL(mem->heap.ptr, "Failed to allocate %1 of memory", heap_size);
 #else
-    mem->heap.ptr = (uint8_t *)mmap(nullptr, mem->heap.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+    mem->heap.ptr = (uint8_t *)mmap(nullptr, heap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+    mem->heap.end = mem->heap.ptr + heap_size;
+
+    K_CRITICAL(mem->heap.ptr, "Failed to allocate %1 of memory", heap_size);
 #endif
-    K_CRITICAL(mem->heap.ptr, "Failed to allocate %1 of memory", mem->heap.len);
 
     if (temporary) {
         instance->temporaries++;
@@ -1467,13 +1482,6 @@ InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, Size hea
 
 void ReleaseMemory(InstanceData *instance, InstanceMemory *mem)
 {
-    if (--mem->depth)
-        return;
-
-    // The first InstanceMemory is used for sync calls, no need to manage the async stuff
-    if (mem == instance->memories[0])
-        return;
-
     std::lock_guard<std::mutex> lock(instance->mem_mutex);
 
     if (mem->temporary) {
@@ -1484,164 +1492,282 @@ void ReleaseMemory(InstanceData *instance, InstanceMemory *mem)
     }
 }
 
-static Napi::Value TranslateNormalCall(const FunctionInfo *func, void *native,
-                                       const Napi::CallbackInfo &info)
+static napi_value TranslateZeroCallNode(napi_env env, napi_callback_info info)
 {
-    Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    struct CallbackBundle {
+        napi_env env;
+        void *data;
+    };
 
-    if (info.Length() < (uint32_t)func->required_parameters) [[unlikely]] {
-        ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, info.Length());
-        return env.Null();
-    }
+    CallbackBundle **ptr = (CallbackBundle **)((uint8_t *)info + K_SIZE(void *));
+    FunctionInfo *func = (FunctionInfo *)(*ptr)->data;
 
+    InstanceData *instance = func->instance;
     InstanceMemory *mem = instance->memories[0];
-    CallData call(env, instance, mem);
+    CallData call(env, instance, mem, func->native);
 
-    if (!call.Prepare(func, info)) [[unlikely]]
-        return env.Null();
+    K_DEFER_C(prev_call = instance->sync_call) { instance->sync_call = prev_call; };
+    instance->sync_call = &call;
 
-    if (instance->debug) {
-        call.DumpForward(func);
-    }
+    napi_value ret = call.Run(func, nullptr);
+    call.FinalizeFast();
 
-    // Execute call
-    {
-        K_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
-        exec_call = &call;
+    return ret;
+}
+
+static napi_value TranslateZeroCallBun(napi_env env, napi_callback_info info)
+{
+    FunctionInfo *func = *(FunctionInfo **)((uint8_t *)info + K_SIZE(void *));
+
+    InstanceData *instance = func->instance;
+    InstanceMemory *mem = instance->memories[0];
+    CallData call(env, instance, mem, func->native);
+
+    K_DEFER_C(prev_call = instance->sync_call) { instance->sync_call = prev_call; };
+    instance->sync_call = &call;
+
+    napi_value ret = call.Run(func, nullptr);
+    call.FinalizeFast();
+
+    return ret;
+}
+
+napi_value TranslateFastCall(napi_env env, napi_callback_info info)
+{
+    napi_value args[6];
+    size_t count = 6;
+    FunctionInfo *func;
+
+    napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, (void **)&func);
+    K_ASSERT(status == napi_ok);
+
+    InstanceData *instance = func->instance;
 
-        call.Execute(func, native);
+    if (count < (size_t)func->required_parameters) [[unlikely]] {
+        ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, count);
+        return Napi::Env(env).Null();
     }
 
-    return call.Complete(func);
+    InstanceMemory *mem = instance->memories[0];
+    CallData call(env, instance, mem, func->native);
+
+    K_DEFER_C(prev_call = instance->sync_call) { instance->sync_call = prev_call; };
+    instance->sync_call = &call;
+
+    napi_value ret = call.Run(func, args);
+    call.FinalizeFast();
+
+    return ret;
 }
 
-Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
+static FORCE_INLINE napi_value TranslateNormalCall(napi_env env, const FunctionInfo *func, void *native, napi_value *args, Size count)
 {
-    FunctionInfo *func = (FunctionInfo *)info.Data();
-    return TranslateNormalCall(func, func->native, info);
+    static_assert(MaxParameters >= 6);
+
+    InstanceData *instance = func->instance;
+
+    if (count < func->required_parameters) [[unlikely]] {
+        ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, count);
+        return Napi::Env(env).Null();
+    }
+
+    InstanceMemory *mem = instance->memories[0];
+    CallData call(env, instance, mem, native);
+
+    K_DEFER_C(prev_call = instance->sync_call) { instance->sync_call = prev_call; };
+    instance->sync_call = &call;
+
+    napi_value ret = call.Run(func, args);
+    call.Finalize();
+
+    return ret;
 }
 
-static Napi::Value TranslateVariadicCall(const FunctionInfo *func, void *native,
-                                         const Napi::CallbackInfo &info)
+napi_value TranslateNormalCall(napi_env env, napi_callback_info info)
 {
-    Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    napi_value args[MaxParameters];
+    size_t count = 6;
+    FunctionInfo *func;
 
-    FunctionInfo copy;
-    memcpy((void *)&copy, func, K_SIZE(*func));
-    copy.lib = nullptr;
+    napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, (void **)&func);
+    K_ASSERT(status == napi_ok);
 
-    // This makes variadic calls non-reentrant
-    K_DEFER_C(len = copy.parameters.len) {
-        copy.parameters.RemoveFrom(len);
-        copy.parameters.Leak();
-    };
+    if (count > 6) {
+        napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, nullptr);
+        K_ASSERT(status == napi_ok);
 
-    if (info.Length() < (uint32_t)copy.required_parameters) [[unlikely]] {
-        ThrowError<Napi::TypeError>(env, "Expected %1 arguments or more, got %2", copy.parameters.len, info.Length());
-        return env.Null();
-    }
-    if ((info.Length() - copy.required_parameters) % 2) [[unlikely]] {
-        ThrowError<Napi::Error>(env, "Missing value argument for variadic call");
-        return env.Null();
+        count = std::min(count, (size_t)MaxParameters);
     }
 
-    for (Size i = copy.required_parameters; i < (Size)info.Length(); i += 2) {
-        ParameterInfo param = {};
+    return TranslateNormalCall(env, func, func->native, args, (Size)count);
+}
 
-        param.type = ResolveType(info[(uint32_t)i], &param.directions);
+static napi_value TranslateVariadicCall(napi_env env, const FunctionInfo *func, void *native, napi_value *args, Size count)
+{
+    static_assert(MaxParameters >= 6);
 
-        if (!param.type) [[unlikely]]
-            return env.Null();
-        if (!CanPassType(param.type, param.directions)) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", param.type->name);
-            return env.Null();
+    InstanceData *instance = func->instance;
+
+    FunctionInfo *variadic = nullptr;
+    K_DEFER_N(err_guard) { delete variadic; };
+
+    // Try cached function
+    {
+        FunctionInfo *prev = instance->variadic_func;
+
+        if (prev && prev->native == native) {
+            Size specified = (count - prev->required_parameters);
+            Size processed = (prev->parameters.len - prev->required_parameters) * 2;
+
+            if (specified == processed) {
+                bool match = true;
+
+                for (Size i = prev->required_parameters, j = prev->required_parameters; i < (Size)count; i += 2, j++) {
+                    int directions;
+                    const TypeInfo *type = ResolveType(Napi::Value(env, args[i]), &directions);
+
+                    if (type != prev->parameters[j].type || directions != prev->parameters[j].directions) [[unlikely]] {
+                        match = false;
+                        break;
+                    }
+                }
+
+                if (match) [[likely]] {
+                    variadic = prev;
+
+                    // If an error happens it'll get destroyed, so don't keep it around
+                    instance->variadic_func = nullptr;
+                }
+            }
         }
-        if (copy.parameters.len >= MaxParameters) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
-            return env.Null();
+    }
+
+    if (!variadic) {
+        variadic = new FunctionInfo();
+
+        memcpy((void *)variadic, func, K_SIZE(*func));
+        memset((void *)&variadic->parameters, 0, K_SIZE(variadic->parameters));
+        memset((void *)&variadic->sync, 0, K_SIZE(variadic->sync));
+        memset((void *)&variadic->async, 0, K_SIZE(variadic->async));
+
+        variadic->parameters = func->parameters;
+        variadic->lib = nullptr;
+
+        if (count < variadic->required_parameters) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Expected %1 arguments or more, got %2", variadic->parameters.len, count);
+            return Napi::Env(env).Null();
         }
-        if ((param.directions & 2) && ++copy.out_parameters >= MaxParameters) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 output parameters", MaxParameters);
-            return env.Null();
+        if ((count - variadic->required_parameters) % 2) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "Missing value argument for variadic call");
+            return Napi::Env(env).Null();
         }
 
-        param.variadic = true;
-        param.offset = (int8_t)(i + 1);
+        for (Size i = variadic->required_parameters; i < count; i += 2) {
+            ParameterInfo param = {};
 
-        copy.parameters.Append(param);
-    }
+            param.type = ResolveType(Napi::Value(env, args[i]), &param.directions);
 
-    if (!AnalyseFunction(env, instance, &copy)) [[unlikely]]
-        return env.Null();
+            if (!param.type) [[unlikely]]
+                return Napi::Env(env).Null();
+            if (!CanPassType(param.type, param.directions)) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", param.type->name);
+                return Napi::Env(env).Null();
+            }
+            if (variadic->parameters.len >= MaxParameters) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
+                return Napi::Env(env).Null();
+            }
 
-    InstanceMemory *mem = instance->memories[0];
-    CallData call(env, instance, mem);
+            param.variadic = true;
+            param.offset = (int8_t)(i + 1);
 
-    if (!call.Prepare(&copy, info)) [[unlikely]]
-        return env.Null();
+            variadic->parameters.Append(param);
+        }
 
-    if (instance->debug) {
-        call.DumpForward(&copy);
+        if (!AnalyseFunction(env, instance, variadic)) [[unlikely]]
+            return Napi::Env(env).Null();
     }
 
-    // Execute call
-    {
-        K_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
-        exec_call = &call;
+    InstanceMemory *mem = instance->memories[0];
+    CallData call(env, instance, mem, native);
+
+    K_DEFER_C(prev_call = instance->sync_call) { instance->sync_call = prev_call; };
+    instance->sync_call = &call;
+
+    napi_value ret = call.Run(variadic, args);
+    call.Finalize();
 
-        call.Execute(&copy, native);
+    if (variadic != instance->variadic_func) {
+        err_guard.Disable();
+
+        delete instance->variadic_func;
+        instance->variadic_func = variadic;
     }
 
-    return call.Complete(&copy);
+    return ret;
 }
 
-Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
+napi_value TranslateVariadicCall(napi_env env, napi_callback_info info)
 {
-    FunctionInfo *func = (FunctionInfo *)info.Data();
-    return TranslateVariadicCall(func, func->native, info);
+    napi_value args[MaxParameters];
+    size_t count = 6;
+    FunctionInfo *func;
+
+    napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, (void **)&func);
+    K_ASSERT(status == napi_ok);
+
+    if (count > 6) {
+        napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, nullptr);
+        K_ASSERT(status == napi_ok);
+
+        count = std::min(count, (size_t)MaxParameters);
+    }
+
+    return TranslateVariadicCall(env, func, func->native, args, (Size)count);
 }
 
 class AsyncCall: public Napi::AsyncWorker {
     Napi::Env env;
 
     const FunctionInfo *func;
-    void *native;
+    NoDestroy<CallData> call;
 
-    CallData call;
     bool prepared = false;
 
 public:
-    AsyncCall(Napi::Env env, InstanceData *instance, const FunctionInfo *func,
-              void *native, InstanceMemory *mem, Napi::Function &callback)
-        : Napi::AsyncWorker(callback), env(env), func(func->Ref()), native(native),
-          call(env, instance, mem) {}
-    ~AsyncCall() { func->Unref(); }
+    AsyncCall(Napi::Env env, InstanceData *instance, InstanceMemory *mem, const FunctionInfo *func, Napi::Function &callback)
+        : Napi::AsyncWorker(callback), env(env), func(func->Ref()), call(env, instance, mem, func->native) {}
+    ~AsyncCall();
 
-    bool Prepare(const Napi::CallbackInfo &info) {
-        prepared = call.Prepare(func, info);
+    bool Prepare(napi_value *args) {
+        prepared = call->PrepareAsync(func, args);
 
-        if (!prepared) {
+        if (!prepared) [[unlikely]] {
             Napi::Error err = env.GetAndClearPendingException();
             SetError(err.Message());
         }
 
         return prepared;
     }
-    void DumpForward() { call.DumpForward(func); }
 
     void Execute() override;
     void OnOK() override;
+    void OnError(const Napi::Error& err) override;
 };
 
-void AsyncCall::Execute()
+AsyncCall::~AsyncCall()
 {
-    if (prepared) {
-        K_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
-        exec_call = &call;
+#if defined(K_DEBUG)
+    call->~CallData();
+#endif
+
+    ReleaseMemory(call->instance, call->mem);
+}
 
-        call.Execute(func, native);
+void AsyncCall::Execute()
+{
+    if (prepared) [[likely]] {
+        call->ExecuteAsync();
     }
 }
 
@@ -1651,90 +1777,138 @@ void AsyncCall::OnOK()
 
     Napi::FunctionReference &callback = Callback();
 
-    Napi::Value self = env.Null();
-    napi_value args[] = {
-        env.Null(),
-        call.Complete(func)
-    };
+    napi_value ret = call->EndAsync();
+    call->Finalize();
+
+    napi_value self = env.Null();
+    napi_value args[] = { env.Null(), ret };
 
     callback.Call(self, K_LEN(args), args);
 }
 
-static Napi::Value TranslateAsyncCall(const FunctionInfo *func, void *native,
-                                      const Napi::CallbackInfo &info)
+void AsyncCall::OnError(const Napi::Error& err)
 {
-    K_ASSERT(!func->variadic);
+    Napi::FunctionReference &callback = Callback();
 
-    Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    call->Finalize();
 
-    if (info.Length() <= (uint32_t)func->required_parameters) {
-        ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len + 1, info.Length());
-        return env.Null();
+    napi_value self = env.Null();
+    napi_value args[] = { err.Value(), env.Undefined() };
+
+    callback.Call(self, K_LEN(args), args);
+}
+
+napi_value TranslateAsyncCall(napi_env env, napi_callback_info info)
+{
+    static_assert(MaxParameters >= 6);
+
+    napi_value args[MaxParameters];
+    size_t count = 6;
+    FunctionInfo *func;
+
+    napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, (void **)&func);
+    K_ASSERT(status == napi_ok);
+
+    if (count > 6) {
+        napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, nullptr);
+        K_ASSERT(status == napi_ok);
+
+        count = std::min(count, (size_t)MaxParameters);
+    }
+
+    InstanceData *instance = func->instance;
+
+    if (count <= (size_t)func->required_parameters) {
+        ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->required_parameters + 1, count);
+        return Napi::Env(env).Null();
     }
 
-    Napi::Function callback = info[(uint32_t)func->required_parameters].As<Napi::Function>();
+    Napi::Function callback = Napi::Value(env, args[func->required_parameters]).As<Napi::Function>();
 
     if (!callback.IsFunction()) {
         ThrowError<Napi::TypeError>(env, "Expected callback function as last argument, got %1", GetValueType(instance, callback));
-        return env.Null();
+        return Napi::Env(env).Null();
     }
 
     InstanceMemory *mem = AllocateMemory(instance, instance->config.async_stack_size, instance->config.async_heap_size);
     if (!mem) [[unlikely]] {
         ThrowError<Napi::Error>(env, "Too many asynchronous calls are running");
-        return env.Null();
+        return Napi::Env(env).Null();
     }
-    AsyncCall *async = new AsyncCall(env, instance, func, native, mem, callback);
+    AsyncCall *async = new AsyncCall(env, instance, mem, func, callback);
 
-    if (async->Prepare(info) && instance->debug) {
-        async->DumpForward();
-    }
+    async->Prepare(args);
     async->Queue();
 
-    return env.Undefined();
+    return Napi::Env(env).Undefined();
 }
 
-Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
+static FORCE_INLINE bool CheckTrampolineStatus(TrampolineInfo *trampoline)
 {
-    FunctionInfo *func = (FunctionInfo *)info.Data();
-    return TranslateAsyncCall(func, func->native, info);
+    if (trampoline->state == 1) [[likely]]
+        return true;
+
+    Napi::Env env = trampoline->func.Env();
+
+    if (!trampoline->state) {
+        ThrowError<Napi::Error>(env, "Cannot use non-registered callback beyond FFI call");
+        trampoline->state = -1;
+    }
+
+    // We use trampoline->state < 0 as a signal than an exception has occured, because we want
+    // to avoid calling IsExceptionPending() in the happy path. But trampolines get reused, so
+    // there might not be an exception anymore!
+    if (!env.IsExceptionPending()) {
+        trampoline->state = 1;
+        return true;
+    }
+
+    return false;
 }
 
 extern "C" void RelayCallback(Size idx, uint8_t *sp)
 {
-    CallData *call = exec_call;
+    TrampolineInfo *trampoline = &shared.trampolines[idx];
+    InstanceData *instance = trampoline->instance;
 
-    // Try the fast path first: we are on the main thread and we are running a native call through Koffi.
-    // It should be easy, but in this case we are running on the custom Koffi stack, which will trip up
-    // Node and V8. So we need to switch back to the normal/main stack.
-    if (call && std::this_thread::get_id() == call->instance->main_thread_id) {
-        SwitchAndRelay(call, idx, sp, call->old_sp, &call->mem->stack);
+    // Fast path: main thread and we are running a native call through Koffi.
+    // But this means we are running on the custom Koffi stack, which could trip up
+    // Node and V8, so we need to stwich back to the normal/main stack.
+    if (InstanceMemory *mem0 = instance->memories[0]; sp >= mem0->stack0.ptr && sp <= mem0->stack0.end) {
+        CallData *call = instance->sync_call;
+
+        SwitchAndRelay(call, idx, sp, call->saved_sp, &call->mem->stack);
         return;
     }
 
+    if (!CheckTrampolineStatus(trampoline))
+        return;
+
     // Otherwise, we need to allocate memory to perform the callback.
     // Since the necessary machinery live in CallData, just use a temporary instance.
-    // In some cases we would reuse the existing call (exec_call may be not null),
-    // but it is rare so let's ignore this for simplicity.
+    // In some cases we would reuse the existing call, but it is rare so let's ignore
+    // this for simplicity.
 
-    TrampolineInfo *trampoline = &shared.trampolines[idx];
     Napi::Env env = trampoline->func.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     InstanceMemory *mem = AllocateMemory(instance, instance->config.async_stack_size, instance->config.async_heap_size);
     if (!mem) [[unlikely]] {
         ThrowError<Napi::Error>(env, "Too many asynchronous calls are running");
         return;
     }
+    K_DEFER { ReleaseMemory(instance, mem); };
 
     if (std::this_thread::get_id() == instance->main_thread_id) {
-        CallData call(env, instance, mem);
+        CallData call(env, instance, mem, nullptr);
+        K_DEFER { call.Finalize(); };
+
+        napi_handle_scope scope;
+        napi_open_handle_scope(env, &scope);
+        K_DEFER { napi_close_handle_scope(env, scope); };
 
-        Napi::HandleScope scope(env);
         call.Relay(idx, sp);
     } else {
-        CallData call(env, instance, mem);
+        CallData call(env, instance, mem, nullptr);
         call.RelayAsync(idx, sp);
     }
 }
@@ -1742,7 +1916,6 @@ extern "C" void RelayCallback(Size idx, uint8_t *sp)
 extern "C" void RelayDirect(CallData *call, Size idx, uint8_t *sp)
 {
     TrampolineInfo *trampoline = &shared.trampolines[idx];
-    Napi::Env env = trampoline->func.Env();
 
 #if defined(_WIN32)
     TEB *teb = GetTEB();
@@ -1763,15 +1936,17 @@ extern "C" void RelayDirect(CallData *call, Size idx, uint8_t *sp)
     teb->DeallocationStack = instance->main_stack_min;
 #endif
 
-    if (env.IsExceptionPending()) [[unlikely]]
-        return;
-    if (!trampoline->used) [[unlikely]] {
-        ThrowError<Napi::Error>(env, "Cannot use non-registered callback beyond FFI call");
+    if (!CheckTrampolineStatus(trampoline))
         return;
-    }
 
-    Napi::HandleScope scope(call->env);
-    call->Relay(idx, sp);
+    // Relay the call
+    {
+        napi_handle_scope scope;
+        napi_open_handle_scope(call->env, &scope);
+        K_DEFER { napi_close_handle_scope(call->env, scope); };
+
+        call->Relay(idx, sp);
+    }
 }
 
 static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info)
@@ -1783,6 +1958,8 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info)
     FunctionInfo *func = new FunctionInfo();
     K_DEFER { func->Unref(); };
 
+    func->env = env;
+    func->instance = instance;
     func->lib = lib->Ref();
 
     if (info.Length() >= 2) {
@@ -1810,10 +1987,6 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info)
 
     if (!AnalyseFunction(env, instance, func))
         return env.Null();
-    if (func->variadic) {
-        // Minimize reallocations
-        func->parameters.Grow(32);
-    }
 
 #if defined(_WIN32)
     if (func->ordinal_name < 0) {
@@ -1877,10 +2050,7 @@ static Napi::Value FindSymbol(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    Napi::External<void> external = Napi::External<void>::New(env, ptr);
-    SetValueTag(external, &type);
-
-    return external;
+    return WrapPointer(env, type, ptr);
 }
 
 static Napi::Value UnloadLibrary(const Napi::CallbackInfo &info)
@@ -1902,11 +2072,11 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
         ThrowError<Napi::TypeError>(env, "Expected 1 or 2 arguments, got %1", info.Length());
         return env.Null();
     }
-    if (!info[0].IsString() && !IsNullOrUndefined(info[0])) {
+    if (!info[0].IsString() && !IsNullOrUndefined(env, info[0])) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for filename, expected string or null", GetValueType(instance, info[0]));
         return env.Null();
     }
-    if (info.Length() >= 2 && !IsObject(info[1])) {
+    if (info.Length() >= 2 && !IsObject(env, info[1])) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for options, expected object", GetValueType(instance, info[1]));
         return env.Null();
     }
@@ -2037,25 +2207,22 @@ static Napi::Value RegisterCallback(const Napi::CallbackInfo &info)
 
     TrampolineInfo *trampoline = &shared.trampolines[idx];
 
+    trampoline->state = 1;
     trampoline->instance = instance;
     trampoline->proto = type->ref.proto;
     trampoline->func.Reset(func, 1);
-    if (!IsNullOrUndefined(recv)) {
+    if (!IsNullOrUndefined(env, recv)) {
         trampoline->recv.Reset(recv, 1);
     } else {
         trampoline->recv.Reset();
     }
-    trampoline->used = true;
 
     void *ptr = GetTrampoline(idx);
 
-    Napi::External<void> external = Napi::External<void>::New(env, ptr);
-    SetValueTag(external, type->ref.marker);
-
     // Cache index for fast unregistration
     instance->trampolines_map.Set(ptr, idx);
 
-    return external;
+    return WrapCallback(env, type->ref.type, ptr);
 }
 
 static Napi::Value UnregisterCallback(const Napi::CallbackInfo &info)
@@ -2067,14 +2234,13 @@ static Napi::Value UnregisterCallback(const Napi::CallbackInfo &info)
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
         return env.Null();
     }
-    if (!info[0].IsExternal()) {
+
+    void *ptr;
+    if (!TryPointer(env, info[0], &ptr)) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for id, expected registered callback", GetValueType(instance, info[0]));
         return env.Null();
     }
 
-    Napi::External<void> external = info[0].As<Napi::External<void>>();
-    void *ptr = external.Data();
-
     int16_t idx;
     {
         int16_t *it = instance->trampolines_map.Find(ptr);
@@ -2095,9 +2261,9 @@ static Napi::Value UnregisterCallback(const Napi::CallbackInfo &info)
         TrampolineInfo *trampoline = &shared.trampolines[idx];
         K_ASSERT(!trampoline->func.IsEmpty());
 
+        trampoline->state = 0;
         trampoline->func.Reset();
         trampoline->recv.Reset();
-        trampoline->used = false;
 
         shared.available.Append(idx);
     }
@@ -2128,13 +2294,14 @@ static Napi::Value CastValue(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    ValueCast *cast = new ValueCast;
+    ValueCast *cast = new ValueCast();
 
-    cast->ref.Reset(value, 1);
+    cast->env = env;
+    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; });
-    SetValueTag(external, &CastMarker);
+    SetValueTag(env, external, &CastMarker);
 
     return external;
 }
@@ -2161,10 +2328,10 @@ static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
     if (has_len) {
         Size len = info[2 + has_offset].As<Napi::Number>();
 
-        Napi::Value ret = Decode(value, offset, type, &len);
+        Napi::Value ret = Decode(value, (Size)offset, type, &len);
         return ret;
     } else {
-        Napi::Value ret = Decode(value, offset, type);
+        Napi::Value ret = Decode(value, (Size)offset, type);
         return ret;
     }
 }
@@ -2212,8 +2379,10 @@ static Napi::Value CallPointerSync(const Napi::CallbackInfo &info)
 
     const FunctionInfo *proto = type->ref.proto;
 
-    return proto->variadic ? TranslateVariadicCall(proto, ptr, info)
-                           : TranslateNormalCall(proto, ptr, info);
+    napi_value ret = proto->variadic ? TranslateVariadicCall(env, proto, ptr, info.First() + 2, info.Length() - 2)
+                                     : TranslateNormalCall(env, proto, ptr, info.First() + 2, info.Length() - 2);
+
+    return Napi::Value(env, ret);
 }
 
 static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
@@ -2239,10 +2408,10 @@ static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
     if (has_len) {
         Size len = info[3 + has_offset].As<Napi::Number>();
 
-        if (!Encode(ref, offset, value, type, &len))
+        if (!Encode(ref, (Size)offset, value, type, &len))
             return env.Null();
     } else {
-        if (!Encode(ref, offset, value, type))
+        if (!Encode(ref, (Size)offset, value, type))
             return env.Null();
     }
 
@@ -2318,6 +2487,11 @@ static Napi::Value ResetKoffi(const Napi::CallbackInfo &info)
 
     instance->callbacks.Clear();
 
+    for (InstanceMemory *mem: instance->memories) {
+        delete mem;
+    }
+    instance->memories.Clear();
+
     return env.Undefined();
 }
 
@@ -2349,6 +2523,18 @@ void LibraryHolder::Unref() const
     }
 }
 
+ValueCast::~ValueCast()
+{
+    if (node_api_post_finalizer) {
+        node_api_post_finalizer(env, [](napi_env env, void *data, void *) {
+            napi_ref ref = (napi_ref)data;
+            napi_delete_reference(env, ref);
+        }, (void *)ref, nullptr);
+    } else {
+        napi_delete_reference(env, ref);
+    }
+}
+
 FunctionInfo::~FunctionInfo()
 {
     if (lib) {
@@ -2380,10 +2566,10 @@ InstanceMemory::~InstanceMemory()
     }
 #else
     if (stack.ptr) {
-        munmap(stack.ptr, stack.len);
+        munmap(stack.ptr, stack.end - stack.ptr);
     }
     if (heap.ptr) {
-        munmap(heap.ptr, heap.len);
+        munmap(heap.ptr, heap.end - heap.ptr);
     }
 #endif
 }
@@ -2431,10 +2617,8 @@ static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initiali
     }
 
     if (ref) {
-        const TypeInfo *marker = instance->types_map.FindValue(ref, nullptr);
-        K_ASSERT(marker);
-
-        type->ref.marker = marker;
+        type->ref.type = instance->types_map.FindValue(ref, nullptr);
+        K_ASSERT(type->ref.type);
     }
 
     Napi::Value wrapper = WrapType(env, type);
@@ -2480,33 +2664,124 @@ static inline PrimitiveKind GetBigEndianPrimitive(PrimitiveKind kind)
 #endif
 }
 
-static InstanceData *CreateInstance()
+static bool DetectBun(Napi::Env env)
 {
-    InstanceData *instance = new InstanceData();
-    K_DEFER_N(err_guard) { delete instance; };
+    Napi::Value ret = env.RunScript("process.isBun");
+    Napi::Boolean b = ret.ToBoolean();
 
-    instance->main_thread_id = std::this_thread::get_id();
+    return b.Value();
+}
 
-    instance->debug = GetDebugFlag("DUMP_CALLS");
+static void PickTranslateZeroCallVariant(Napi::Env env)
+{
+    static int BunTrap = 42;
 
-#if defined(_WIN32)
-    TEB *teb = GetTEB();
+    Napi::Object self = Napi::Object::New(env);
 
-    instance->main_stack_max = teb->StackBase;
-    instance->main_stack_min = teb->DeallocationStack;
-#endif
+    napi_status status;
+    napi_value func;
+    napi_value ret;
 
-    err_guard.Disable();
-    return instance;
+    status = napi_create_function(env, nullptr, 0, [](napi_env env, napi_callback_info info) {
+        napi_value self;
+        napi_get_cb_info(env, info, nullptr, nullptr, &self, nullptr);
+
+        void **ptr1 = (void **)info;
+        napi_value *ptr2 = (napi_value *)info;
+
+        if (ptr1[0] == &BunTrap || ptr1[1] == &BunTrap) {
+            translate_zero_call = TranslateZeroCallBun;
+        } else if (ptr2[0] != self && ptr2[1] != self) {
+            translate_zero_call = TranslateZeroCallNode;
+        } else {
+            translate_zero_call = TranslateFastCall;
+        }
+
+        return self;
+    }, &BunTrap, &func);
+    K_ASSERT(status == napi_ok);
+
+    status = napi_call_function(env, self, func, 0, nullptr, &ret);
+    K_ASSERT(status == napi_ok);
+}
+
+static bool CanReferencePrimitiveValues(napi_env env)
+{
+    uint32_t version = 0;
+    napi_get_version(env, &version);
+
+    return version >= 10;
+}
+
+static bool CanDeleteReferenceInFinalizer(napi_env env)
+{
+    const napi_node_version *version = nullptr;
+    napi_get_node_version(env, &version);
+
+    if (version->major >= 24)
+        return true;
+
+    // Made by looking at the git history of each release branch
+    if (version->major == 23 && version->minor >= 5)
+        return true;
+    if (version->major == 22 && version->minor >= 13)
+        return true;
+    if (version->major == 20 && version->minor >= 19)
+        return true;
+    if (version->major == 20 && version->minor == 18 && version->patch >= 3)
+        return true;
+
+    return false;
 }
 
 static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
 {
-    InstanceData *instance = CreateInstance();
+    // Load recent N-API functions (version >= 9) functions dynamically
+    {
+        static std::once_flag flag;
+
+        std::call_once(flag, [&]() {
+            PickTranslateZeroCallVariant(env);
+
+            if (DetectBun(env))
+                return;
+
+            uv_lib_t lib = {};
+
+#if defined(_WIN32)
+            lib.handle = GetModuleHandle(nullptr);
+#else
+            uv_dlopen(nullptr, &lib);
+            K_DEFER { uv_dlclose(&lib); };
+#endif
+
+            if (CanReferencePrimitiveValues(env)) {
+                // We can't use optimized property keys in older versions because we need to create
+                // references to them, but napi_create_reference() was not usable with primitive values.
+                uv_dlsym(&lib, "node_api_create_property_key_utf8", (void **)&node_api_create_property_key_utf8);
+            }
+
+            if (!CanDeleteReferenceInFinalizer(env)) {
+                // napi_delete_reference cannot be safely used in older Node versions because it
+                // errors out (or even asserts) if it gets called in a finalizer. In this case,
+                // use experimental API to try to run it later.
+                uv_dlsym(&lib, "node_api_post_finalizer", (void **)&node_api_post_finalizer);
+            }
+        });
+    }
+
+    InstanceData *instance = new InstanceData();
     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);
+#endif
+
     exports.Set("config", Napi::Function::New(env, GetSetConfig, "config"));
     exports.Set("stats", Napi::Function::New(env, GetStats, "stats"));
 
@@ -2558,7 +2833,7 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
         Napi::Object codes = Napi::Object::New(env);
 
         for (const ErrnoCodeInfo &info: ErrnoCodes) {
-            codes.Set(info.name, Napi::Number::New(env, info.value));
+            codes.Set(info.name, NewInt(env, (int32_t)info.value));
         }
 
         os.Set("errno", codes);
@@ -2649,10 +2924,7 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
         Napi::Object node = Napi::Object::New(env);
         exports.Set("node", node);
 
-        Napi::External<void> external = Napi::External<void>::New(env, (napi_env)env);
-        SetValueTag(external, instance->void_type);
-
-        node.Set("env", external);
+        node.Set("env", WrapPointer(env, instance->void_type, (napi_env)env));
 
         node.Set("poll", Napi::Function::New(env, &Poll, "poll"));
         node.Set("PollHandle", PollHandle::Define(env));
@@ -2660,6 +2932,18 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
 
     exports.Set("version", Napi::String::New(env, K_STRINGIFY(VERSION)));
 
+#if defined(_WIN32)
+    {
+        TEB *teb = GetTEB();
+
+        instance->main_stack_max = teb->StackBase;
+        instance->main_stack_min = teb->DeallocationStack;
+    }
+#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) {
         InstanceData *instance = (InstanceData *)udata;
 
@@ -2676,6 +2960,8 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
 
 InstanceData::~InstanceData()
 {
+    delete variadic_func;
+
     for (InstanceMemory *mem: memories) {
         delete mem;
     }
@@ -2691,7 +2977,7 @@ InstanceData::~InstanceData()
                 trampoline->instance = nullptr;
                 trampoline->func.Reset();
                 trampoline->recv.Reset();
-                trampoline->used = false;
+                trampoline->state = 0;
             }
         }
     }