koffi 2.14.0 → 2.15.0

package/src/koffi/src/util.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 {
 
 // Value does not matter, the tag system uses memory addresses
 const napi_type_tag TypeInfoMarker = { 0x1cc449675b294374, 0xbb13a50e97dcb017 };
@@ -35,10 +17,10 @@ const napi_type_tag MagicUnionMarker = { 0x5eaf2245526a4c7d, 0x8c86c9ee2b96ffc8
 
 Napi::Function MagicUnion::InitClass(Napi::Env env, const TypeInfo *type)
 {
-    RG_ASSERT(type->primitive == PrimitiveKind::Union);
+    K_ASSERT(type->primitive == PrimitiveKind::Union);
 
     // node-addon-api wants std::vector
-    std::vector<Napi::ClassPropertyDescriptor<MagicUnion>> properties; 
+    std::vector<Napi::ClassPropertyDescriptor<MagicUnion>> properties;
     properties.reserve(type->members.len);
 
     for (Size i = 0; i < type->members.len; i++) {
@@ -96,7 +78,7 @@ Napi::Value MagicUnion::Getter(const Napi::CallbackInfo &info)
         active_idx = idx;
     }
 
-    RG_ASSERT(!value.IsEmpty());
+    K_ASSERT(!value.IsEmpty());
     return value;
 }
 
@@ -187,7 +169,7 @@ const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
 
             // Cache for quick future access
             bool inserted;
-            auto bucket = instance->types_map.TrySetDefault(remain.ptr, &inserted);
+            auto bucket = instance->types_map.InsertOrGetDefault(remain.ptr, &inserted);
 
             if (inserted) {
                 bucket->key = DuplicateString(remain, &instance->str_alloc).ptr;
@@ -198,12 +180,12 @@ const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
         }
 
         return type;
-    } else if (CheckValueTag(instance, value, &TypeInfoMarker)) {
+    } else if (CheckValueTag(value, &TypeInfoMarker)) {
         Napi::External<TypeInfo> external = value.As<Napi::External<TypeInfo>>();
         const TypeInfo *raw = external.Data();
 
         const TypeInfo *type = AlignDown(raw, 4);
-        RG_ASSERT(type);
+        K_ASSERT(type);
 
         if (out_directions) {
             Size delta = (uint8_t *)raw - (uint8_t *)type;
@@ -343,7 +325,7 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str)
 
             TypeInfo *copy = instance->types.AppendDefault();
 
-            memcpy((void *)copy, (const void *)type, RG_SIZE(*type));
+            memcpy((void *)copy, (const void *)type, K_SIZE(*type));
             copy->name = Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.count).ptr;
             copy->members.allocator = GetNullAllocator();
 
@@ -373,12 +355,12 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str)
             }
 
             type = MakeArrayType(instance, type, len);
-            RG_ASSERT(type);
+            K_ASSERT(type);
         } else {
-            RG_ASSERT(!len);
+            K_ASSERT(!len);
 
             type = MakePointerType(instance, type);
-            RG_ASSERT(type);
+            K_ASSERT(type);
         }
     }
 
