koffi 3.0.1 → 3.1.0

package/src/koffi/src/call.cc

@@ -4,6 +4,7 @@
 #include "lib/native/base/base.hh"
 #include "call.hh"
 #include "ffi.hh"
+#include "type.hh"
 #include "util.hh"
 #if defined(_WIN32)
     #include "win32.hh"
@@ -44,6 +45,8 @@ static const Size TrampolineSize = ((const uint8_t *)&TrampolineEnd - Trampoline
 
 #endif
 
+static napi_value (*translate_zero_call)(napi_env env, napi_callback_info info);
+
 #if defined(K_DEBUG)
 CallData::~CallData()
 {
@@ -71,21 +74,12 @@ void CallData::Finalize()
                         DecodeElements(instance, value, out.ptr, out.type, len);
                     } break;
 
-                    case OutArgument::Kind::Buffer: {
-                        Span<uint8_t> buffer;
-
-                        bool success = TryBuffer(env, value, &buffer);
-                        K_ASSERT(success);
-
-                        DecodeBuffer(buffer, out.ptr, out.type);
-                    } break;
-
                     case OutArgument::Kind::String: {
                         K_ASSERT(IsArray(env, value));
                         K_ASSERT(GetArrayLength(env, value) == 1);
 
                         Size len = strnlen((const char *)out.ptr, out.max_len);
-                        Napi::String str = Napi::String::New(env, (const char *)out.ptr, len);
+                        napi_value str = NewString(env, (const char *)out.ptr, len);
 
                         napi_set_element(env, value, 0, str);
                     } break;
@@ -95,7 +89,7 @@ void CallData::Finalize()
                         K_ASSERT(GetArrayLength(env, value) == 1);
 
                         Size len = NullTerminatedLength((const char16_t *)out.ptr, out.max_len);
-                        Napi::String str = Napi::String::New(env, (const char16_t *)out.ptr, len);
+                        napi_value str = NewString(env, (const char16_t *)out.ptr, len);
 
                         napi_set_element(env, value, 0, str);
                     } break;
@@ -105,7 +99,7 @@ void CallData::Finalize()
                         K_ASSERT(GetArrayLength(env, value) == 1);
 
                         Size len = NullTerminatedLength((const char32_t *)out.ptr, out.max_len);
-                        Napi::String str = MakeStringFromUTF32(env, (const char32_t *)out.ptr, len);
+                        napi_value str = NewString(env, (const char32_t *)out.ptr, len);
 
                         napi_set_element(env, value, 0, str);
                     } break;
@@ -113,7 +107,7 @@ void CallData::Finalize()
                     case OutArgument::Kind::Object: {
                         if (CheckValueTag(env, value, &UnionValueMarker)) {
                             UnionValue *u = nullptr;
-                            napi_unwrap(env, value, (void **)&u);
+                            NAPI_OK(napi_unwrap(env, value, (void **)&u));
 
                             u->SetRaw(out.ptr);
                         } else {
@@ -125,7 +119,7 @@ void CallData::Finalize()
         }
 
         for (const OutArgument &out: out_arguments) {
-            napi_delete_reference(env, out.ref);
+            node_api_delete_reference(env, out.ref);
         }
     }
 
@@ -140,7 +134,7 @@ void CallData::Finalize()
             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);
@@ -183,7 +177,7 @@ void CallData::RelayAsync(Size idx, uint8_t *sp)
         .sp = sp
     };
 
-    napi_call_threadsafe_function(instance->broker, &ctx, napi_tsfn_blocking);
+    NAPI_OK(napi_call_threadsafe_function(instance->broker, &ctx, napi_tsfn_blocking));
 
     // Wait until it executes
     std::unique_lock<std::mutex> lock(ctx.mutex);
