koffi 2.14.0 → 2.15.0

package/src/koffi/src/call.cc

@@ -1,32 +1,14 @@
-// Copyright (C) 2025  Niels Martignène <niels.martignene@protonmail.com>
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the “Software”), to deal in
-// the Software without restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
-// Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-
-#include "src/core/base/base.hh"
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
+
+#include "lib/native/base/base.hh"
 #include "call.hh"
 #include "ffi.hh"
 #include "util.hh"
 
 #include <napi.h>
 
-namespace RG {
+namespace K {
 
 struct RelayContext {
     CallData *call;
@@ -49,8 +31,8 @@ CallData::CallData(Napi::Env env, InstanceData *instance, InstanceMemory *mem)
     mem->generation += !mem->depth;
     mem->depth++;
 
-    RG_ASSERT(AlignUp(mem->stack.ptr, 16) == mem->stack.ptr);
-    RG_ASSERT(AlignUp(mem->stack.end(), 16) == mem->stack.end());
+    K_ASSERT(AlignUp(mem->stack.ptr, 16) == mem->stack.ptr);
+    K_ASSERT(AlignUp(mem->stack.end(), 16) == mem->stack.end());
 }
 
 CallData::~CallData()
@@ -77,8 +59,8 @@ void CallData::Dispose()
             int16_t idx = used_trampolines[i];
             TrampolineInfo *trampoline = &shared.trampolines[idx];
 
-            RG_ASSERT(trampoline->instance == instance);
-            RG_ASSERT(!trampoline->func.IsEmpty());
+            K_ASSERT(trampoline->instance == instance);
+            K_ASSERT(!trampoline->func.IsEmpty());
 
             trampoline->instance = nullptr;
             trampoline->func.Reset();
@@ -88,15 +70,7 @@ void CallData::Dispose()
         }
     }
 
-    instance->temporaries -= mem->temporary;
-
-    if (!--mem->depth) {
-        mem->busy = false;
-
-        if (mem->temporary) {
-            delete mem;
-        }
-    }
+    ReleaseMemory(instance, mem);
 
     instance = nullptr;
 }
@@ -147,6 +121,7 @@ void CallData::RelayAsync(napi_env, napi_value, void *, void *udata)
 
 bool CallData::PushString(Napi::Value value, int directions, const char **out_str)
 {
+    // Fast path
     if (value.IsString()) {
         if (directions & 2) [[unlikely]] {
             ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
@@ -155,62 +130,41 @@ bool CallData::PushString(Napi::Value value, int directions, const char **out_st
 
         PushStringValue(value, out_str);
         return true;
-    } else if (IsNullOrUndefined(value)) {
-        *out_str = nullptr;
-        return true;
-    } else if (value.IsArray()) {
-        Napi::Array array = value.As<Napi::Array>();
+    }
 
-        if (!(directions & 2)) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
-            return false;
-        }
-        if (array.Length() != 1) [[unlikely]] {
+    return PushPointer(value, instance->str_type, directions, (void **)out_str);
+}
+
+bool CallData::PushString16(Napi::Value value, int directions, const char16_t **out_str16)
+{
+    // Fast path
+    if (value.IsString()) {
+        if (directions & 2) [[unlikely]] {
             ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
             return false;
         }
 
-        value = array[0u];
+        PushString16Value(value, out_str16);
+        return true;
+    }
 
-        if (!value.IsString()) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, array[0u]));
-            return false;
-        }
+    return PushPointer(value, instance->str16_type, directions, (void **)out_str16);
+}
 
-        Size len = PushStringValue(value, out_str);
-        if (len < 0) [[unlikely]]
+bool CallData::PushString32(Napi::Value value, int directions, const char32_t **out_str32)
+{
+    // Fast path
+    if (value.IsString()) {
+        if (directions & 2) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
             return false;
-
-        // Create array type
-        TypeInfo *type;
-        {
-            type = AllocateOne<TypeInfo>(&call_alloc, (int)AllocFlag::Zero);
-
-            type->name = "<temporary>";
-
-            type->primitive = PrimitiveKind::Array;
-            type->align = 1;
-            type->size = (int32_t)len;
-            type->ref.type = instance->char_type;
-            type->hint = ArrayHint::String;
-        }
-
-        // Prepare output argument
-        {
-            OutArgument *out = out_arguments.AppendDefault();
-
-            napi_status status = napi_create_reference(env, array, 1, &out->ref);
-            RG_ASSERT(status == napi_ok);
-
-            out->kind = OutArgument::Kind::Array;
-            out->ptr = (const uint8_t *)*out_str;
-            out->type = type;
         }
 
+        PushString32Value(value, out_str32);
         return true;
-    } else {
-        return PushPointer(value, instance->str_type, directions, (void **)out_str);
     }
+
+    return PushPointer(value, instance->str32_type, directions, (void **)out_str32);
 }
 
 Size CallData::PushStringValue(Napi::Value value, const char **out_str)