@@ -392,14 +374,14 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str)
 
 TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count)
 {
-    RG_ASSERT(count >= 1);
+    K_ASSERT(count >= 1);
 
     for (int i = 0; i < count; i++) {
         char name_buf[256];
         Fmt(name_buf, "%1%2*", ref->name, EndsWith(ref->name, "*") ? "" : " ");
 
         bool inserted;
-        auto bucket = instance->types_map.TrySetDefault(name_buf, &inserted);
+        auto bucket = instance->types_map.InsertOrGetDefault(name_buf, &inserted);
 
         if (inserted) {
             TypeInfo *type = instance->types.AppendDefault();
@@ -408,14 +390,14 @@ TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count
 
             if (ref->primitive != PrimitiveKind::Prototype) {
                 type->primitive = PrimitiveKind::Pointer;
-                type->size = RG_SIZE(void *);
-                type->align = RG_SIZE(void *);
+                type->size = K_SIZE(void *);
+                type->align = K_SIZE(void *);
                 type->ref.type = ref;
                 type->hint = (ref->flags & (int)TypeFlag::HasTypedArray) ? ArrayHint::Typed : ArrayHint::Array;
             } else {
                 type->primitive = PrimitiveKind::Callback;
-                type->size = RG_SIZE(void *);
-                type->align = RG_SIZE(void *);
+                type->size = K_SIZE(void *);
+                type->align = K_SIZE(void *);
                 type->ref.proto = ref->ref.proto;
             }
 
@@ -431,8 +413,8 @@ TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count
 
 static TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint, bool insert)
 {
-    RG_ASSERT(len >= 0);
-    RG_ASSERT(len <= instance->config.max_type_size / ref->size);
+    K_ASSERT(len >= 0);
+    K_ASSERT(len <= instance->config.max_type_size / ref->size);
 
     TypeInfo *type = instance->types.AppendDefault();
 
@@ -446,7 +428,7 @@ static TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size
 
     if (insert) {
         bool inserted;
-        type = (TypeInfo *)*instance->types_map.TrySet(type->name, type, &inserted);
+        type = (TypeInfo *)*instance->types_map.InsertOrGet(type->name, type, &inserted);
         instance->types.RemoveLast(!inserted);
     }
 
@@ -473,10 +455,10 @@ TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, A
     return MakeArrayType(instance, ref, len, hint, false);
 }
 
-Napi::External<TypeInfo> WrapType(Napi::Env env, InstanceData *instance, const TypeInfo *type)
+Napi::External<TypeInfo> WrapType(Napi::Env env, const TypeInfo *type)
 {
     Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
-    SetValueTag(instance, external, &TypeInfoMarker);
+    SetValueTag(external, &TypeInfoMarker);
 
     return external;
 }
@@ -540,17 +522,17 @@ bool CanStoreType(const TypeInfo *type)
 
 const char *GetValueType(const InstanceData *instance, Napi::Value value)
 {
-    if (CheckValueTag(instance, value, &CastMarker)) {
+    if (CheckValueTag(value, &CastMarker)) {
         Napi::External<ValueCast> external = value.As<Napi::External<ValueCast>>();
         ValueCast *cast = external.Data();
 
         return cast->type->name;
     }
 
-    if (CheckValueTag(instance, value, &TypeInfoMarker))
+    if (CheckValueTag(value, &TypeInfoMarker))
         return "Type";
     for (const TypeInfo &type: instance->types) {
-        if (type.ref.marker && CheckValueTag(instance, value, type.ref.marker))
+        if (type.ref.marker && CheckValueTag(value, type.ref.marker))
             return type.name;
     }
 
@@ -595,9 +577,9 @@ const char *GetValueType(const InstanceData *instance, Napi::Value value)
     return "Unknown";
 }
 
-void SetValueTag(const InstanceData *instance, Napi::Value value, const void *marker)
+void SetValueTag(Napi::Value value, const void *marker)
 {
-    static_assert(RG_SIZE(TypeInfo) >= 16);
+    static_assert(K_SIZE(TypeInfo) >= 16);
 
     // We used to make a temporary tag on the stack with lower set to a constant value and
     // upper to the pointer address, but this broke in Node 20.12 and Node 21.6 due to ExternalWrapper
@@ -611,10 +593,10 @@ void SetValueTag(const InstanceData *instance, Napi::Value value, const void *ma
     const napi_type_tag *tag = (const napi_type_tag *)marker;
 
     napi_status status = napi_type_tag_object(value.Env(), value, tag);
-    RG_ASSERT(status == napi_ok);
+    K_ASSERT(status == napi_ok);
 }
 
-bool CheckValueTag(const InstanceData *instance, Napi::Value value, const void *marker)
+bool CheckValueTag(Napi::Value value, const void *marker)
 {
     bool match = false;
 
@@ -641,30 +623,32 @@ int GetTypedArrayType(const TypeInfo *type)
         default: return -1;
     }
 
-    RG_UNREACHABLE();
+    K_UNREACHABLE();
 }
 
 Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr, Size len)
 {
+    static const char16_t ReplacementChar = 0xFFFD;
+
     HeapArray<char16_t> buf;
     buf.Reserve(len * 2);
 
     for (Size i = 0; i < len; i++) {
         char32_t uc = ptr[i];
 
-        if (uc < 0xFFFF) {
+        if (uc <= 0xFFFF) {
             if (uc < 0xD800 || uc > 0xDFFF) {
                 buf.Append((char16_t)uc);
             } else {
-                buf.Append('?');
+                buf.Append(ReplacementChar);
             }
-        } else if (uc < 0x10FFFF) {
+        } else if (uc <= 0x10FFFF) {
             uc -= 0x0010000UL;
 
             buf.Append((char16_t)((uc >> 10) + 0xD800));
             buf.Append((char16_t)((uc & 0x3FFul) + 0xDC00));
         } else {
-            buf.Append('?');
+            buf.Append(ReplacementChar);
         }
     }
 
@@ -676,10 +660,8 @@ Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *
 {
     // We can't decode unions because we don't know which member is valid
     if (type->primitive == PrimitiveKind::Union) {
-        InstanceData *instance = env.GetInstanceData<InstanceData>();
-
         Napi::Object wrapper = type->construct.New({}).As<Napi::Object>();
-        SetValueTag(instance, wrapper, &MagicUnionMarker);
+        SetValueTag(wrapper, &MagicUnionMarker);
 
         MagicUnion *u = MagicUnion::Unwrap(wrapper);
         u->SetRaw(origin);
@@ -766,18 +748,17 @@ static uint32_t DecodeDynamicLength(const uint8_t *origin, const RecordMember &b
         case PrimitiveKind::Array:
         case PrimitiveKind::Float32:
         case PrimitiveKind::Float64:
-        case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
+        case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
     }
 
-    RG_UNREACHABLE();
+    K_UNREACHABLE();
 }
 
 void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
 {
     Napi::Env env = obj.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    RG_ASSERT(type->primitive == PrimitiveKind::Record);
+    K_ASSERT(type->primitive == PrimitiveKind::Record);
 
     for (Size i = 0; i < type->members.len; i++) {
         const RecordMember &member = type->members[i];
@@ -785,7 +766,7 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
         const uint8_t *src = origin + member.offset;
 
         switch (member.type->primitive) {
-            case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+            case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
 
             case PrimitiveKind::Bool: {
                 bool b = *(bool *)src;
@@ -887,7 +868,7 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
                     obj.Set(member.name, value);
                 } else if (ptr2) {
                     Napi::External<void> external = Napi::External<void>::New(env, ptr2);
-                    SetValueTag(instance, external, member.type->ref.marker);
+                    SetValueTag(external, member.type->ref.marker);
 
                     obj.Set(member.name, external);
                 } else {
@@ -929,14 +910,13 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
                 obj.Set(member.name, Napi::Number::New(env, d));
             } break;
 
-            case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
+            case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
         }
     }
 }
 
 Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type, uint32_t len)
 {
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
     Size offset = 0;
 
 #define POP_ARRAY(SetCode) \
@@ -964,7 +944,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 }); \
             } else { \
                 Napi::TypedArrayType array = Napi::TypedArrayType::New(env, len); \
-                Span<uint8_t> buffer = MakeSpan((uint8_t *)array.ArrayBuffer().Data(), (Size)len * RG_SIZE(CType)); \
+                Span<uint8_t> buffer = MakeSpan((uint8_t *)array.ArrayBuffer().Data(), (Size)len * K_SIZE(CType)); \
                  \
                 DecodeBuffer(buffer, origin, type->ref.type); \
                  \
@@ -981,7 +961,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 }); \
             } else { \
                 Napi::TypedArrayType array = Napi::TypedArrayType::New(env, len); \
-                Span<uint8_t> buffer = MakeSpan((uint8_t *)array.ArrayBuffer().Data(), (Size)len * RG_SIZE(CType)); \
+                Span<uint8_t> buffer = MakeSpan((uint8_t *)array.ArrayBuffer().Data(), (Size)len * K_SIZE(CType)); \
                  \
                 DecodeBuffer(buffer, origin, type->ref.type); \
                  \
@@ -990,7 +970,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
         } while (false)
 
     switch (type->ref.type->primitive) {
-        case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+        case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
 
         case PrimitiveKind::Bool: {
             POP_ARRAY({
@@ -1087,7 +1067,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
 
                 if (ptr2) {
                     Napi::External<void> external = Napi::External<void>::New(env, ptr2);
-                    SetValueTag(instance, external, type->ref.type->ref.marker);
+                    SetValueTag(external, type->ref.type->ref.marker);
 
                     array.Set(i, external);
                 } else {
@@ -1111,19 +1091,19 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
         case PrimitiveKind::Float32: { POP_NUMBER_ARRAY(Float32Array, float); } break;
         case PrimitiveKind::Float64: { POP_NUMBER_ARRAY(Float64Array, double); } break;
 
-        case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
+        case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
     }
 
 #undef POP_NUMBER_ARRAY_SWAP
 #undef POP_NUMBER_ARRAY
 #undef POP_ARRAY
 
-    RG_UNREACHABLE();
+    K_UNREACHABLE();
 }
 
 Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type)
 {
-    RG_ASSERT(type->primitive == PrimitiveKind::Array);
+    K_ASSERT(type->primitive == PrimitiveKind::Array);
 
     uint32_t len = type->size / type->ref.type->size;
     return DecodeArray(env, origin, type, len);
@@ -1132,9 +1112,8 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
 void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref)
 {
     Napi::Env env = array.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    RG_ASSERT(array.IsArray());
+    K_ASSERT(array.IsArray());
 
     Size offset = 0;
     uint32_t len = array.Length();
@@ -1168,7 +1147,7 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
         } while (false)
 
     switch (ref->primitive) {
-        case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+        case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
 
         case PrimitiveKind::Bool: {
             POP_ARRAY({
@@ -1247,7 +1226,7 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
 
                 if (ptr2) {
                     Napi::External<void> external = Napi::External<void>::New(env, ptr2);
-                    SetValueTag(instance, external, ref->ref.marker);
+                    SetValueTag(external, ref->ref.marker);
 
                     array.Set(i, external);
                 } else {
@@ -1275,7 +1254,7 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
         case PrimitiveKind::Float32: { POP_NUMBER_ARRAY(float); } break;
         case PrimitiveKind::Float64: { POP_NUMBER_ARRAY(double); } break;
 
-        case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
+        case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
     }
 
 #undef POP_NUMBER_ARRAY_SWAP
@@ -1291,7 +1270,7 @@ void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *r
 #define SWAP(CType) \
         do { \
             CType *data = (CType *)buffer.ptr; \
-            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]); \
@@ -1322,6 +1301,10 @@ Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const S
     } else if (IsRawBuffer(value)) {
         Span<uint8_t> buffer = GetRawBuffer(value);
 
+        if (offset < 0) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "Offset must be >= 0");
+            return env.Null();
+        }
         if (buffer.len - offset < type->size) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Expected buffer with size superior or equal to type %1 (%2 bytes)",
                                     type->name, type->size + offset);
@@ -1354,24 +1337,24 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
             type = MakeArrayType(instance, type, *len);
         } else {
             switch (type->primitive) {
-                case PrimitiveKind::Int8: 
+                case PrimitiveKind::Int8:
                 case PrimitiveKind::UInt8: {
                     Size count = strlen((const char *)ptr);
                     type = MakeArrayType(instance, type, count);
                 } break;
-                case PrimitiveKind::Int16: 
+                case PrimitiveKind::Int16:
                 case PrimitiveKind::UInt16: {
-                    Size count = NullTerminatedLength((const char16_t *)ptr, RG_SIZE_MAX);
+                    Size count = NullTerminatedLength((const char16_t *)ptr, K_SIZE_MAX);
                     type = MakeArrayType(instance, type, count);
                 } break;
                 case PrimitiveKind::Int32:
                 case PrimitiveKind::UInt32: {
-                    Size count = NullTerminatedLength((const char32_t *)ptr, RG_SIZE_MAX);
+                    Size count = NullTerminatedLength((const char32_t *)ptr, K_SIZE_MAX);
                     type = MakeArrayType(instance, type, count);
                 } break;
 
                 case PrimitiveKind::Pointer: {
-                    Size count = NullTerminatedLength((const void **)ptr, RG_SIZE_MAX);
+                    Size count = NullTerminatedLength((const void **)ptr, K_SIZE_MAX);
                     type = MakeArrayType(instance, type, count);
                 } break;
 
@@ -1470,14 +1453,14 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
 
         case PrimitiveKind::Prototype: {
             const FunctionInfo *proto = type->ref.proto;
-            RG_ASSERT(!proto->variadic);
-            RG_ASSERT(!proto->lib);
+            K_ASSERT(!proto->variadic);
+            K_ASSERT(!proto->lib);
 
             FunctionInfo *func = new FunctionInfo();
-            RG_DEFER { func->Unref(); };
+            K_DEFER { func->Unref(); };
 
-            memcpy((void *)func, proto, RG_SIZE(*proto));
-            memset((void *)&func->parameters, 0, RG_SIZE(func->parameters));
+            memcpy((void *)func, proto, K_SIZE(*proto));
+            memset((void *)&func->parameters, 0, K_SIZE(func->parameters));
             func->parameters = proto->parameters;
 
             func->name = "<anonymous>";
@@ -1513,6 +1496,10 @@ bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *typ
     } else if (IsRawBuffer(ref)) {
         Span<uint8_t> buffer = GetRawBuffer(ref);
 
+        if (offset < 0) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "Offset must be >= 0");
+            return env.Null();
+        }
         if (buffer.len - offset < type->size) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Expected buffer with size superior or equal to type %1 (%2 bytes)",
                                     type->name, type->size + offset);
@@ -1521,7 +1508,7 @@ bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *typ
 
         ptr = (uint8_t *)buffer.ptr;
     } else {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for reference, expected external or TypedArray", GetValueType(instance, value));
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for reference, expected external or TypedArray", GetValueType(instance, ref));
         return env.Null();
     }
 