@@ -198,8 +192,8 @@ napi_value CallData::CallCallback(const TrampolineInfo *trampoline, const napi_v
     napi_value func;
     napi_value value;
 
-    napi_get_undefined(env, &recv);
-    napi_get_reference_value(env, trampoline->func, &func);
+    NAPI_OK(napi_get_undefined(env, &recv));
+    NAPI_OK(napi_get_reference_value(env, trampoline->func, &func));
 
     napi_status status = napi_call_function(env, recv, func, (size_t)count, args, &value);
     if (status == napi_pending_exception) [[unlikely]]
@@ -257,16 +251,13 @@ bool CallData::PushString32(napi_value value, int directions, const char32_t **o
 Size CallData::PushStringValue(napi_value value, const char **out_str)
 {
     size_t len;
-    napi_status status;
 
     size_t available = (size_t)(mem->heap.end - mem->heap.ptr);
     char *ptr = (char *)mem->heap.ptr;
 
     // Fast path for small strings
     if (available >= 4096) [[likely]] {
-        char *ptr = (char *)mem->heap.ptr;
-
-        status = napi_get_value_string_utf8(env, value, ptr, 4096, &len);
+        napi_status status = napi_get_value_string_utf8(env, value, ptr, 4096, &len);
         if (status == napi_string_expected)
             return -1;
         K_ASSERT(status == napi_ok);
@@ -285,14 +276,12 @@ Size CallData::PushStringValue(napi_value value, const char **out_str)
         }
     }
 
-    status = napi_get_value_string_utf8(env, value, nullptr, 0, &len);
-    K_ASSERT(status == napi_ok);
+    NAPI_OK(napi_get_value_string_utf8(env, value, nullptr, 0, &len));
 
     len++;
 
     if (len <= available) {
-        status = napi_get_value_string_utf8(env, value, ptr, len, nullptr);
-        K_ASSERT(status == napi_ok);
+        NAPI_OK(napi_get_value_string_utf8(env, value, ptr, len, nullptr));
 
         mem->heap.ptr += (Size)AlignLen(len, 16);
 
@@ -302,8 +291,7 @@ Size CallData::PushStringValue(napi_value value, const char **out_str)
         Span<char> buf = AllocateSpan<char>(&mem->allocator, (Size)len);
         release_alloc |= (prev_stack == mem->stack.end);
 
-        status = napi_get_value_string_utf8(env, value, buf.ptr, len, nullptr);
-        K_ASSERT(status == napi_ok);
+        NAPI_OK(napi_get_value_string_utf8(env, value, buf.ptr, len, nullptr));
 
         *out_str = buf.ptr;
         return (Size)len;
@@ -314,9 +302,8 @@ Size CallData::PushString16Value(napi_value value, const char16_t **out_str16)
 {
     size_t len = 0;
     Span<char16_t> buf;
-    napi_status status;
 
-    status = napi_get_value_string_utf16(env, value, nullptr, 0, &len);
+    napi_status status = napi_get_value_string_utf16(env, value, nullptr, 0, &len);
     if (status == napi_string_expected)
         return -1;
     K_ASSERT(status == napi_ok);
@@ -327,16 +314,14 @@ Size CallData::PushString16Value(napi_value value, const char16_t **out_str16)
     buf.len = (mem->heap.end - mem->heap.ptr) / 2;
 
     if (len <= (size_t)buf.len) {
-        status = napi_get_value_string_utf16(env, value, buf.ptr, len, nullptr);
-        K_ASSERT(status == napi_ok);
+        NAPI_OK(napi_get_value_string_utf16(env, value, buf.ptr, len, nullptr));
 
         mem->heap.ptr += (Size)AlignLen(len * 2, 16);
     } else {
         buf = AllocateSpan<char16_t>(&mem->allocator, (Size)len);
         release_alloc |= (prev_stack == mem->stack.end);
 
-        status = napi_get_value_string_utf16(env, value, buf.ptr, len, nullptr);
-        K_ASSERT(status == napi_ok);
+        NAPI_OK(napi_get_value_string_utf16(env, value, buf.ptr, len, nullptr));
     }
 
     *out_str16 = buf.ptr;
@@ -391,17 +376,16 @@ Size CallData::PushString32Value(napi_value value, const char32_t **out_str32)
     return j;
 }
 
-static inline napi_value GetMemberValue(napi_env env, napi_value obj, const RecordMember &member)
+static FORCE_INLINE napi_value GetMemberValue(napi_env env, napi_value obj, const RecordMember &member)
 {
-    napi_value value = nullptr;
+    napi_value value;
 
     if (member.key) {
-        napi_value key = nullptr;
-        napi_get_reference_value(env, member.key, &key);
-
-        napi_get_property(env, obj, key, &value);
+        napi_value key;
+        NAPI_OK(napi_get_reference_value(env, member.key, &key));
+        NAPI_OK(napi_get_property(env, obj, key, &value));
     } else {
-        napi_get_named_property(env, obj, member.name, &value);
+        NAPI_OK(napi_get_named_property(env, obj, member.name, &value));
     }
 
     return value;
@@ -409,10 +393,14 @@ static inline napi_value GetMemberValue(napi_env env, napi_value obj, const Reco
 
 bool CallData::PushObject(napi_value obj, const TypeInfo *type, uint8_t *origin)
 {
-    K_ASSERT(IsObject(env, obj));
     K_ASSERT(type->primitive == PrimitiveKind::Record ||
              type->primitive == PrimitiveKind::Union);
 
+    if (GetKindOf(env, obj) != napi_object) [[unlikely]] {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, obj));
+        return false;
+    }
+
     Span<const RecordMember> members = type->members;
 
     if (type->primitive == PrimitiveKind::Union) {
@@ -562,12 +550,7 @@ bool CallData::PushObject(napi_value obj, const TypeInfo *type, uint8_t *origin)
             } break;
             case PrimitiveKind::Record:
             case PrimitiveKind::Union: {
-                if (!IsObject(env, value)) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
-                    return false;
-                }
-
-                if (!PushObject(value, member.type, dest))
+                if (!PushObject(value, member.type, dest)) [[unlikely]]
                     return false;
             } break;
             case PrimitiveKind::Array: {
@@ -652,7 +635,7 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
 #define PUSH_ARRAY(SetCode) \
         do { \
             for (Size i = 0; i < len; i++) { \
-                Napi::Value value = array[(uint32_t)i]; \
+                napi_value value = array[(uint32_t)i].AsValue(); \
                  \
                 uint8_t *dest = origin + offset; \
                 SetCode \
@@ -744,11 +727,6 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
         } break;
         case PrimitiveKind::Pointer: {
             PUSH_ARRAY({
-                if (!IsObject(env, value)) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
-                    return false;
-                }
-
                 void *ptr;
                 if (!PushPointer(value, ref, 1, &ptr)) [[unlikely]]
                     return false;
@@ -759,28 +737,23 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: {
             PUSH_ARRAY({
-                if (!IsObject(env, value)) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
-                    return false;
-                }
-
-                if (!PushObject(value, ref, dest))
+                if (!PushObject(value, ref, dest)) [[unlikely]]
                     return false;
             });
         } break;
         case PrimitiveKind::Array: {
             for (Size i = 0; i < len; i++) {
-                Napi::Value value = array[(uint32_t)i];
+                napi_value value = array[(uint32_t)i].AsValue();
 
                 uint8_t *dest = origin + offset;
 
-                if (value.IsArray()) {
-                    Napi::Array array2 = value.As<Napi::Array>();
-                    if (!PushNormalArray(array2, ref, (Size)ref->size, dest))
+                if (IsArray(env, value)) {
+                    Napi::Array array = Napi::Array(env, value);
+                    if (!PushNormalArray(array, ref, (Size)ref->size, dest))
                         return false;
                 } else if (Span<uint8_t> buffer = {}; TryBuffer(env, value, &buffer)) {
                     PushBuffer(buffer, ref, dest);
-                } else if (value.IsString()) {
+                } else if (GetKindOf(env, value) == napi_string) {
                     if (!PushStringArray(value, ref, dest))
                         return false;
                 } else {
@@ -814,19 +787,13 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
             });
         } break;
         case PrimitiveKind::Callback: {
-            for (Size i = 0; i < len; i++) {
-                Napi::Value value = array[(uint32_t)i];
-
-                uint8_t *dest = origin + offset;
-
+            PUSH_ARRAY({
                 void *ptr;
                 if (!PushCallback(value, ref, &ptr))
                     return false;
 
-                *(void **)dest = ptr;
-
-                offset += stride;
-            }
+                *(const void **)dest = ptr;
+            });
         } break;
 
         case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
@@ -893,14 +860,9 @@ bool CallData::PushStringArray(napi_value value, const TypeInfo *type, uint8_t *
     size_t encoded = 0;
 
     switch (type->ref.type->primitive) {
-        case PrimitiveKind::Int8: {
-            napi_status status = napi_get_value_string_utf8(env, value, (char *)origin, type->size, &encoded);
-            K_ASSERT(status == napi_ok);
-        } break;
+        case PrimitiveKind::Int8: { NAPI_OK(napi_get_value_string_utf8(env, value, (char *)origin, type->size, &encoded)); } break;
         case PrimitiveKind::Int16: {
-            napi_status status = napi_get_value_string_utf16(env, value, (char16_t *)origin, type->size / 2, &encoded);
-            K_ASSERT(status == napi_ok);
-
+            NAPI_OK(napi_get_value_string_utf16(env, value, (char16_t *)origin, type->size / 2, &encoded));
             encoded *= 2;
         } break;
 
@@ -933,7 +895,7 @@ restart:
             Napi::External<ValueCast> external = Napi::External<ValueCast>(env, value);
             ValueCast *cast = external.Data();
 
-            napi_get_reference_value(env, cast->ref, &value);
+            NAPI_OK(napi_get_reference_value(env, cast->ref, &value));
             type = cast->type;
 
             goto restart;
@@ -1029,8 +991,7 @@ bool CallData::PushPointerSlow(napi_value value, napi_valuetype kind, const Type
         if (directions & 2) {
             OutArgument *out = out_arguments.AppendDefault();
 
-            napi_status status = napi_create_reference(env, value, 1, &out->ref);
-            K_ASSERT(status == napi_ok);
+            NAPI_OK(napi_create_reference(env, value, 1, &out->ref));
 
             out->kind = out_kind;
             out->ptr = (const uint8_t *)ptr;
@@ -1042,8 +1003,6 @@ bool CallData::PushPointerSlow(napi_value value, napi_valuetype kind, const Type
         return true;
     } else if (ref->primitive == PrimitiveKind::Record ||
                ref->primitive == PrimitiveKind::Union) [[likely]] {
-        K_ASSERT(IsObject(env, value));
-
         ptr = (void *)AllocHeap(ref->size);
 
         if (ref->primitive == PrimitiveKind::Union &&
@@ -1053,17 +1012,19 @@ bool CallData::PushPointerSlow(napi_value value, napi_valuetype kind, const Type
         }
 
         if (directions & 1) {
-            if (!PushObject(value, ref, (uint8_t *)ptr))
+            if (!PushObject(value, ref, (uint8_t *)ptr)) [[unlikely]]
                 return false;
         } else {
+            if (kind != napi_object) [[unlikely]]
+                return false;
+
             MemSet(ptr, 0, ref->size);
         }
 
         if (directions & 2) {
             OutArgument *out = out_arguments.AppendDefault();
 
-            napi_status status = napi_create_reference(env, value, 1, &out->ref);
-            K_ASSERT(status == napi_ok);
+            NAPI_OK(napi_create_reference(env, value, 1, &out->ref));
 
             out->kind = OutArgument::Kind::Object;
             out->ptr = (const uint8_t *)ptr;
@@ -1107,7 +1068,7 @@ restart:
             Napi::External<ValueCast> external = Napi::External<ValueCast>(env, value);
             ValueCast *cast = external.Data();
 
-            napi_get_reference_value(env, cast->ref, &value);
+            NAPI_OK(napi_get_reference_value(env, cast->ref, &value));
             type = cast->type;
 
             goto restart;
@@ -1132,7 +1093,7 @@ restart:
         Napi::External<ValueCast> external = Napi::External<ValueCast>(env, value);
         ValueCast *cast = external.Data();
 
-        napi_get_reference_value(env, cast->ref, &value);
+        NAPI_OK(napi_get_reference_value(env, cast->ref, &value));
         type = cast->type;
 
         goto restart;
@@ -1148,7 +1109,7 @@ Size CallData::PushIndirectString(Napi::Array array, const TypeInfo *ref, void *
     if (array.Length() != 1)
         return -1;
 
-    Napi::Value value = array[0u];
+    napi_value value = array[0u].AsValue();
 
     if (ref == instance->void_type) {
         return PushStringValue(value, (const char **)out_ptr);
@@ -1192,7 +1153,7 @@ void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func
     trampoline->instance = instance;
     trampoline->stack0 = instance->memories[0]->stack0;
     trampoline->proto = proto;
-    napi_create_reference(env, func, 1, &trampoline->func);
+    NAPI_OK(napi_create_reference(env, func, 1, &trampoline->func));
 
     void *ptr = GetTrampoline(idx);
 
@@ -1280,72 +1241,7 @@ void CallData::DebugForward()
 
 #endif
 
-static bool DetectDeno(Napi::Env env)
-{
-    Napi::Value ret = env.RunScript("typeof Deno != 'undefined'");
-    Napi::Boolean b = ret.ToBoolean();
-
-    return b.Value();
-}
-
-static bool DetectBun(Napi::Env env)
-{
-    Napi::Value ret = env.RunScript("process.isBun");
-    Napi::Boolean b = ret.ToBoolean();
-
-    return b.Value();
-}
-
-void InitTranslateZeroCall(Napi::Env env)
-{
-    if (DetectDeno(env) || DetectBun(env)) {
-        translate_zero_call = TranslateFastCall;
-        return;
-    }
-
-    Napi::Object self = Napi::Object::New(env);
-
-    napi_status status;
-    napi_value func;
-    napi_value ret;
-
-    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);
-
-        napi_value *ptr = (napi_value *)info;
-
-        if (ptr[0] != self && ptr[1] != self) {
-            translate_zero_call = TranslateZeroCall;
-        } else {
-            translate_zero_call = TranslateFastCall;
-        }
-
-        return self;
-    }, nullptr, &func);
-    K_ASSERT(status == napi_ok);
-
-    status = napi_call_function(env, self, func, 0, nullptr, &ret);
-    K_ASSERT(status == napi_ok);
-}
-
-bool InitAsyncBroker(Napi::Env env, InstanceData *instance)
-{
-    if (!instance->broker) {
-        if (napi_create_threadsafe_function(env, nullptr, nullptr,
-                                            Napi::String::New(env, "Koffi Async Callback Broker"),
-                                            0, 1, nullptr, nullptr, nullptr,
-                                            PerformAsyncRelay, &instance->broker) != napi_ok) {
-            LogError("Failed to create async callback broker");
-            return false;
-        }
-        napi_unref_threadsafe_function(env, instance->broker);
-    }
-
-    return true;
-}
-
-napi_value TranslateZeroCall(napi_env env, napi_callback_info info)
+static napi_value TranslateZeroCall(napi_env env, napi_callback_info info)
 {
     struct CallbackBundle {
         napi_env env;
@@ -1376,8 +1272,7 @@ napi_value TranslateFastCall(napi_env env, napi_callback_info info)
     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);
+    NAPI_OK(napi_get_cb_info(env, info, &count, args, nullptr, (void **)&func));
 
     if (count < (size_t)func->required_parameters) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, count);
@@ -1421,7 +1316,7 @@ static FORCE_INLINE napi_value TranslateNormalCall(napi_env env, const FunctionI
     return ret;
 }
 
-napi_value TranslateNormalCall(napi_env env, napi_callback_info info)
+static napi_value TranslateNormalCall(napi_env env, napi_callback_info info)
 {
     static_assert(MaxParameters >= 8);
 
@@ -1429,13 +1324,10 @@ napi_value TranslateNormalCall(napi_env env, napi_callback_info info)
     size_t count = 8;
     FunctionInfo *func;
 
-    napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, (void **)&func);
-    K_ASSERT(status == napi_ok);
+    NAPI_OK(napi_get_cb_info(env, info, &count, args, nullptr, (void **)&func));
 
     if (count > 8) {
-        napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, nullptr);
-        K_ASSERT(status == napi_ok);
-
+        NAPI_OK(napi_get_cb_info(env, info, &count, args, nullptr, nullptr));
         count = std::min(count, (size_t)MaxParameters);
     }
 
@@ -1474,7 +1366,7 @@ static FORCE_INLINE napi_value TranslateNormalCallDebugAsync(napi_env env, const
     return ret;
 }
 
-napi_value TranslateNormalCallDebugAsync(napi_env env, napi_callback_info info)
+static napi_value TranslateNormalCallDebugAsync(napi_env env, napi_callback_info info)
 {
     static_assert(MaxParameters >= 8);
 
@@ -1482,13 +1374,10 @@ napi_value TranslateNormalCallDebugAsync(napi_env env, napi_callback_info info)
     size_t count = 8;
     FunctionInfo *func;
 
-    napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, (void **)&func);
-    K_ASSERT(status == napi_ok);
+    NAPI_OK(napi_get_cb_info(env, info, &count, args, nullptr, (void **)&func));
 
     if (count > 8) {
-        napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, nullptr);
-        K_ASSERT(status == napi_ok);
-
+        NAPI_OK(napi_get_cb_info(env, info, &count, args, nullptr, nullptr));
         count = std::min(count, (size_t)MaxParameters);
     }
 
@@ -1517,7 +1406,7 @@ static napi_value TranslateVariadicCall(napi_env env, const FunctionInfo *func,
 
                 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);
+                    const TypeInfo *type = ResolveType(instance, args[i], &directions);
 
                     if (type != prev->parameters[j].type || directions != prev->parameters[j].directions) [[unlikely]] {
                         match = false;
@@ -1558,7 +1447,7 @@ static napi_value TranslateVariadicCall(napi_env env, const FunctionInfo *func,
         for (Size i = variadic->required_parameters; i < count; i += 2) {
             ParameterInfo param = {};
 
-            param.type = ResolveType(Napi::Value(env, args[i]), &param.directions);
+            param.type = ResolveType(instance, args[i], &param.directions);
 
             if (!param.type) [[unlikely]]
                 return Napi::Env(env).Null();
@@ -1599,7 +1488,7 @@ static napi_value TranslateVariadicCall(napi_env env, const FunctionInfo *func,
     return ret;
 }
 
-napi_value TranslateVariadicCall(napi_env env, napi_callback_info info)
+static napi_value TranslateVariadicCall(napi_env env, napi_callback_info info)
 {
     static_assert(MaxParameters >= 8);
 
@@ -1607,13 +1496,10 @@ napi_value TranslateVariadicCall(napi_env env, napi_callback_info info)
     size_t count = 8;
     FunctionInfo *func;
 
-    napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, (void **)&func);
-    K_ASSERT(status == napi_ok);
+    NAPI_OK(napi_get_cb_info(env, info, &count, args, nullptr, (void **)&func));
 
     if (count > 8) {
-        napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, nullptr);
-        K_ASSERT(status == napi_ok);
-
+        NAPI_OK(napi_get_cb_info(env, info, &count, args, nullptr, nullptr));
         count = std::min(count, (size_t)MaxParameters);
     }
 
@@ -1695,7 +1581,7 @@ void AsyncCall::OnError(const Napi::Error& err)
     callback.Call(self, K_LEN(args), args);
 }
 
-napi_value TranslateAsyncCall(napi_env env, napi_callback_info info)
+static napi_value TranslateAsyncCall(napi_env env, napi_callback_info info)
 {
     static_assert(MaxParameters >= 6);
 
@@ -1703,13 +1589,10 @@ napi_value TranslateAsyncCall(napi_env env, napi_callback_info info)
     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);
+    NAPI_OK(napi_get_cb_info(env, info, &count, args, nullptr, (void **)&func));
 
     if (count > 6) {
-        napi_status status = napi_get_cb_info(env, info, &count, args, nullptr, nullptr);
-        K_ASSERT(status == napi_ok);
-
+        NAPI_OK(napi_get_cb_info(env, info, &count, args, nullptr, nullptr));
         count = std::min(count, (size_t)MaxParameters);
     }
 
@@ -1740,6 +1623,215 @@ napi_value TranslateAsyncCall(napi_env env, napi_callback_info info)
     return Napi::Env(env).Undefined();
 }
 
+static bool DetectDeno(Napi::Env env)
+{
+    Napi::Value ret = env.RunScript("typeof Deno != 'undefined'");
+    Napi::Boolean b = ret.ToBoolean();
+
+    return b.Value();
+}
+
+static bool DetectBun(Napi::Env env)
+{
+    Napi::Value ret = env.RunScript("process.isBun");
+    Napi::Boolean b = ret.ToBoolean();
+
+    return b.Value();
+}
+
+void InitTranslateZeroCall(Napi::Env env)
+{
+    if (DetectDeno(env) || DetectBun(env)) {
+        translate_zero_call = TranslateFastCall;
+        return;
+    }
+
+    Napi::Object self = Napi::Object::New(env);
+
+    napi_value func;
+    napi_value ret;
+
+    auto cb = [](napi_env env, napi_callback_info info) {
+        napi_value self;
+        NAPI_OK(napi_get_cb_info(env, info, nullptr, nullptr, &self, nullptr));
+
+        napi_value *ptr = (napi_value *)info;
+
+        if (ptr[0] != self && ptr[1] != self) {
+            translate_zero_call = TranslateZeroCall;
+        } else {
+            translate_zero_call = TranslateFastCall;
+        }
+
+        return self;
+    };
+
+    NAPI_OK(napi_create_function(env, nullptr, 0, cb, nullptr, &func));
+    NAPI_OK(napi_call_function(env, self, func, 0, nullptr, &ret));
+}
+
+napi_value CallPointer(Napi::Env env, const FunctionInfo *proto, void *native, napi_value *args, Size count)
+{
+    if (proto->variadic) {
+        return TranslateVariadicCall(env, proto, native, args, count);
+    } else {
+        return TranslateNormalCall(env, proto, native, args, count);
+    }
+}
+
+static void PerformAsyncRelay(napi_env, napi_value, void *, void *udata)
+{
+    RelayContext *ctx = (RelayContext *)udata;
+    CallData *call = ctx->call;
+
+    call->Relay(ctx->idx, ctx->sp);
+    call->Finalize();
+
+    // We're done!
+    std::lock_guard<std::mutex> lock(ctx->mutex);
+    ctx->done = true;
+    ctx->cv.notify_one();
+}
+
+bool InitAsyncBroker(Napi::Env env, InstanceData *instance)
+{
+    if (!instance->broker) {
+        if (napi_create_threadsafe_function(env, nullptr, nullptr,
+                                            NewString(env, "Koffi Async Callback Broker"),
+                                            0, 1, nullptr, nullptr, nullptr,
+                                            PerformAsyncRelay, &instance->broker) != napi_ok) {
+            LogError("Failed to create async callback broker");
+            return false;
+        }
+
+        NAPI_OK(napi_unref_threadsafe_function(env, instance->broker));
+    }
+
+    return true;
+}
+
+void *GetTrampoline(int idx)
+{
+    return (void *)(TrampolineStart + TrampolineSize * idx);
+}
+
+static bool CanTypeAcceptCallbacks(const TypeInfo *type)
+{
+    if (type->primitive == PrimitiveKind::Pointer)
+        return true;
+    if (type->primitive == PrimitiveKind::Callback)
+        return true;
+
+    if (type->primitive == PrimitiveKind::Record ||
+            type->primitive == PrimitiveKind::Union) {
+        for (const RecordMember &member: type->members) {
+            if (CanTypeAcceptCallbacks(member.type))
+                return false;
+        }
+    }
+
+    return true;
+}
+
+static bool CanUseFastCall(const FunctionInfo *func)
+{
+    if (func->parameters.len > 6)
+        return false;
+
+    // Fast calls basically skip CallData::Finalize(), which handles output arguments
+    // and temporary callback trampolines. If the function does not use any
+    // output argument and cannot accept callbacks (so no pointer or callback arguments),
+    // we can skip finalization!
+
+    for (const ParameterInfo &param: func->parameters) {
+        if (param.directions & 2)
+            return false;
+        if (CanTypeAcceptCallbacks(param.type))
+            return false;
+    }
+
+    return true;
+}
+
+napi_value DescribeFunction(InstanceData *instance, const FunctionInfo *func)
+{
+    static const char *const DirectionNames[] = {
+        nullptr,
+        "Input",
+        "Output",
+        "Input/Output"
+    };
+
+    Napi::Env env = instance->env;
+
+    Napi::Object meta = Napi::Object::New(env);
+    Napi::Array arguments = Napi::Array::New(env, func->parameters.len);
+
+    meta.Set("name", NewString(env, func->name));
+    meta.Set("arguments", arguments);
+    meta.Set("result", WrapType(instance, func->ret.type));
+
+    for (Size i = 0; i < func->parameters.len; i++) {
+        const ParameterInfo &param = func->parameters[i];
+        Napi::Object obj = Napi::Object::New(env);
+
+        obj.Set("type", WrapType(instance, param.type));
+        obj.Set("direction", NewString(env, DirectionNames[param.directions]));
+
+        arguments.Set((uint32_t)i, obj);
+    }
+
+    meta.Freeze();
+
+    return meta;
+}
+
+static bool IsDebugAsyncEnabled()
+{
+    static bool debug = GetDebugFlag("DEBUG_ASYNC");
+    return debug;
+}
+
+napi_value WrapFunction(InstanceData *instance, const FunctionInfo *func)
+{
+    Napi::Env env = instance->env;
+
+    Napi::Function wrapper;
+    {
+        napi_value value;
+
+        if (func->variadic) {
+            NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateVariadicCall, (void *)func->Ref(), &value));
+        } else if (IsDebugAsyncEnabled()) {
+            NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateNormalCallDebugAsync, (void *)func->Ref(), &value));
+        } else if (!func->parameters.len) {
+            NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, translate_zero_call, (void *)func->Ref(), &value));
+        } else if (CanUseFastCall(func)) {
+            NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateFastCall, (void *)func->Ref(), &value));
+        } else {
+            NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateNormalCall, (void *)func->Ref(), &value));
+        }
+
+        wrapper = Napi::Function(env, value);
+        wrapper.AddFinalizer([](Napi::BasicEnv, FunctionInfo *func) { func->Unref(); }, (FunctionInfo *)func);
+    }
+
+    if (!func->variadic) {
+        napi_value value;
+        NAPI_OK(napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateAsyncCall, (void *)func->Ref(), &value));
+
+        Napi::Function async = Napi::Function(env, value);
+        async.AddFinalizer([](Napi::BasicEnv, FunctionInfo *func) { func->Unref(); }, (FunctionInfo *)func);
+
+        wrapper.Set("async", async);
+    }
+
+    napi_value meta = DescribeFunction(instance, func);
+    wrapper.Set("info", meta);
+
+    return wrapper;
+}
+
 static FORCE_INLINE bool CheckTrampolineStatus(TrampolineInfo *trampoline)
 {
     if (trampoline->state == 1) [[likely]]
@@ -1800,7 +1892,7 @@ extern "C" void RelayCallback(Size idx, uint8_t *sp)
         K_DEFER { call.Finalize(); };
 
         napi_handle_scope scope;
-        napi_open_handle_scope(env, &scope);
+        NAPI_OK(napi_open_handle_scope(env, &scope));
         K_DEFER { napi_close_handle_scope(env, scope); };
 
         call.Relay(idx, sp);
@@ -1839,39 +1931,164 @@ extern "C" void RelayDirect(CallData *call, Size idx, uint8_t *sp)
     // Relay the call
     {
         napi_handle_scope scope;
-        napi_open_handle_scope(call->env, &scope);
+        NAPI_OK(napi_open_handle_scope(call->env, &scope));
         K_DEFER { napi_close_handle_scope(call->env, scope); };
 
         call->Relay(idx, sp);
     }
 }
 