@@ -223,7 +177,7 @@ Size CallData::PushStringValue(Napi::Value value, const char **out_str)
     buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32));
 
     status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
-    RG_ASSERT(status == napi_ok);
+    K_ASSERT(status == napi_ok);
 
     len++;
 
@@ -232,13 +186,13 @@ Size CallData::PushStringValue(Napi::Value value, const char **out_str)
         mem->heap.len -= (Size)len;
     } else {
         status = napi_get_value_string_utf8(env, value, nullptr, 0, &len);
-        RG_ASSERT(status == napi_ok);
+        K_ASSERT(status == napi_ok);
 
         len++;
         buf = AllocateSpan<char>(&call_alloc, (Size)len);
 
         status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
-        RG_ASSERT(status == napi_ok);
+        K_ASSERT(status == napi_ok);
 
         len++;
     }
@@ -247,74 +201,6 @@ Size CallData::PushStringValue(Napi::Value value, const char **out_str)
     return (Size)len;
 }
 
-bool CallData::PushString16(Napi::Value value, int directions, const char16_t **out_str16)
-{
-    if (value.IsString()) {
-        if (directions & 2) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
-            return false;
-        }
-
-        PushString16Value(value, out_str16);
-        return true;
-    } else if (IsNullOrUndefined(value)) {
-        *out_str16 = nullptr;
-        return true;
-    }  else if (value.IsArray()) {
-        Napi::Array array = value.As<Napi::Array>();
-
-        if (!(directions & 2)) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
-            return false;
-        }
-        if (array.Length() != 1) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
-            return false;
-        }
-
-        value = array[0u];
-
-        if (!value.IsString()) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, array[0u]));
-            return false;
-        }
-
-        Size len = PushString16Value(value, out_str16);
-        if (len < 0) [[unlikely]]
-            return false;
-
-        // Create array type
-        TypeInfo *type;
-        {
-            type = AllocateOne<TypeInfo>(&call_alloc, (int)AllocFlag::Zero);
-
-            type->name = "<temporary>";
-
-            type->primitive = PrimitiveKind::Array;
-            type->align = 2;
-            type->size = (int32_t)(len * 2);
-            type->ref.type = instance->char16_type;
-            type->hint = ArrayHint::String;
-        }
-
-        // Prepare output argument
-        {
-            OutArgument *out = out_arguments.AppendDefault();
-
-            napi_status status = napi_create_reference(env, array, 1, &out->ref);
-            RG_ASSERT(status == napi_ok);
-
-            out->kind = OutArgument::Kind::Array;
-            out->ptr = (const uint8_t *)*out_str16;
-            out->type = type;
-        }
-
-        return true;
-    } else {
-        return PushPointer(value, instance->str16_type, directions, (void **)out_str16);
-    }
-}
-
 Size CallData::PushString16Value(Napi::Value value, const char16_t **out_str16)
 {
     Span<char16_t> buf;
@@ -326,7 +212,7 @@ Size CallData::PushString16Value(Napi::Value value, const char16_t **out_str16)
     buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32)) / 2;
 
     status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
-    RG_ASSERT(status == napi_ok);
+    K_ASSERT(status == napi_ok);
 
     len++;
 
@@ -335,13 +221,13 @@ Size CallData::PushString16Value(Napi::Value value, const char16_t **out_str16)
         mem->heap.len -= (Size)len * 2;
     } else {
         status = napi_get_value_string_utf16(env, value, nullptr, 0, &len);
-        RG_ASSERT(status == napi_ok);
+        K_ASSERT(status == napi_ok);
 
         len++;
         buf = AllocateSpan<char16_t>(&call_alloc, (Size)len);
 
         status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
-        RG_ASSERT(status == napi_ok);
+        K_ASSERT(status == napi_ok);
 
         len++;
     }
