@entelligentsia/forgecli 0.7.6 → 0.7.9

package/node_modules/koffi/src/koffi/src/util.cc

@@ -0,0 +1,1807 @@
+// 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 K {
+
+// Value does not matter, the tag system uses memory addresses
+const napi_type_tag TypeInfoMarker = { 0x1cc449675b294374, 0xbb13a50e97dcb017 };
+const napi_type_tag CastMarker = { 0x77f459614a0a412f, 0x80b3dda1341dc8df };
+const napi_type_tag MagicUnionMarker = { 0x5eaf2245526a4c7d, 0x8c86c9ee2b96ffc8 };
+
+Napi::Function MagicUnion::InitClass(Napi::Env env, const TypeInfo *type)
+{
+    K_ASSERT(type->primitive == PrimitiveKind::Union);
+
+    // node-addon-api wants std::vector
+    std::vector<Napi::ClassPropertyDescriptor<MagicUnion>> properties;
+    properties.reserve(type->members.len);
+
+    for (Size i = 0; i < type->members.len; i++) {
+        const RecordMember &member = type->members[i];
+
+        napi_property_attributes attr = (napi_property_attributes)(napi_writable | napi_enumerable);
+        Napi::ClassPropertyDescriptor<MagicUnion> prop = InstanceAccessor(member.name, &MagicUnion::Getter,
+                                                                          &MagicUnion::Setter, attr, (void *)i);
+
+        properties.push_back(prop);
+    }
+
+    Napi::Function constructor = DefineClass(env, type->name, properties, (void *)type);
+    return constructor;
+}
+
+MagicUnion::MagicUnion(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<MagicUnion>(info), type((const TypeInfo *)info.Data())
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    active_symbol.Reset(instance->active_symbol.Value(), 1);
+}
+
+void MagicUnion::SetRaw(const uint8_t *ptr)
+{
+    raw.RemoveFrom(0);
+    raw.Append(MakeSpan(ptr, type->size));
+
+    Value().Set(active_symbol.Value(), Env().Undefined());
+    active_idx = -1;
+}
+
+Napi::Value MagicUnion::Getter(const Napi::CallbackInfo &info)
+{
+    Size idx = (Size)info.Data();
+    const RecordMember &member = type->members[idx];
+
+    Napi::Value value;
+
+    if (idx == active_idx) {
+        value = Value().Get(active_symbol.Value());
+    } else {
+        Napi::Env env = info.Env();
+
+        if (!raw.len) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "Cannont convert %1 union value", active_idx < 0 ? "empty" : "assigned");
+            return env.Null();
+        }
+
+        value = Decode(env, raw.ptr, member.type);
+
+        Value().Set(active_symbol.Value(), value);
+        active_idx = idx;
+    }
+
+    K_ASSERT(!value.IsEmpty());
+    return value;
+}
+
+void MagicUnion::Setter(const Napi::CallbackInfo &info, const Napi::Value &value)
+{
+    Size idx = (Size)info.Data();
+
+    Value().Set(active_symbol.Value(), value);
+    active_idx = idx;
+
+    raw.Clear();
+}
+
+static inline bool IsIdentifierStart(char c)
+{
+    return IsAsciiAlpha(c) || c == '_';
+}
+
+static inline bool IsIdentifierChar(char c)
+{
+    return IsAsciiAlphaOrDigit(c) || c == '_';
+}
+
+static inline Span<const char> SplitIdentifier(Span<const char> str)
+{
+    Size offset = 0;
+
+    if (str.len && IsIdentifierStart(str[0])) {
+        offset++;
+
+        while (offset < str.len && IsIdentifierChar(str[offset])) {
+            offset++;
+        }
+    }
+
+    Span<const char> token = str.Take(0, offset);
+    return token;
+}
+
+int ResolveDirections(Span<const char> str)
+{
+    if (str == "_In_") {
+        return 1;
+    } else if (str == "_Out_") {
+        return 2;
+    } else if (str == "_Inout_") {
+        return 3;
+    } else {
+        return 0;
+    }
+}
+
+const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
+{
+    Napi::Env env = value.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (value.IsString()) {
+        std::string str = value.As<Napi::String>();
+        Span<const char> remain = str.c_str();
+
+        // Quick path for known types (int, float *, etc.)
+        const TypeInfo *type = instance->types_map.FindValue(remain.ptr, nullptr);
+
+        if (!type || (type->flags & (int)TypeFlag::IsIncomplete)) {
+            if (out_directions) {
+                Span<const char> prefix = SplitIdentifier(remain);
+                int directions = ResolveDirections(prefix);
+
+                if (directions) {
+                    remain = remain.Take(prefix.len, remain.len - prefix.len);
+                    remain = TrimStrLeft(remain);
+
+                    *out_directions = directions;
+                } else {
+                    *out_directions = 1;
+                }
+            }
+
+            type = ResolveType(env, remain.ptr);
+
+            if (!type) {
+                if (!env.IsExceptionPending()) {
+                    ThrowError<Napi::TypeError>(env, "Unknown or invalid type name '%1'", str.c_str());
+                }
+                return nullptr;
+            }
+
+            // Cache for quick future access
+            bool inserted;
+            auto bucket = instance->types_map.InsertOrGetDefault(remain.ptr, &inserted);
+
+            if (inserted) {
+                bucket->key = DuplicateString(remain, &instance->str_alloc).ptr;
+                bucket->value = type;
+            }
+        } else if (out_directions) {
+            *out_directions = 1;
+        }
+
+        return type;
+    } 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);
+        K_ASSERT(type);
+
+        if (out_directions) {
+            Size delta = (uint8_t *)raw - (uint8_t *)type;
+            *out_directions = 1 + (int)delta;
+        }
+
+        return type;
+    } else {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value as type specifier, expected string or type", GetValueType(instance, value));
+        return nullptr;
+    }
+}
+
+const TypeInfo *ResolveType(Napi::Env env, Span<const char> str)
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    // Each item can be > 0 for array or 0 for a pointer
+    LocalArray<Size, 8> arrays;
+    uint8_t disposables = 0;
+
+    Span<const char> name;
+    Span<const char> after;
+    {
+        Span<const char> remain = str;
+
+        // Skip initial const qualifiers
+        remain = TrimStrLeft(remain);
+        while (SplitIdentifier(remain) == "const") {
+            remain = remain.Take(6, remain.len - 6);
+            remain = TrimStrLeft(remain);
+        }
+        remain = TrimStrLeft(remain);
+
+        after = remain;
+
+        // Consume one or more identifiers (e.g. unsigned int)
+        for (;;) {
+            after = TrimStrLeft(after);
+
+            Span<const char> token = SplitIdentifier(after);
+            if (!token.len)
+                break;
+            after = after.Take(token.len, after.len - token.len);
+        }
+
+        name = TrimStr(MakeSpan(remain.ptr, after.ptr - remain.ptr));
+    }
+
+    // Consume type indirections (pointer, array, etc.)
+    while (after.len) {
+        if (after[0] == '*') {
+            after = after.Take(1, after.len - 1);
+
+            if (!arrays.Available()) [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Too many type indirections");
+                return nullptr;
+            }
+
+            arrays.Append(0);
+        } else if (after[0] == '!') {
+            after = after.Take(1, after.len - 1);
+            disposables |= (1u << arrays.len);
+        } else if (after[0] == '[') {
+            after = after.Take(1, after.len - 1);
+
+            Size len = 0;
+
+            after = TrimStrLeft(after);
+            if (!ParseInt(after, &len, 0, &after) || len < 0) [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Invalid array length");
+                return nullptr;
+            }
+            after = TrimStrLeft(after);
+            if (!after.len || after[0] != ']') [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Expected ']' after array length");
+                return nullptr;
+            }
+            after = after.Take(1, after.len - 1);
+
+            if (!arrays.Available()) [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Too many type indirections");
+                return nullptr;
+            }
+
+            arrays.Append(len);
+        } else if (SplitIdentifier(after) == "const") {
+            after = after.Take(6, after.len - 6);
+        } else {
+            after = TrimStrRight(after);
+
+            if (after.len) [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Unexpected character '%1' in type specifier", after[0]);
+                return nullptr;
+            }
+
+            break;
+        }
+
+        after = TrimStrLeft(after);
+    }
+
+    const TypeInfo *type = instance->types_map.FindValue(name, nullptr);
+
+    if (!type) {
+        // Try with cleaned up spaces
+        if (name.len < 256) {
+            LocalArray<char, 256> buf;
+            for (Size i = 0; i < name.len; i++) {
+                char c = name[i];
+
+                if (IsAsciiWhite(c)) {
+                    buf.Append(' ');
+                    while (++i < name.len && IsAsciiWhite(name[i]));
+                    i--;
+                } else {
+                    buf.Append(c);
+                }
+            }
+
+            type = instance->types_map.FindValue(buf, nullptr);
+        }
+
+        if (!type)
+            return nullptr;
+    }
+
+    for (int i = 0;; i++) {
+        if (disposables & (1u << i)) {
+            if (type->primitive != PrimitiveKind::Pointer &&
+                    type->primitive != PrimitiveKind::String &&
+                    type->primitive != PrimitiveKind::String16 &&
+                    type->primitive != PrimitiveKind::String32) [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Cannot create disposable type for non-pointer");
+                return nullptr;
+            }
+
+            TypeInfo *copy = instance->types.AppendDefault();
+
+            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();
+
+            copy->dispose = [](Napi::Env env, const TypeInfo *, const void *ptr) {
+                InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+                free((void *)ptr);
+                instance->stats.disposed++;
+            };
+
+            type = copy;
+        }
+
+        if (i >= arrays.len)
+            break;
+        Size len = arrays[i];
+
+        if (len > 0) {
+            if (type->flags & (int)TypeFlag::IsIncomplete) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Cannot make array of incomplete type");
+                return nullptr;
+            }
+
+            if (len > instance->config.max_type_size / type->size) {
+                ThrowError<Napi::TypeError>(env, "Array length is too high (max = %1)", instance->config.max_type_size / type->size);
+                return nullptr;
+            }
+
+            type = MakeArrayType(instance, type, len);
+            K_ASSERT(type);
+        } else {
+            K_ASSERT(!len);
+
+            type = MakePointerType(instance, type);
+            K_ASSERT(type);
+        }
+    }
+
+    if (type->flags & (int)TypeFlag::IsIncomplete) [[unlikely]] {
+        ThrowError<Napi::TypeError>(env, "Cannot directly use incomplete type");
+        return nullptr;
+    }
+
+    return type;
+}
+
+TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count)
+{
+    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.InsertOrGetDefault(name_buf, &inserted);
+
+        if (inserted) {
+            TypeInfo *type = instance->types.AppendDefault();
+
+            type->name = DuplicateString(name_buf, &instance->str_alloc).ptr;
+
+            if (ref->primitive != PrimitiveKind::Prototype) {
+                type->primitive = PrimitiveKind::Pointer;
+                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 = K_SIZE(void *);
+                type->align = K_SIZE(void *);
+                type->ref.proto = ref->ref.proto;
+            }
+
+            bucket->key = type->name;
+            bucket->value = type;
+        }
+
+        ref = bucket->value;
+    }
+
+    return (TypeInfo *)ref;
+}
+
+static TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint, bool insert)
+{
+    K_ASSERT(len >= 0);
+    K_ASSERT(len <= instance->config.max_type_size / ref->size);
+
+    TypeInfo *type = instance->types.AppendDefault();
+
+    type->name = Fmt(&instance->str_alloc, "%1[%2]", ref->name, len).ptr;
+
+    type->primitive = PrimitiveKind::Array;
+    type->align = ref->align;
+    type->size = (int32_t)(len * ref->size);
+    type->ref.type = ref;
+    type->hint = hint;
+
+    if (insert) {
+        bool inserted;
+        type = (TypeInfo *)*instance->types_map.InsertOrGet(type->name, type, &inserted);
+        instance->types.RemoveLast(!inserted);
+    }
+
+    return type;
+}
+
+TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len)
+{
+    ArrayHint hint = {};
+
+    if (ref->flags & (int)TypeFlag::IsCharLike) {
+        hint = ArrayHint::String;
+    } else if (ref->flags & (int)TypeFlag::HasTypedArray) {
+        hint = ArrayHint::Typed;
+    } else {
+        hint = ArrayHint::Array;
+    }
+
+    return MakeArrayType(instance, ref, len, hint, true);
+}
+
+TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint)
+{
+    return MakeArrayType(instance, ref, len, hint, false);
+}
+
+Napi::External<TypeInfo> WrapType(Napi::Env env, const TypeInfo *type)
+{
+    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
+    SetValueTag(external, &TypeInfoMarker);
+
+    return external;
+}
+
+bool CanPassType(const TypeInfo *type, int directions)
+{
+    if (type->countedby)
+        return false;
+
+    if (directions & 2) {
+        if (type->primitive == PrimitiveKind::Pointer)
+            return true;
+        if (type->primitive == PrimitiveKind::String)
+            return true;
+        if (type->primitive == PrimitiveKind::String16)
+            return true;
+        if (type->primitive == PrimitiveKind::String32)
+            return true;
+
+        return false;
+    } else {
+        if (type->primitive == PrimitiveKind::Void)
+            return false;
+        if (type->primitive == PrimitiveKind::Array)
+            return false;
+        if (type->primitive == PrimitiveKind::Prototype)
+            return false;
+        if (type->primitive == PrimitiveKind::Callback && type->ref.proto->variadic)
+            return false;
+
+        return true;
+    }
+}
+
+bool CanReturnType(const TypeInfo *type)
+{
+    if (type->countedby)
+        return false;
+
+    if (type->primitive == PrimitiveKind::Void && !TestStr(type->name, "void"))
+        return false;
+    if (type->primitive == PrimitiveKind::Array)
+        return false;
+    if (type->primitive == PrimitiveKind::Prototype)
+        return false;
+
+    return true;
+}
+
+bool CanStoreType(const TypeInfo *type)
+{
+    if (type->primitive == PrimitiveKind::Void)
+        return false;
+    if (type->primitive == PrimitiveKind::Prototype)
+        return false;
+    if (type->primitive == PrimitiveKind::Callback && type->ref.proto->variadic)
+        return false;
+
+    return true;
+}
+
+const char *GetValueType(const InstanceData *instance, Napi::Value value)
+{
+    if (CheckValueTag(value, &CastMarker)) {
+        Napi::External<ValueCast> external = value.As<Napi::External<ValueCast>>();
+        ValueCast *cast = external.Data();
+
+        return cast->type->name;
+    }
+
+    if (CheckValueTag(value, &TypeInfoMarker))
+        return "Type";
+    for (const TypeInfo &type: instance->types) {
+        if (type.ref.marker && CheckValueTag(value, type.ref.marker))
+            return type.name;
+    }
+
+    if (value.IsArray()) {
+        return "Array";
+    } else if (value.IsTypedArray()) {
+        Napi::TypedArray array = value.As<Napi::TypedArray>();
+
+        switch (array.TypedArrayType()) {
+            case napi_int8_array: return "Int8Array";
+            case napi_uint8_array: return "Uint8Array";
+            case napi_uint8_clamped_array: return "Uint8ClampedArray";
+            case napi_int16_array: return "Int16Array";
+            case napi_uint16_array: return "Uint16Array";
+            case napi_int32_array: return "Int32Array";
+            case napi_uint32_array: return "Uint32Array";
+            case napi_float16_array: return "Float16Array";
+            case napi_float32_array: return "Float32Array";
+            case napi_float64_array: return "Float64Array";
+            case napi_bigint64_array: return "BigInt64Array";
+            case napi_biguint64_array: return "BigUint64Array";
+        }
+    } else if (value.IsArrayBuffer()) {
+        return "ArrayBuffer";
+    } else if (value.IsBuffer()) {
+        return "Buffer";
+    }
+
+    switch (value.Type()) {
+        case napi_undefined: return "Undefined";
+        case napi_null: return "Null";
+        case napi_boolean: return "Boolean";
+        case napi_number: return "Number";
+        case napi_string: return "String";
+        case napi_symbol: return "Symbol";
+        case napi_object: return "Object";
+        case napi_function: return "Function";
+        case napi_external: return "External";
+        case napi_bigint: return "BigInt";
+    }
+
+    // This should not be possible, but who knows...
+    return "Unknown";
+}
+
+void SetValueTag(Napi::Value value, const void *marker)
+{
+    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
+    // storing a pointer to the tag and not the tag value itself (which seems wrong, but anyway).
+    //
+    // Since this is no longer an option, we just type alias whatever marker points to to napi_type_tag.
+    // This may seem gross, but we disable strict aliasing anyway, so as long as what marker points
+    // to is bigger than 16 bytes and does not change, it works!
+    // Which holds true for us: the main thing pointed to is TypeInfo, which is constant and big enough,
+    // and the few other markers we use, such as CastMarker, are actual const napi_type_tag structs.
+    const napi_type_tag *tag = (const napi_type_tag *)marker;
+
+    napi_status status = napi_type_tag_object(value.Env(), value, tag);
+    K_ASSERT(status == napi_ok);
+}
+
+bool CheckValueTag(Napi::Value value, const void *marker)
+{
+    bool match = false;
+
+    if (!IsNullOrUndefined(value)) {
+        const napi_type_tag *tag = (const napi_type_tag *)marker;
+        napi_check_object_type_tag(value.Env(), value, tag, &match);
+    }
+
+    return match;
+}
+
+int GetTypedArrayType(const TypeInfo *type)
+{
+    switch (type->primitive) {
+        case PrimitiveKind::Int8: return napi_int8_array;
+        case PrimitiveKind::UInt8: return napi_uint8_array;
+        case PrimitiveKind::Int16: return napi_int16_array;
+        case PrimitiveKind::UInt16: return napi_uint16_array;
+        case PrimitiveKind::Int32: return napi_int32_array;
+        case PrimitiveKind::UInt32: return napi_uint32_array;
+        case PrimitiveKind::Float32: return napi_float32_array;
+        case PrimitiveKind::Float64: return napi_float64_array;
+
+        default: return -1;
+    }
+
+    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 < 0xD800 || uc > 0xDFFF) {
+                buf.Append((char16_t)uc);
+            } else {
+                buf.Append(ReplacementChar);
+            }
+        } else if (uc <= 0x10FFFF) {
+            uc -= 0x0010000UL;
+
+            buf.Append((char16_t)((uc >> 10) + 0xD800));
+            buf.Append((char16_t)((uc & 0x3FFul) + 0xDC00));
+        } else {
+            buf.Append(ReplacementChar);
+        }
+    }
+
+    Napi::String str = Napi::String::New(env, buf.ptr, buf.len);
+    return str;
+}
+
+Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *type)
+{
+    // We can't decode unions because we don't know which member is valid
+    if (type->primitive == PrimitiveKind::Union) {
+        Napi::Object wrapper = type->construct.New({}).As<Napi::Object>();
+        SetValueTag(wrapper, &MagicUnionMarker);
+
+        MagicUnion *u = MagicUnion::Unwrap(wrapper);
+        u->SetRaw(origin);
+
+        return wrapper;
+    }
+
+    Napi::Object obj = Napi::Object::New(env);
+    DecodeObject(obj, origin, type);
+    return obj;
+}
+
+static uint32_t DecodeDynamicLength(const uint8_t *origin, const RecordMember &by)
+{
+    const uint8_t *src = origin + by.offset;
+
+    switch (by.type->primitive) {
+        case PrimitiveKind::Int8: {
+            int8_t i = *(int8_t *)src;
+            return (uint32_t)i;
+        } break;
+        case PrimitiveKind::UInt8: {
+            uint8_t u = *(uint8_t *)src;
+            return (uint32_t)u;
+        } break;
+        case PrimitiveKind::Int16: {
+            int16_t i = *(int16_t *)src;
+            return (uint32_t)i;
+        } break;
+        case PrimitiveKind::Int16S: {
+            int16_t i = ReverseBytes(*(int16_t *)src);
+            return (uint32_t)i;
+        } break;
+        case PrimitiveKind::UInt16: {
+            uint16_t u = *(uint16_t *)src;
+            return (uint32_t)u;
+        } break;
+        case PrimitiveKind::UInt16S: {
+            uint16_t u = ReverseBytes(*(uint16_t *)src);
+            return (uint32_t)u;
+        } break;
+        case PrimitiveKind::Int32: {
+            int32_t i = *(int32_t *)src;
+            return (uint32_t)i;
+        } break;
+        case PrimitiveKind::Int32S: {
+            int32_t i = ReverseBytes(*(int32_t *)src);
+            return (uint32_t)i;
+        } break;
+        case PrimitiveKind::UInt32: {
+            uint32_t u = *(uint32_t *)src;
+            return (uint32_t)u;
+        } break;
+        case PrimitiveKind::UInt32S: {
+            uint32_t u = ReverseBytes(*(uint32_t *)src);
+            return (uint32_t)u;
+        } break;
+        case PrimitiveKind::Int64: {
+            int64_t i = *(int64_t *)src;
+            return (uint32_t)i;
+        } break;
+        case PrimitiveKind::Int64S: {
+            int64_t i = ReverseBytes(*(int64_t *)src);
+            return (uint32_t)i;
+        } break;
+        case PrimitiveKind::UInt64: {
+            uint64_t u = *(uint64_t *)src;
+            return (uint32_t)u;
+        } break;
+        case PrimitiveKind::UInt64S: {
+            uint64_t u = ReverseBytes(*(uint64_t *)src);
+            return (uint32_t)u;
+        } break;
+
+        case PrimitiveKind::Void:
+        case PrimitiveKind::Bool:
+        case PrimitiveKind::String:
+        case PrimitiveKind::String16:
+        case PrimitiveKind::String32:
+        case PrimitiveKind::Pointer:
+        case PrimitiveKind::Callback:
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union:
+        case PrimitiveKind::Array:
+        case PrimitiveKind::Float32:
+        case PrimitiveKind::Float64:
+        case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
+    }
+
+    K_UNREACHABLE();
+}
+
+void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
+{
+    Napi::Env env = obj.Env();
+
+    K_ASSERT(type->primitive == PrimitiveKind::Record);
+
+    for (Size i = 0; i < type->members.len; i++) {
+        const RecordMember &member = type->members[i];
+
+        const uint8_t *src = origin + member.offset;
+
+        switch (member.type->primitive) {
+            case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
+
+            case PrimitiveKind::Bool: {
+                bool b = *(bool *)src;
+                obj.Set(member.name, Napi::Boolean::New(env, b));
+            } break;
+            case PrimitiveKind::Int8: {
+                double d = (double)*(int8_t *)src;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::UInt8: {
+                double d = (double)*(uint8_t *)src;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::Int16: {
+                double d = (double)*(int16_t *)src;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::Int16S: {
+                int16_t v = *(int16_t *)src;
+                double d = (double)ReverseBytes(v);
+
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::UInt16: {
+                double d = (double)*(uint16_t *)src;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::UInt16S: {
+                uint16_t v = *(uint16_t *)src;
+                double d = (double)ReverseBytes(v);
+
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::Int32: {
+                double d = (double)*(int32_t *)src;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::Int32S: {
+                int32_t v = *(int32_t *)src;
+                double d = (double)ReverseBytes(v);
+
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::UInt32: {
+                double d = (double)*(uint32_t *)src;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::UInt32S: {
+                uint32_t v = *(uint32_t *)src;
+                double d = (double)ReverseBytes(v);
+
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::Int64: {
+                int64_t v = *(int64_t *)src;
+                obj.Set(member.name, NewBigInt(env, v));
+            } break;
+            case PrimitiveKind::Int64S: {
+                int64_t v = ReverseBytes(*(int64_t *)src);
+                obj.Set(member.name, NewBigInt(env, v));
+            } break;
+            case PrimitiveKind::UInt64: {
+                uint64_t v = *(uint64_t *)src;
+                obj.Set(member.name, NewBigInt(env, v));
+            } break;
+            case PrimitiveKind::UInt64S: {
+                uint64_t v = ReverseBytes(*(uint64_t *)src);
+                obj.Set(member.name, NewBigInt(env, v));
+            } break;
+            case PrimitiveKind::String: {
+                const char *str = *(const char **)src;
+                obj.Set(member.name, str ? Napi::String::New(env, str) : env.Null());
+
+                if (member.type->dispose) {
+                    member.type->dispose(env, member.type, str);
+                }
+            } break;
+            case PrimitiveKind::String16: {
+                const char16_t *str16 = *(const char16_t **)src;
+                obj.Set(member.name, str16 ? Napi::String::New(env, str16) : env.Null());
+
+                if (member.type->dispose) {
+                    member.type->dispose(env, member.type, str16);
+                }
+            } break;
+            case PrimitiveKind::String32: {
+                const char32_t *str32 = *(const char32_t **)src;
+                obj.Set(member.name, str32 ? MakeStringFromUTF32(env, str32) : env.Null());
+            } break;
+            case PrimitiveKind::Pointer:
+            case PrimitiveKind::Callback: {
+                void *ptr2 = *(void **)src;
+
+                if (member.countedby >= 0) {
+                    const RecordMember &by = type->members[member.countedby];
+                    uint32_t len = DecodeDynamicLength(origin, by);
+
+                    Napi::Value value = DecodeArray(env, (const uint8_t *)ptr2, member.type, len);
+                    obj.Set(member.name, value);
+                } else if (ptr2) {
+                    Napi::External<void> external = Napi::External<void>::New(env, ptr2);
+                    SetValueTag(external, member.type->ref.marker);
+
+                    obj.Set(member.name, external);
+                } else {
+                    obj.Set(member.name, env.Null());
+                }
+
+                if (member.type->dispose) {
+                    member.type->dispose(env, member.type, ptr2);
+                }
+            } break;
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
+                Napi::Object obj2 = DecodeObject(env, src, member.type);
+                obj.Set(member.name, obj2);
+            } break;
+            case PrimitiveKind::Array: {
+                if (member.countedby >= 0) {
+                    const RecordMember &by = type->members[member.countedby];
+
+                    uint32_t len = DecodeDynamicLength(origin, by);
+                    uint32_t max = member.type->size / member.type->ref.type->size;
+
+                    // Silently truncate result
+                    len = std::min(len, max);
+
+                    Napi::Value value = DecodeArray(env, src, member.type, len);
+                    obj.Set(member.name, value);
+                } else {
+                    Napi::Value value = DecodeArray(env, src, member.type);
+                    obj.Set(member.name, value);
+                }
+            } break;
+            case PrimitiveKind::Float32: {
+                float f = *(float *)src;
+                obj.Set(member.name, Napi::Number::New(env, (double)f));
+            } break;
+            case PrimitiveKind::Float64: {
+                double d = *(double *)src;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+
+            case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
+        }
+    }
+}
+
+Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type, uint32_t len)
+{
+    Size offset = 0;
+
+#define POP_ARRAY(SetCode) \
+        do { \
+            Napi::Array array = Napi::Array::New(env); \
+             \
+            for (uint32_t i = 0; i < len; i++) { \
+                offset = AlignLen(offset, type->ref.type->align); \
+                 \
+                const uint8_t *src = origin + offset; \
+                 \
+                SetCode \
+                 \
+                offset += type->ref.type->size; \
+            } \
+             \
+            return array; \
+        } while (false)
+#define POP_NUMBER_ARRAY(TypedArrayType, CType) \
+        do { \
+            if (type->hint == ArrayHint::Array) { \
+                POP_ARRAY({ \
+                    double d = (double)*(CType *)src; \
+                    array.Set(i, Napi::Number::New(env, d)); \
+                }); \
+            } else { \
+                Napi::TypedArrayType array = Napi::TypedArrayType::New(env, len); \
+                Span<uint8_t> buffer = MakeSpan((uint8_t *)array.ArrayBuffer().Data(), (Size)len * K_SIZE(CType)); \
+                 \
+                DecodeBuffer(buffer, origin, type->ref.type); \
+                 \
+                return array; \
+            } \
+        } while (false)
+#define POP_NUMBER_ARRAY_SWAP(TypedArrayType, CType) \
+        do { \
+            if (type->hint == ArrayHint::Array) { \
+                POP_ARRAY({ \
+                    CType v = *(CType *)src; \
+                    double d = (double)ReverseBytes(v); \
+                    array.Set(i, Napi::Number::New(env, d)); \
+                }); \
+            } else { \
+                Napi::TypedArrayType array = Napi::TypedArrayType::New(env, len); \
+                Span<uint8_t> buffer = MakeSpan((uint8_t *)array.ArrayBuffer().Data(), (Size)len * K_SIZE(CType)); \
+                 \
+                DecodeBuffer(buffer, origin, type->ref.type); \
+                 \
+                return array; \
+            } \
+        } while (false)
+
+    switch (type->ref.type->primitive) {
+        case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
+
+        case PrimitiveKind::Bool: {
+            POP_ARRAY({
+                bool b = *(bool *)src;
+                array.Set(i, Napi::Boolean::New(env, b));
+            });
+        } break;
+        case PrimitiveKind::Int8: {
+            if (type->hint == ArrayHint::String) {
+                const char *ptr = (const char *)origin;
+                size_t count = strnlen(ptr, (size_t)len);
+
+                Napi::String str = Napi::String::New(env, ptr, count);
+                return str;
+            }
+
+            POP_NUMBER_ARRAY(Int8Array, int8_t);
+        } break;
+        case PrimitiveKind::UInt8: { POP_NUMBER_ARRAY(Uint8Array, uint8_t); } break;
+        case PrimitiveKind::Int16: {
+            if (type->hint == ArrayHint::String) {
+                const char16_t *ptr = (const char16_t *)origin;
+                Size count = NullTerminatedLength(ptr, len);
+
+                Napi::String str = Napi::String::New(env, ptr, count);
+                return str;
+            }
+
+            POP_NUMBER_ARRAY(Int16Array, int16_t);
+        } break;
+        case PrimitiveKind::Int16S: { POP_NUMBER_ARRAY_SWAP(Int16Array, int16_t); } break;
+        case PrimitiveKind::UInt16: { POP_NUMBER_ARRAY(Uint16Array, uint16_t); } break;
+        case PrimitiveKind::UInt16S: { POP_NUMBER_ARRAY_SWAP(Uint16Array, uint16_t); } break;
+        case PrimitiveKind::Int32: {
+            if (type->hint == ArrayHint::String) {
+                const char32_t *ptr = (const char32_t *)origin;
+                Size count = NullTerminatedLength(ptr, len);
+
+                Napi::String str = MakeStringFromUTF32(env, ptr, count);
+                return str;
+            }
+
+            POP_NUMBER_ARRAY(Int32Array, int32_t);
+        } break;
+        case PrimitiveKind::Int32S: { POP_NUMBER_ARRAY_SWAP(Int32Array, int32_t); } break;
+        case PrimitiveKind::UInt32: { POP_NUMBER_ARRAY(Uint32Array, uint32_t); } break;
+        case PrimitiveKind::UInt32S: { POP_NUMBER_ARRAY_SWAP(Uint32Array, uint32_t); } break;
+        case PrimitiveKind::Int64: {
+            POP_ARRAY({
+                int64_t v = *(int64_t *)src;
+                array.Set(i, NewBigInt(env, v));
+            });
+        } break;
+        case PrimitiveKind::Int64S: {
+            POP_ARRAY({
+                int64_t v = ReverseBytes(*(int64_t *)src);
+                array.Set(i, NewBigInt(env, v));
+            });
+        } break;
+        case PrimitiveKind::UInt64: {
+            POP_ARRAY({
+                uint64_t v = *(uint64_t *)src;
+                array.Set(i, NewBigInt(env, v));
+            });
+        } break;
+        case PrimitiveKind::UInt64S: {
+            POP_ARRAY({
+                uint64_t v = ReverseBytes(*(uint64_t *)src);
+                array.Set(i, NewBigInt(env, v));
+            });
+        } break;
+        case PrimitiveKind::String: {
+            POP_ARRAY({
+                const char *str = *(const char **)src;
+                array.Set(i, str ? Napi::String::New(env, str) : env.Null());
+            });
+        } break;
+        case PrimitiveKind::String16: {
+            POP_ARRAY({
+                const char16_t *str16 = *(const char16_t **)src;
+                array.Set(i, str16 ? Napi::String::New(env, str16) : env.Null());
+            });
+        } break;
+        case PrimitiveKind::String32: {
+            POP_ARRAY({
+                const char32_t *str32 = *(const char32_t **)src;
+                array.Set(i, str32 ? MakeStringFromUTF32(env, str32) : env.Null());
+            });
+        } break;
+        case PrimitiveKind::Pointer:
+        case PrimitiveKind::Callback: {
+            POP_ARRAY({
+                void *ptr2 = *(void **)src;
+
+                if (ptr2) {
+                    Napi::External<void> external = Napi::External<void>::New(env, ptr2);
+                    SetValueTag(external, type->ref.type->ref.marker);
+
+                    array.Set(i, external);
+                } else {
+                    array.Set(i, env.Null());
+                }
+            });
+        } break;
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
+            POP_ARRAY({
+                Napi::Object obj = DecodeObject(env, src, type->ref.type);
+                array.Set(i, obj);
+            });
+        } break;
+        case PrimitiveKind::Array: {
+            POP_ARRAY({
+                Napi::Value value = DecodeArray(env, src, type->ref.type);
+                array.Set(i, value);
+            });
+        } break;
+        case PrimitiveKind::Float32: { POP_NUMBER_ARRAY(Float32Array, float); } break;
+        case PrimitiveKind::Float64: { POP_NUMBER_ARRAY(Float64Array, double); } break;
+
+        case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
+    }
+
+#undef POP_NUMBER_ARRAY_SWAP
+#undef POP_NUMBER_ARRAY
+#undef POP_ARRAY
+
+    K_UNREACHABLE();
+}
+
+Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type)
+{
+    K_ASSERT(type->primitive == PrimitiveKind::Array);
+
+    uint32_t len = type->size / type->ref.type->size;
+    return DecodeArray(env, origin, type, len);
+}
+
+void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref)
+{
+    Napi::Env env = array.Env();
+
+    K_ASSERT(array.IsArray());
+
+    Size offset = 0;
+    uint32_t len = array.Length();
+
+#define POP_ARRAY(SetCode) \
+        do { \
+            for (uint32_t i = 0; i < len; i++) { \
+                offset = AlignLen(offset, ref->align); \
+                 \
+                const uint8_t *src = origin + offset; \
+                 \
+                SetCode \
+                 \
+                offset += ref->size; \
+            } \
+        } while (false)
+#define POP_NUMBER_ARRAY(CType) \
+        do { \
+            POP_ARRAY({ \
+                double d = (double)*(CType *)src; \
+                array.Set(i, Napi::Number::New(env, d)); \
+            }); \
+        } while (false)
+#define POP_NUMBER_ARRAY_SWAP(CType) \
+        do { \
+            POP_ARRAY({ \
+                CType v = *(CType *)src; \
+                double d = (double)ReverseBytes(v); \
+                array.Set(i, Napi::Number::New(env, d)); \
+            }); \
+        } while (false)
+
+    switch (ref->primitive) {
+        case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
+
+        case PrimitiveKind::Bool: {
+            POP_ARRAY({
+                bool b = *(bool *)src;
+                array.Set(i, Napi::Boolean::New(env, b));
+            });
+        } break;
+        case PrimitiveKind::Int8: { POP_NUMBER_ARRAY(int8_t); } break;
+        case PrimitiveKind::UInt8: { POP_NUMBER_ARRAY(uint8_t); } break;
+        case PrimitiveKind::Int16: { POP_NUMBER_ARRAY(int16_t); } break;
+        case PrimitiveKind::Int16S: { POP_NUMBER_ARRAY_SWAP(int16_t); } break;
+        case PrimitiveKind::UInt16: { POP_NUMBER_ARRAY(uint16_t); } break;
+        case PrimitiveKind::UInt16S: { POP_NUMBER_ARRAY_SWAP(uint16_t); } break;
+        case PrimitiveKind::Int32: { POP_NUMBER_ARRAY(int32_t); } break;
+        case PrimitiveKind::Int32S: { POP_NUMBER_ARRAY_SWAP(int32_t); } break;
+        case PrimitiveKind::UInt32: { POP_NUMBER_ARRAY(uint32_t); } break;
+        case PrimitiveKind::UInt32S: { POP_NUMBER_ARRAY_SWAP(uint32_t); } break;
+        case PrimitiveKind::Int64: {
+            POP_ARRAY({
+                int64_t v = *(int64_t *)src;
+                array.Set(i, NewBigInt(env, v));
+            });
+        } break;
+        case PrimitiveKind::Int64S: {
+            POP_ARRAY({
+                int64_t v = ReverseBytes(*(int64_t *)src);
+                array.Set(i, NewBigInt(env, v));
+            });
+        } break;
+        case PrimitiveKind::UInt64: {
+            POP_ARRAY({
+                uint64_t v = *(uint64_t *)src;
+                array.Set(i, NewBigInt(env, v));
+            });
+        } break;
+        case PrimitiveKind::UInt64S: {
+            POP_ARRAY({
+                uint64_t v = ReverseBytes(*(uint64_t *)src);
+                array.Set(i, NewBigInt(env, v));
+            });
+        } break;
+        case PrimitiveKind::String: {
+            POP_ARRAY({
+                const char *str = *(const char **)src;
+                array.Set(i, str ? Napi::String::New(env, str) : env.Null());
+
+                if (ref->dispose) {
+                    ref->dispose(env, ref, str);
+                }
+            });
+        } break;
+        case PrimitiveKind::String16: {
+            POP_ARRAY({
+                const char16_t *str16 = *(const char16_t **)src;
+                array.Set(i, str16 ? Napi::String::New(env, str16) : env.Null());
+
+                if (ref->dispose) {
+                    ref->dispose(env, ref, str16);
+                }
+            });
+        } break;
+        case PrimitiveKind::String32: {
+            POP_ARRAY({
+                const char32_t *str32 = *(const char32_t **)src;
+                array.Set(i, str32 ? MakeStringFromUTF32(env, str32) : env.Null());
+
+                if (ref->dispose) {
+                    ref->dispose(env, ref, str32);
+                }
+            });
+        } break;
+        case PrimitiveKind::Pointer:
+        case PrimitiveKind::Callback: {
+            POP_ARRAY({
+                void *ptr2 = *(void **)src;
+
+                if (ptr2) {
+                    Napi::External<void> external = Napi::External<void>::New(env, ptr2);
+                    SetValueTag(external, ref->ref.marker);
+
+                    array.Set(i, external);
+                } else {
+                    array.Set(i, env.Null());
+                }
+
+                if (ref->dispose) {
+                    ref->dispose(env, ref, ptr2);
+                }
+            });
+        } break;
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
+            POP_ARRAY({
+                Napi::Object obj = DecodeObject(env, src, ref);
+                array.Set(i, obj);
+            });
+        } break;
+        case PrimitiveKind::Array: {
+            POP_ARRAY({
+                Napi::Value value = DecodeArray(env, src, ref);
+                array.Set(i, value);
+            });
+        } break;
+        case PrimitiveKind::Float32: { POP_NUMBER_ARRAY(float); } break;
+        case PrimitiveKind::Float64: { POP_NUMBER_ARRAY(double); } break;
+
+        case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
+    }
+
+#undef POP_NUMBER_ARRAY_SWAP
+#undef POP_NUMBER_ARRAY
+#undef POP_ARRAY
+}
+
+void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *ref)
+{
+    // Go fast brrrrr!
+    MemCpy(buffer.ptr, origin, (size_t)buffer.len);
+
+#define SWAP(CType) \
+        do { \
+            CType *data = (CType *)buffer.ptr; \
+            Size len = buffer.len / K_SIZE(CType); \
+             \
+            for (Size i = 0; i < len; i++) { \
+                data[i] = ReverseBytes(data[i]); \
+            } \
+        } while (false)
+
+    if (ref->primitive == PrimitiveKind::Int16S || ref->primitive == PrimitiveKind::UInt16S) {
+        SWAP(uint16_t);
+    } else if (ref->primitive == PrimitiveKind::Int32S || ref->primitive == PrimitiveKind::UInt32S) {
+        SWAP(uint32_t);
+    } else if (ref->primitive == PrimitiveKind::Int64S || ref->primitive == PrimitiveKind::UInt64S) {
+        SWAP(uint64_t);
+    }
+
+#undef SWAP
+}
+
+Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len)
+{
+    Napi::Env env = value.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    const uint8_t *ptr = nullptr;
+
+    if (value.IsExternal()) {
+        Napi::External<void> external = value.As<Napi::External<void>>();
+        ptr = (const uint8_t *)external.Data();
+    } 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);
+            return env.Null();
+        }
+
+        ptr = (const uint8_t *)buffer.ptr;
+    } else {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for variable, expected external or TypedArray", GetValueType(instance, value));
+        return env.Null();
+    }
+
+    if (!ptr)
+        return env.Null();
+    ptr += offset;
+
+    Napi::Value ret = Decode(env, ptr, type, len);
+    return ret;
+}
+
+Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, const Size *len)
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (len && type->primitive != PrimitiveKind::String &&
+               type->primitive != PrimitiveKind::String16 &&
+               type->primitive != PrimitiveKind::String32 &&
+               type->primitive != PrimitiveKind::Prototype) {
+        if (*len >= 0) {
+            type = MakeArrayType(instance, type, *len);
+        } else {
+            switch (type->primitive) {
+                case PrimitiveKind::Int8:
+                case PrimitiveKind::UInt8: {
+                    Size count = strlen((const char *)ptr);
+                    type = MakeArrayType(instance, type, count);
+                } break;
+                case PrimitiveKind::Int16:
+                case PrimitiveKind::UInt16: {
+                    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, K_SIZE_MAX);
+                    type = MakeArrayType(instance, type, count);
+                } break;
+
+                case PrimitiveKind::Pointer: {
+                    Size count = NullTerminatedLength((const void **)ptr, K_SIZE_MAX);
+                    type = MakeArrayType(instance, type, count);
+                } break;
+
+                default: {
+                    ThrowError<Napi::TypeError>(env, "Cannot determine null-terminated length for type %1", type->name);
+                    return env.Null();
+                } break;
+            }
+        }
+    }
+
+#define RETURN_INT(Type, NewCall) \
+        do { \
+            Type v = *(Type *)ptr; \
+            return NewCall(env, v); \
+        } while (false)
+#define RETURN_INT_SWAP(Type, NewCall) \
+        do { \
+            Type v = ReverseBytes(*(Type *)ptr); \
+            return NewCall(env, v); \
+        } while (false)
+
+    switch (type->primitive) {
+        case PrimitiveKind::Void: {
+            ThrowError<Napi::TypeError>(env, "Cannot decode value of type %1", type->name);
+            return env.Null();
+        } break;
+
+        case PrimitiveKind::Bool: {
+            bool v = *(bool *)ptr;
+            return Napi::Boolean::New(env, v);
+        } break;
+        case PrimitiveKind::Int8: { RETURN_INT(int8_t, Napi::Number::New); } break;
+        case PrimitiveKind::UInt8: { RETURN_INT(uint8_t, Napi::Number::New); } break;
+        case PrimitiveKind::Int16: { RETURN_INT(int16_t, Napi::Number::New); } break;
+        case PrimitiveKind::Int16S: { RETURN_INT_SWAP(int16_t, Napi::Number::New); } break;
+        case PrimitiveKind::UInt16: { RETURN_INT(uint16_t, Napi::Number::New); } break;
+        case PrimitiveKind::UInt16S: { RETURN_INT_SWAP(uint16_t, Napi::Number::New); } break;
+        case PrimitiveKind::Int32: { RETURN_INT(int32_t, Napi::Number::New); } break;
+        case PrimitiveKind::Int32S: { RETURN_INT_SWAP(int32_t, Napi::Number::New); } break;
+        case PrimitiveKind::UInt32: { RETURN_INT(uint32_t, Napi::Number::New); } break;
+        case PrimitiveKind::UInt32S: { RETURN_INT_SWAP(uint32_t, Napi::Number::New); } break;
+        case PrimitiveKind::Int64: { RETURN_INT(int64_t, NewBigInt); } break;
+        case PrimitiveKind::Int64S: { RETURN_INT_SWAP(int64_t, NewBigInt); } break;
+        case PrimitiveKind::UInt64: { RETURN_INT(uint64_t, NewBigInt); } break;
+        case PrimitiveKind::UInt64S: { RETURN_INT_SWAP(uint64_t, NewBigInt); } break;
+        case PrimitiveKind::String: {
+            if (len) {
+                const char *str = *(const char **)ptr;
+                return str ? Napi::String::New(env, str, *len) : env.Null();
+            } else {
+                const char *str = *(const char **)ptr;
+                return str ? Napi::String::New(env, str) : env.Null();
+            }
+        } break;
+        case PrimitiveKind::String16: {
+            if (len) {
+                const char16_t *str16 = *(const char16_t **)ptr;
+                return str16 ? Napi::String::New(env, str16, *len) : env.Null();
+            } else {
+                const char16_t *str16 = *(const char16_t **)ptr;
+                return str16 ? Napi::String::New(env, str16) : env.Null();
+            }
+        } break;
+        case PrimitiveKind::String32: {
+            if (len) {
+                const char32_t *str32 = *(const char32_t **)ptr;
+                return str32 ? MakeStringFromUTF32(env, str32, *len) : env.Null();
+            } else {
+                const char32_t *str32 = *(const char32_t **)ptr;
+                return str32 ? MakeStringFromUTF32(env, str32) : env.Null();
+            }
+        } break;
+        case PrimitiveKind::Pointer:
+        case PrimitiveKind::Callback: {
+            void *ptr2 = *(void **)ptr;
+            return ptr2 ? Napi::External<void>::New(env, ptr2, [](Napi::Env, void *) {}) : env.Null();
+        } break;
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
+            Napi::Object obj = DecodeObject(env, ptr, type);
+            return obj;
+        } break;
+        case PrimitiveKind::Array: {
+            Napi::Value array = DecodeArray(env, ptr, type);
+            return array;
+        } break;
+        case PrimitiveKind::Float32: {
+            float f = *(float *)ptr;
+            return Napi::Number::New(env, f);
+        } break;
+        case PrimitiveKind::Float64: {
+            double d = *(double *)ptr;
+            return Napi::Number::New(env, d);
+        } break;
+
+        case PrimitiveKind::Prototype: {
+            const FunctionInfo *proto = type->ref.proto;
+            K_ASSERT(!proto->variadic);
+            K_ASSERT(!proto->lib);
+
+            FunctionInfo *func = new FunctionInfo();
+            K_DEFER { func->Unref(); };
+
+            memcpy((void *)func, proto, K_SIZE(*proto));
+            memset((void *)&func->parameters, 0, K_SIZE(func->parameters));
+            func->parameters = proto->parameters;
+
+            func->name = "<anonymous>";
+            func->native = (void *)ptr;
+
+            // Fix back parameter offset
+            for (ParameterInfo &param: func->parameters) {
+                param.offset -= 2;
+            }
+            func->required_parameters -= 2;
+
+            Napi::Function wrapper = WrapFunction(env, func);
+            return wrapper;
+        } break;
+    }
+
+#undef RETURN_BIGINT
+#undef RETURN_INT
+
+    return env.Null();
+}
+
+bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *type, const Size *len)
+{
+    Napi::Env env = ref.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    uint8_t *ptr = nullptr;
+
+    if (ref.IsExternal()) {
+        Napi::External<void> external = ref.As<Napi::External<void>>();
+        ptr = (uint8_t *)external.Data();
+    } 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);
+            return env.Null();
+        }
+
+        ptr = (uint8_t *)buffer.ptr;
+    } else {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for reference, expected external or TypedArray", GetValueType(instance, ref));
+        return env.Null();
+    }
+
+    if (!ptr) [[unlikely]] {
+        ThrowError<Napi::Error>(env, "Cannot encode data in NULL pointer");
+        return env.Null();
+    }
+    ptr += offset;
+
+    return Encode(env, ptr, value, type, len);
+}
+
+bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *type, const Size *len)
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (len && type->primitive != PrimitiveKind::String &&
+               type->primitive != PrimitiveKind::String16 &&
+               type->primitive != PrimitiveKind::String32 &&
+               type->primitive != PrimitiveKind::Prototype) {
+        if (*len < 0) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Automatic (negative) length is only supported when decoding");
+            return env.Null();
+        }
+
+        type = MakeArrayType(instance, type, *len);
+    }
+
+    InstanceMemory mem = {};
+    CallData call(env, instance, &mem);
+
+#define PUSH_INTEGER(CType) \
+        do { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
+                return false; \
+            } \
+             \
+            CType v = GetNumber<CType>(value); \
+            *(CType *)origin = v; \
+        } while (false)
+#define PUSH_INTEGER_SWAP(CType) \
+        do { \
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value)); \
+                return false; \
+            } \
+             \
+            CType v = GetNumber<CType>(value); \
+            *(CType *)origin = ReverseBytes(v); \
+        } while (false)
+
+    switch (type->primitive) {
+        case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
+
+        case PrimitiveKind::Bool: {
+            if (!value.IsBoolean()) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected boolean", GetValueType(instance, value));
+                return false;
+            }
+
+            bool b = value.As<Napi::Boolean>();
+            *(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(value)) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
+                return false;
+            }
+
+            Napi::Object obj = value.As<Napi::Object>();
+
+            if (!call.PushObject(obj, type, origin))
+                return false;
+        } break;
+        case PrimitiveKind::Array: {
+            if (value.IsArray()) {
+                Napi::Array array = value.As<Napi::Array>();
+                if (!call.PushNormalArray(array, type, type->size, origin))
+                    return false;
+            } else if (IsRawBuffer(value)) {
+                Span<const uint8_t> buffer = GetRawBuffer(value);
+                call.PushBuffer(buffer, type, origin);
+            } else if (value.IsString()) {
+                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: {
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                return false;
+            }
+
+            float f = GetNumber<float>(value);
+            *(float *)origin = f;
+        } break;
+        case PrimitiveKind::Float64: {
+            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
+                return false;
+            }
+
+            double d = GetNumber<double>(value);
+            *(double *)origin = d;
+        } break;
+        case PrimitiveKind::Callback: {
+            void *ptr;
+
+            if (value.IsFunction()) {
+                ThrowError<Napi::Error>(env, "Cannot encode non-registered callback");
+                return false;
+            } else if (CheckValueTag(value, type->ref.marker)) {
+                ptr = value.As<Napi::External<void>>().Data();
+            } else if (IsNullOrUndefined(value)) {
+                ptr = nullptr;
+            } 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 (call.alloc.IsUsed()) {
+        BlockAllocator *copy = instance->encode_map.FindValue(origin, nullptr);
+
+        if (!copy) {
+            copy = instance->encode_allocators.AppendDefault();
+            instance->encode_map.Set(origin, copy);
+        }
+
+        std::swap(call.alloc, *copy);
+    }
+
+    return true;
+}
+
+Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func)
+{
+    Napi::Function wrapper;
+    if (func->variadic) {
+        Napi::Function::Callback call = TranslateVariadicCall;
+        wrapper = Napi::Function::New(env, call, func->name, (void *)func->Ref());
+    } else {
+        Napi::Function::Callback call = TranslateNormalCall;
+        wrapper = Napi::Function::New(env, call, func->name, (void *)func->Ref());
+    }
+    wrapper.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, (FunctionInfo *)func);
+
+    if (!func->variadic) {
+        Napi::Function::Callback call = TranslateAsyncCall;
+        Napi::Function async = Napi::Function::New(env, call, func->name, (void *)func->Ref());
+
+        async.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, (FunctionInfo *)func);
+        wrapper.Set("async", async);
+    }
+
+    // Create info object
+    {
+        Napi::Object meta = Napi::Object::New(env);
+        Napi::Array arguments = Napi::Array::New(env, func->parameters.len);
+
+        meta.Set("name", Napi::String::New(env, func->name));
+        meta.Set("arguments", arguments);
+        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, param.type));
+        }
+
+        wrapper.Set("info", meta);
+    }
+
+    return wrapper;
+}
+
+bool DetectCallConvention(Span<const char> name, CallConvention *out_convention)
+{
+    if (name == "__cdecl") {
+        *out_convention = CallConvention::Cdecl;
+        return true;
+    } else if (name == "__stdcall") {
+        *out_convention = CallConvention::Stdcall;
+        return true;
+    } else if (name == "__fastcall") {
+        *out_convention = CallConvention::Fastcall;
+        return true;
+    } else if (name == "__thiscall") {
+        *out_convention = CallConvention::Thiscall;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+static int AnalyseFlatRec(const TypeInfo *type, int offset, int count, FunctionRef<void(const TypeInfo *type, int offset, int count)> func)
+{
+    if (type->primitive == PrimitiveKind::Record) {
+        for (int i = 0; i < count; i++) {
+            for (const RecordMember &member: type->members) {
+                offset = AnalyseFlatRec(member.type, offset, 1, func);
+            }
+        }
+    } else if (type->primitive == PrimitiveKind::Union) {
+        for (int i = 0; i < count; i++) {
+            for (const RecordMember &member: type->members) {
+                AnalyseFlatRec(member.type, offset, 1, func);
+            }
+        }
+        offset += count;
+    } else if (type->primitive == PrimitiveKind::Array) {
+        count *= type->size / type->ref.type->size;
+        offset = AnalyseFlatRec(type->ref.type, offset, count, func);
+    } else {
+        func(type, offset, count);
+        offset += count;
+    }
+
+    return offset;
+}
+
+int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func)
+{
+    return AnalyseFlatRec(type, 0, 1, func);
+}
+
+void DumpMemory(const char *type, Span<const uint8_t> bytes)
+{
+    if (bytes.len) {
+        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]  ", FmtHex((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, 2));
+            }
+            PrintLn(StdErr);
+        }
+    }
+}
+
+}