-napi_value CallPointer(napi_env env, const FunctionInfo *proto, void *native, napi_value *args, Size count)
+bool Encode(InstanceData *instance, uint8_t *origin, napi_value value, const TypeInfo *type)
 {
-    if (proto->variadic) {
-        return TranslateVariadicCall(env, proto, native, args, count);
-    } else {
-        return TranslateNormalCall(env, proto, native, args, count);
+    Napi::Env env = instance->env;
+
+    InstanceMemory mem = {};
+    CallData call(env, instance, &mem, nullptr);
+
+#define PUSH_INTEGER(CType) \
+        do { \
+            CType v; \
+            if (!TryNumber(env, value, &v)) [[unlikely]] { \
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
+                return false; \
+            } \
+             \
+            *(CType *)origin = v; \
+        } while (false)
+#define PUSH_INTEGER_SWAP(CType) \
+        do { \
+            CType v; \
+            if (!TryNumber(env, value, &v)) [[unlikely]] { \
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
+                return false; \
+            } \
+             \
+            *(CType *)origin = ReverseBytes(v); \
+        } while (false)
+
+    switch (type->primitive) {
+        case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
+
+        case PrimitiveKind::Bool: {
+            bool b;
+            napi_status status = napi_get_value_bool(env, value, &b);
+
+            if (status != napi_ok) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected boolean", GetValueType(instance, value));
+                return false;
+            }
+
+            *(bool *)origin = b;
+        } break;
+        case PrimitiveKind::Int8: { PUSH_INTEGER(int8_t); } break;
+        case PrimitiveKind::UInt8: { PUSH_INTEGER(uint8_t); } break;
+        case PrimitiveKind::Int16: { PUSH_INTEGER(int16_t); } break;
+        case PrimitiveKind::Int16S: { PUSH_INTEGER_SWAP(int16_t); } break;
+        case PrimitiveKind::UInt16: { PUSH_INTEGER(uint16_t); } break;
+        case PrimitiveKind::UInt16S: { PUSH_INTEGER_SWAP(uint16_t); } break;
+        case PrimitiveKind::Int32: { PUSH_INTEGER(int32_t); } break;
+        case PrimitiveKind::Int32S: { PUSH_INTEGER_SWAP(int32_t); } break;
+        case PrimitiveKind::UInt32: { PUSH_INTEGER(uint32_t); } break;
+        case PrimitiveKind::UInt32S: { PUSH_INTEGER_SWAP(uint32_t); } break;
+        case PrimitiveKind::Int64: { PUSH_INTEGER(int64_t); } break;
+        case PrimitiveKind::Int64S: { PUSH_INTEGER_SWAP(int64_t); } break;
+        case PrimitiveKind::UInt64: { PUSH_INTEGER(uint64_t); } break;
+        case PrimitiveKind::UInt64S: { PUSH_INTEGER_SWAP(uint64_t); } break;
+        case PrimitiveKind::String: {
+            const char *str;
+            if (!call.PushString(value, 1, &str)) [[unlikely]]
+                return false;
+            *(const char **)origin = str;
+        } break;
+        case PrimitiveKind::String16: {
+            const char16_t *str16;
+            if (!call.PushString16(value, 1, &str16)) [[unlikely]]
+                return false;
+            *(const char16_t **)origin = str16;
+        } break;
+        case PrimitiveKind::String32: {
+            const char32_t *str32;
+            if (!call.PushString32(value, 1, &str32)) [[unlikely]]
+                return false;
+            *(const char32_t **)origin = str32;
+        } break;
+        case PrimitiveKind::Pointer: {
+            void *ptr;
+            if (!call.PushPointer(value, type, 1, &ptr)) [[unlikely]]
+                return false;
+            *(void **)origin = ptr;
+        } break;
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
+            if (!call.PushObject(value, type, origin)) [[unlikely]]
+                return false;
+        } break;
+        case PrimitiveKind::Array: {
+            if (IsArray(env, value)) {
+                Napi::Array array = Napi::Array(env, value);
+                if (!call.PushNormalArray(array, type, type->size, origin))
+                    return false;
+            } else if (Span<uint8_t> buffer = {}; TryBuffer(env, value, &buffer)) {
+                call.PushBuffer(buffer, type, origin);
+            } else if (GetKindOf(env, value) == napi_string) {
+                if (!call.PushStringArray(value, type, origin))
+                    return false;
+            } else {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected array", GetValueType(instance, value));
+                return false;
+            }
+        } break;
+        case PrimitiveKind::Float32: {
+            float f;
+            if (!TryNumber(env, value, &f)) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                return false;
+            }
+
+            memcpy(origin, &f, 4);
+        } break;
+        case PrimitiveKind::Float64: {
+            double d;
+            if (!TryNumber(env, value, &d)) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                return false;
+            }
+
+            memcpy(origin, &d, 8);
+        } break;
+        case PrimitiveKind::Callback: {
+            void *ptr;
+            if (!TryPointer(env, value, &ptr)) [[unlikely]] {
+                if (GetKindOf(env, value) == napi_function) {
+                    ThrowError<Napi::Error>(env, "Cannot encode non-registered callback");
+                } else {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected %2", GetValueType(instance, value), type->name);
+                }
+                return false;
+            }
+
+            *(void **)origin = ptr;
+        } break;
+
+        case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
     }
-}
 
-void PerformAsyncRelay(napi_env, napi_value, void *, void *udata)
-{
-    RelayContext *ctx = (RelayContext *)udata;
-    CallData *call = ctx->call;
+#undef PUSH_INTEGER_SWAP
+#undef PUSH_INTEGER
 
-    call->Relay(ctx->idx, ctx->sp);
-    call->Finalize();
+    // Keep memory around if any was allocated
+    if (mem.allocator.IsUsed()) {
+        LinkedAllocator *copy = instance->encode_map.FindValue(origin, nullptr);
 
-    // We're done!
-    std::lock_guard<std::mutex> lock(ctx->mutex);
-    ctx->done = true;
-    ctx->cv.notify_one();
-}
+        if (!copy) {
+            copy = instance->encode_allocators.AppendDefault();
+            instance->encode_map.Set(origin, copy);
+        }
 
-void *GetTrampoline(int idx)
-{
-    return (void *)(TrampolineStart + TrampolineSize * idx);
+        std::swap(mem.allocator, *copy);
+    }
+
+    return true;
 }
 
 }