@@ -350,76 +236,10 @@ Size CallData::PushString16Value(Napi::Value value, const char16_t **out_str16)
     return (Size)len;
 }
 
-bool CallData::PushString32(Napi::Value value, int directions, const char32_t **out_str32)
-{
-    if (value.IsString()) {
-        if (directions & 2) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
-            return false;
-        }
-
-        PushString32Value(value, out_str32);
-        return true;
-    } else if (IsNullOrUndefined(value)) {
-        *out_str32 = nullptr;
-        return true;
-    }  else if (value.IsArray()) {
-        Napi::Array array = value.As<Napi::Array>();
-
-        if (!(directions & 2)) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
-            return false;
-        }
-        if (array.Length() != 1) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
-            return false;
-        }
-
-        value = array[0u];
-
-        if (!value.IsString()) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, array[0u]));
-            return false;
-        }
-
-        Size len = PushString32Value(value, out_str32);
-        if (len < 0) [[unlikely]]
-            return false;
-
-        // Create array type
-        TypeInfo *type;
-        {
-            type = AllocateOne<TypeInfo>(&call_alloc, (int)AllocFlag::Zero);
-
-            type->name = "<temporary>";
-
-            type->primitive = PrimitiveKind::Array;
-            type->align = 4;
-            type->size = (int32_t)(len * 4);
-            type->ref.type = instance->char32_type;
-            type->hint = ArrayHint::String;
-        }
-
-        // Prepare output argument
-        {
-            OutArgument *out = out_arguments.AppendDefault();
-
-            napi_status status = napi_create_reference(env, array, 1, &out->ref);
-            RG_ASSERT(status == napi_ok);
-
-            out->kind = OutArgument::Kind::Array;
-            out->ptr = (const uint8_t *)*out_str32;
-            out->type = type;
-        }
-
-        return true;
-    } else {
-        return PushPointer(value, instance->str32_type, directions, (void **)out_str32);
-    }
-}
-
 Size CallData::PushString32Value(Napi::Value value, const char32_t **out_str32)
 {
+    static const char32_t ReplacementChar = 0x0000FFFD;
+
     Span<char32_t> buf;
 
     Span<const char16_t> buf16;
@@ -443,15 +263,19 @@ Size CallData::PushString32Value(Napi::Value value, const char32_t **out_str32)
         char32_t uc = buf16[i];
 
         if (uc >= 0xD800 && uc <= 0xDBFF) {
-            char16_t uc2 = buf16.ptr[++i];
+            if (++i < buf16.len) {
+                char16_t uc2 = buf16.ptr[i];
 
-            if (uc2 >= 0xDC00 && uc2 <= 0xDFFF) {
-                uc = ((uc - 0xD800) << 10) + (uc2 - 0xDC00) + 0x10000u;
+                if (uc2 >= 0xDC00 && uc2 <= 0xDFFF) [[likely]] {
+                    uc = ((uc - 0xD800) << 10) + (uc2 - 0xDC00) + 0x10000u;
+                } else {
+                    uc = ReplacementChar;
+                }
             } else {
-                uc = '?';
+                uc = ReplacementChar;
             }
-        } else if (uc >= 0xDC00 && uc <= 0xDFFF) {
-            uc = '?';
+        } else if (uc >= 0xDC00 && uc <= 0xDFFF) [[unlikely]] {
+            uc = ReplacementChar;
         }
 
         buf[j++] = uc;
@@ -463,8 +287,8 @@ Size CallData::PushString32Value(Napi::Value value, const char32_t **out_str32)
 
 bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin)
 {
-    RG_ASSERT(IsObject(obj));
-    RG_ASSERT(type->primitive == PrimitiveKind::Record ||
+    K_ASSERT(IsObject(obj));
+    K_ASSERT(type->primitive == PrimitiveKind::Record ||
               type->primitive == PrimitiveKind::Union);
 
     Span<const RecordMember> members = {};
@@ -472,7 +296,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
     if (type->primitive == PrimitiveKind::Record) {
         members = type->members;
     } else if (type->primitive == PrimitiveKind::Union) {
-        if (CheckValueTag(instance, obj, &MagicUnionMarker)) {
+        if (CheckValueTag(obj, &MagicUnionMarker)) {
             MagicUnion *u = MagicUnion::Unwrap(obj);
             const uint8_t *raw = u->GetRaw();
 
@@ -514,7 +338,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             }
         }
     } else {
-        RG_UNREACHABLE();
+        K_UNREACHABLE();
     }
 
     MemSet(origin, 0, type->size);
@@ -536,7 +360,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
         uint8_t *dest = origin + member.offset;
 
         switch (member.type->primitive) {
-            case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+            case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
 
             case PrimitiveKind::Bool: {
                 if (!value.IsBoolean()) [[unlikely]] {
@@ -754,7 +578,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                 *(void **)dest = ptr;
             } break;
 
-            case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
+            case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
         }
     }
 
@@ -763,7 +587,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
 
 bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size size, uint8_t *origin)
 {
-    RG_ASSERT(array.IsArray());
+    K_ASSERT(array.IsArray());
 
     const TypeInfo *ref = type->ref.type;
     Size len = (Size)array.Length();
@@ -992,7 +816,7 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
             }
         } break;
 
-        case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
+        case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
     }
 
 #undef PUSH_ARRAY
