koffi 3.0.1 → 3.0.2

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"
@@ -71,15 +72,6 @@ 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);
@@ -113,7 +105,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 {
@@ -183,7 +175,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 +190,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,7 +249,6 @@ 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;
@@ -266,7 +257,7 @@ Size CallData::PushStringValue(napi_value value, const char **out_str)
     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;
@@ -652,7 +637,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 +729,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;
@@ -770,17 +750,17 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
         } 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 +794,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 +867,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 +902,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 +998,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;
@@ -1062,8 +1030,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 = OutArgument::Kind::Object;
             out->ptr = (const uint8_t *)ptr;
@@ -1107,7 +1074,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 +1099,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 +1115,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 +1159,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);
 
@@ -1305,13 +1272,12 @@ void InitTranslateZeroCall(Napi::Env env)
 
     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) {
+    auto cb = [](napi_env env, napi_callback_info info) {
         napi_value self;
-        napi_get_cb_info(env, info, nullptr, nullptr, &self, nullptr);
+        NAPI_OK(napi_get_cb_info(env, info, nullptr, nullptr, &self, nullptr));
 
         napi_value *ptr = (napi_value *)info;
 
@@ -1322,11 +1288,10 @@ void InitTranslateZeroCall(Napi::Env env)
         }
 
         return self;
-    }, nullptr, &func);
-    K_ASSERT(status == napi_ok);
+    };
 
-    status = napi_call_function(env, self, func, 0, nullptr, &ret);
-    K_ASSERT(status == napi_ok);
+    NAPI_OK(napi_create_function(env, nullptr, 0, cb, nullptr, &func));
+    NAPI_OK(napi_call_function(env, self, func, 0, nullptr, &ret));
 }
 
 bool InitAsyncBroker(Napi::Env env, InstanceData *instance)
@@ -1339,7 +1304,8 @@ bool InitAsyncBroker(Napi::Env env, InstanceData *instance)
             LogError("Failed to create async callback broker");
             return false;
         }
-        napi_unref_threadsafe_function(env, instance->broker);
+
+        NAPI_OK(napi_unref_threadsafe_function(env, instance->broker));
     }
 
     return true;
@@ -1376,8 +1342,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);
@@ -1429,13 +1394,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);
     }
 
@@ -1482,13 +1444,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 +1476,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 +1517,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();
@@ -1607,13 +1566,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);
     }
 
@@ -1703,13 +1659,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);
     }
 
@@ -1800,7 +1753,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,7 +1792,7 @@ 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);
@@ -1874,4 +1827,162 @@ void *GetTrampoline(int idx)
     return (void *)(TrampolineStart + TrampolineSize * idx);
 }
 
+bool Encode(InstanceData *instance, uint8_t *origin, napi_value value, const TypeInfo *type)
+{
+    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 (!IsObject(env, value)) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
+                return false;
+            }
+
+            if (!call.PushObject(value, type, origin))
+                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;
+    }
+
+#undef PUSH_INTEGER_SWAP
+#undef PUSH_INTEGER
+
+    // Keep memory around if any was allocated
+    if (mem.allocator.IsUsed()) {
+        LinkedAllocator *copy = instance->encode_map.FindValue(origin, nullptr);
+
+        if (!copy) {
+            copy = instance->encode_allocators.AppendDefault();
+            instance->encode_map.Set(origin, copy);
+        }
+
+        std::swap(mem.allocator, *copy);
+    }
+
+    return true;
+}
+
 }

package/src/koffi/src/call.hh

@@ -21,7 +21,6 @@ struct alignas(8) CallData {
     struct OutArgument {
         enum class Kind {
             Array,
-            Buffer,
             String,
             String16,
             String32,
@@ -180,4 +179,6 @@ void PerformAsyncRelay(napi_env env, napi_value callback, void *ctx, void *udata
 
 void *GetTrampoline(int idx);
 
+bool Encode(InstanceData *instance, uint8_t *ptr, napi_value value, const TypeInfo *type);
+
 }