@@ -1575,7 +1562,7 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
         } while (false)
 
     switch (type->primitive) {
-        case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+        case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
 
         case PrimitiveKind::Bool: {
             if (!value.IsBoolean()) [[unlikely]] {
@@ -1676,7 +1663,7 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
             if (value.IsFunction()) {
                 ThrowError<Napi::Error>(env, "Cannot encode non-registered callback");
                 return false;
-            } else if (CheckValueTag(instance, value, type->ref.marker)) {
+            } else if (CheckValueTag(value, type->ref.marker)) {
                 ptr = value.As<Napi::External<void>>().Data();
             } else if (IsNullOrUndefined(value)) {
                 ptr = nullptr;
@@ -1688,7 +1675,7 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
             *(void **)origin = ptr;
         } break;
 
-        case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
+        case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
     }
 
 #undef PUSH_INTEGER_SWAP
@@ -1715,8 +1702,6 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
 
 Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func)
 {
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
     Napi::Function wrapper;
     if (func->variadic) {
         Napi::Function::Callback call = TranslateVariadicCall;
@@ -1742,11 +1727,11 @@ Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func)
 
         meta.Set("name", Napi::String::New(env, func->name));
         meta.Set("arguments", arguments);
-        meta.Set("result", WrapType(env, instance, func->ret.type));
+        meta.Set("result", WrapType(env, func->ret.type));
 
         for (Size i = 0; i < func->parameters.len; i++) {
             const ParameterInfo &param = func->parameters[i];
-            arguments.Set((uint32_t)i, WrapType(env, instance, param.type));
+            arguments.Set((uint32_t)i, WrapType(env, param.type));
         }
 
         wrapper.Set("info", meta);
@@ -1811,11 +1796,11 @@ void DumpMemory(const char *type, Span<const uint8_t> bytes)
         PrintLn(StdErr, "%1 at 0x%2 (%3):", type, bytes.ptr, FmtMemSize(bytes.len));
 
         for (const uint8_t *ptr = bytes.begin(); ptr < bytes.end();) {
-            Print(StdErr, "  [0x%1 %2 %3]  ", FmtArg(ptr).Pad0(-16),
-                                              FmtArg((ptr - bytes.begin()) / sizeof(void *)).Pad(-4),
-                                              FmtArg(ptr - bytes.begin()).Pad(-4));
+            Print(StdErr, "  [0x%1 %2 %3]  ", FmtInt((uintptr_t)ptr, 16),
+                                              FmtInt((ptr - bytes.begin()) / sizeof(void *), 4, ' '),
+                                              FmtInt(ptr - bytes.begin(), 4, ' '));
             for (int i = 0; ptr < bytes.end() && i < (int)sizeof(void *); i++, ptr++) {
-                Print(StdErr, " %1", FmtHex(*ptr).Pad0(-2));
+                Print(StdErr, " %1", FmtHex(*ptr, 2));
             }
             PrintLn(StdErr);
         }

package/src/koffi/src/util.hh

@@ -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.
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
 
 #pragma once
 
-#include "src/core/base/base.hh"
+#include "lib/native/base/base.hh"
 #include "ffi.hh"
 
 #include <napi.h>
 
-namespace RG {
+namespace K {
 
 extern const napi_type_tag TypeInfoMarker;
 extern const napi_type_tag CastMarker;
@@ -94,7 +76,7 @@ TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count
 TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len);
 TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint);
 
-Napi::External<TypeInfo> WrapType(Napi::Env env, InstanceData *instance, const TypeInfo *type);
+Napi::External<TypeInfo> WrapType(Napi::Env env, const TypeInfo *type);
 
 bool CanPassType(const TypeInfo *type, int directions);
 bool CanReturnType(const TypeInfo *type);
@@ -103,8 +85,8 @@ bool CanStoreType(const TypeInfo *type);
 // Can be slow, only use for error messages
 const char *GetValueType(const InstanceData *instance, Napi::Value value);
 
-void SetValueTag(const InstanceData *instance, Napi::Value value, const void *marker);
-bool CheckValueTag(const InstanceData *instance, Napi::Value value, const void *marker);
+void SetValueTag(Napi::Value value, const void *marker);
+bool CheckValueTag(Napi::Value value, const void *marker);
 
 static inline bool IsNullOrUndefined(Napi::Value value)
 {
@@ -151,7 +133,7 @@ static inline Span<uint8_t> GetRawBuffer(Napi::Value value)
         return MakeSpan((uint8_t *)buffer.Data(), (Size)buffer.ByteLength());
     }
 
-    RG_UNREACHABLE();
+    K_UNREACHABLE();
 }
 
 int GetTypedArrayType(const TypeInfo *type);
@@ -159,7 +141,7 @@ int GetTypedArrayType(const TypeInfo *type);
 template <typename T>
 T GetNumber(Napi::Value value)
 {
-    RG_ASSERT(value.IsNumber() || value.IsBigInt());
+    K_ASSERT(value.IsNumber() || value.IsBigInt());
 
     if (value.IsNumber()) [[likely]] {
         return (T)value.As<Napi::Number>().DoubleValue();
@@ -170,7 +152,7 @@ T GetNumber(Napi::Value value)
         return (T)bigint.Uint64Value(&lossless);
     }
 
-    RG_UNREACHABLE();
+    K_UNREACHABLE();
 }
 
 template <typename T>
@@ -237,7 +219,7 @@ static inline Napi::Array GetOwnPropertyNames(Napi::Object obj)
     napi_status status = napi_get_all_property_names(env, obj, napi_key_own_only,
                                                      (napi_key_filter)(napi_key_enumerable | napi_key_skip_symbols),
                                                      napi_key_numbers_to_strings, &result);
-    RG_ASSERT(status == napi_ok);
+    K_ASSERT(status == napi_ok);
 
     return Napi::Array(env, result);
 }