@@ -1011,7 +835,7 @@ void CallData::PushBuffer(Span<const uint8_t> buffer, const TypeInfo *type, uint
 #define SWAP(CType) \
         do { \
             CType *data = (CType *)origin; \
-            Size len = buffer.len / RG_SIZE(CType); \
+            Size len = buffer.len / K_SIZE(CType); \
              \
             for (Size i = 0; i < len; i++) { \
                 data[i] = ReverseBytes(data[i]); \
@@ -1035,19 +859,19 @@ void CallData::PushBuffer(Span<const uint8_t> buffer, const TypeInfo *type, uint
 
 bool CallData::PushStringArray(Napi::Value obj, const TypeInfo *type, uint8_t *origin)
 {
-    RG_ASSERT(obj.IsString());
-    RG_ASSERT(type->primitive == PrimitiveKind::Array);
+    K_ASSERT(obj.IsString());
+    K_ASSERT(type->primitive == PrimitiveKind::Array);
 
     size_t encoded = 0;
 
     switch (type->ref.type->primitive) {
         case PrimitiveKind::Int8: {
             napi_status status = napi_get_value_string_utf8(env, obj, (char *)origin, type->size, &encoded);
-            RG_ASSERT(status == napi_ok);
+            K_ASSERT(status == napi_ok);
         } break;
         case PrimitiveKind::Int16: {
             napi_status status = napi_get_value_string_utf16(env, obj, (char16_t *)origin, type->size / 2, &encoded);
-            RG_ASSERT(status == napi_ok);
+            K_ASSERT(status == napi_ok);
 
             encoded *= 2;
         } break;
@@ -1065,7 +889,7 @@ bool CallData::PushStringArray(Napi::Value obj, const TypeInfo *type, uint8_t *o
 
 bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directions, void **out_ptr)
 {
-    if (CheckValueTag(instance, value, &CastMarker)) {
+    if (CheckValueTag(value, &CastMarker)) {
         Napi::External<ValueCast> external = value.As<Napi::External<ValueCast>>();
         ValueCast *cast = external.Data();
 
@@ -1073,6 +897,8 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
         type = cast->type;
     }
 
+    const TypeInfo *ref = type->ref.type;
+
     switch (value.Type()) {
         case napi_undefined:
         case napi_null: {
@@ -1081,14 +907,14 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
         } break;
 
         case napi_external: {
-            RG_ASSERT(type->primitive == PrimitiveKind::Pointer ||
+            K_ASSERT(type->primitive == PrimitiveKind::Pointer ||
                       type->primitive == PrimitiveKind::String ||
                       type->primitive == PrimitiveKind::String16 ||
                       type->primitive == PrimitiveKind::String32);
 
-            if (!CheckValueTag(instance, value, type->ref.marker) &&
-                    !CheckValueTag(instance, value, instance->void_type) &&
-                    type->ref.type != instance->void_type) [[unlikely]]
+            if (!CheckValueTag(value, type->ref.marker) &&
+                    !CheckValueTag(value, instance->void_type) &&
+                    ref != instance->void_type) [[unlikely]]
                 goto unexpected;
 
             *out_ptr = value.As<Napi::External<uint8_t>>().Data();
@@ -1103,29 +929,29 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
 
             if (value.IsArray()) {
                 Napi::Array array = value.As<Napi::Array>();
-                Size len = PushIndirectString(array, type->ref.type, &ptr);
+                Size len = PushIndirectString(array, ref, &ptr);
 
                 if (len >= 0) {
-                    if (!type->ref.type->size && type->ref.type != instance->void_type) [[unlikely]] {
+                    if (!ref->size && ref != instance->void_type) [[unlikely]] {
                         ThrowError<Napi::TypeError>(env, "Cannot pass [string] value to %1", type->name);
                         return false;
                     }
 
-                    switch (type->ref.type->size) {
+                    switch (ref->size) {
                         default: { out_kind = OutArgument::Kind::String; } break;
                         case 2: { out_kind = OutArgument::Kind::String16; } break;
                         case 4: { out_kind = OutArgument::Kind::String32; } break;
                     }
                     out_max_len = len;
                 } else {
-                    if (!type->ref.type->size) [[unlikely]] {
+                    if (!ref->size) [[unlikely]] {
                         ThrowError<Napi::TypeError>(env, "Cannot pass %1 value to %2, use koffi.as()",
-                                                    type->ref.type != instance->void_type ? "opaque" : "ambiguous", type->name);
+                                                    ref != instance->void_type ? "opaque" : "ambiguous", type->name);
                         return false;
                     }
 
                     Size len = (Size)array.Length();
-                    Size size = len * type->ref.type->size;
+                    Size size = len * ref->size;
 
                     ptr = AllocHeap(size, 16);
 
@@ -1146,24 +972,24 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                 directions = 1;
 
                 out_kind = OutArgument::Kind::Buffer;
-            } else if (type->ref.type->primitive == PrimitiveKind::Record ||
-                       type->ref.type->primitive == PrimitiveKind::Union) [[likely]] {
+            } else if (ref->primitive == PrimitiveKind::Record ||
+                       ref->primitive == PrimitiveKind::Union) [[likely]] {
                 Napi::Object obj = value.As<Napi::Object>();
-                RG_ASSERT(IsObject(value));
+                K_ASSERT(IsObject(value));
 
-                ptr = AllocHeap(type->ref.type->size, 16);
+                ptr = AllocHeap(ref->size, 16);
 
-                if (type->ref.type->primitive == PrimitiveKind::Union &&
-                        (directions & 2) && !CheckValueTag(instance, obj, &MagicUnionMarker)) [[unlikely]] {
+                if (ref->primitive == PrimitiveKind::Union &&
+                        (directions & 2) && !CheckValueTag(obj, &MagicUnionMarker)) [[unlikely]] {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected union value", GetValueType(instance, obj));
                     return false;
                 }
 
                 if (directions & 1) {
-                    if (!PushObject(obj, type->ref.type, ptr))
+                    if (!PushObject(obj, ref, ptr))
                         return false;
                 } else {
-                    MemSet(ptr, 0, type->size);
+                    MemSet(ptr, 0, ref->size);
                 }
 
                 out_kind = OutArgument::Kind::Object;
@@ -1175,11 +1001,11 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                 OutArgument *out = out_arguments.AppendDefault();
 
                 napi_status status = napi_create_reference(env, value, 1, &out->ref);
-                RG_ASSERT(status == napi_ok);
+                K_ASSERT(status == napi_ok);
 
                 out->kind = out_kind;
                 out->ptr = ptr;
-                out->type = type->ref.type;
+                out->type = ref;
                 out->max_len = out_max_len;
             }
 
@@ -1188,21 +1014,21 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
         } break;
 
         case napi_string: {
-            RG_ASSERT(type->primitive == PrimitiveKind::Pointer);
+            K_ASSERT(type->primitive == PrimitiveKind::Pointer);
 
             if (directions & 2) [[unlikely]]
                 goto unexpected;
 
-            if (type->ref.type == instance->void_type) {
+            if (ref == instance->void_type) {
                 PushStringValue(value, (const char **)out_ptr);
                 return true;
-            } else if (type->ref.type->primitive == PrimitiveKind::Int8) {
+            } else if (ref->primitive == PrimitiveKind::Int8) {
                 PushStringValue(value, (const char **)out_ptr);
                 return true;
-            } else if (type->ref.type->primitive == PrimitiveKind::Int16) {
+            } else if (ref->primitive == PrimitiveKind::Int16) {
                 PushString16Value(value, (const char16_t **)out_ptr);
                 return true;
-            } else if (type->ref.type->primitive == PrimitiveKind::Int32) {
+            } else if (ref->primitive == PrimitiveKind::Int32) {
                 PushString32Value(value, (const char32_t **)out_ptr);
                 return true;
             } else {
@@ -1262,9 +1088,9 @@ bool CallData::PushCallback(Napi::Value value, const TypeInfo *type, void **out_
             return false;
 
         *out_ptr = ptr;
-    } else if (CheckValueTag(instance, value, type->ref.marker)) {
+    } else if (CheckValueTag(value, type->ref.marker)) {
         *out_ptr = value.As<Napi::External<void>>().Data();
-    } else if (CheckValueTag(instance, value, &CastMarker)) {
+    } else if (CheckValueTag(value, &CastMarker)) {
         Napi::External<ValueCast> external = value.As<Napi::External<ValueCast>>();
         ValueCast *cast = external.Data();
 
@@ -1324,7 +1150,7 @@ void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func
             return env.Null();
         }
         if (!used_trampolines.Available()) [[unlikely]] {
-            ThrowError<Napi::Error>(env, "This call uses too many temporary callbacks (max = %1)", RG_LEN(used_trampolines.data));
+            ThrowError<Napi::Error>(env, "This call uses too many temporary callbacks (max = %1)", K_LEN(used_trampolines.data));
             return env.Null();
         }
 
@@ -1413,7 +1239,7 @@ static inline Napi::Value GetReferenceValue(Napi::Env env, napi_ref ref)
     napi_value value;
 
     napi_status status = napi_get_reference_value(env, ref, &value);
-    RG_ASSERT(status == napi_ok);
+    K_ASSERT(status == napi_ok);
 
     return Napi::Value(env, value);
 }
@@ -1422,18 +1248,18 @@ void CallData::PopOutArguments()
 {
     for (const OutArgument &out: out_arguments) {
         Napi::Value value = GetReferenceValue(env, out.ref);
-        RG_ASSERT(!value.IsEmpty());
+        K_ASSERT(!value.IsEmpty());
 
         switch (out.kind) {
             case OutArgument::Kind::Array: {
-                RG_ASSERT(value.IsArray());
+                K_ASSERT(value.IsArray());
 
                 Napi::Array array(env, value);
                 DecodeNormalArray(array, out.ptr, out.type);
             } break;
 
             case OutArgument::Kind::Buffer: {
-                RG_ASSERT(IsRawBuffer(value));
+                K_ASSERT(IsRawBuffer(value));
 
                 Span<uint8_t> buffer = GetRawBuffer(value);
                 DecodeBuffer(buffer, out.ptr, out.type);
@@ -1442,8 +1268,8 @@ void CallData::PopOutArguments()
             case OutArgument::Kind::String: {
                 Napi::Array array(env, value);
 
-                RG_ASSERT(array.IsArray());
-                RG_ASSERT(array.Length() == 1);
+                K_ASSERT(array.IsArray());
+                K_ASSERT(array.Length() == 1);
 
                 Size len = strnlen((const char *)out.ptr, out.max_len);
                 Napi::String str = Napi::String::New(env, (const char *)out.ptr, len);
@@ -1454,8 +1280,8 @@ void CallData::PopOutArguments()
             case OutArgument::Kind::String16: {
                 Napi::Array array(env, value);
 
-                RG_ASSERT(array.IsArray());
-                RG_ASSERT(array.Length() == 1);
+                K_ASSERT(array.IsArray());
+                K_ASSERT(array.Length() == 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);
@@ -1466,8 +1292,8 @@ void CallData::PopOutArguments()
             case OutArgument::Kind::String32: {
                 Napi::Array array(env, value);
 
-                RG_ASSERT(array.IsArray());
-                RG_ASSERT(array.Length() == 1);
+                K_ASSERT(array.IsArray());
+                K_ASSERT(array.Length() == 1);
 
                 Size len = NullTerminatedLength((const char32_t *)out.ptr, out.max_len);
                 Napi::String str = MakeStringFromUTF32(env, (const char32_t *)out.ptr, len);
@@ -1478,7 +1304,7 @@ void CallData::PopOutArguments()
             case OutArgument::Kind::Object: {
                 Napi::Object obj = value.As<Napi::Object>();
 
-                if (CheckValueTag(instance, value, &MagicUnionMarker)) {
+                if (CheckValueTag(value, &MagicUnionMarker)) {
                     MagicUnion *u = MagicUnion::Unwrap(obj);
                     u->SetRaw(out.ptr);
                 } else {