koffi 2.16.1 → 3.0.0-alpha.2

package/src/koffi/src/util.cc

@@ -13,22 +13,22 @@ 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 };
+const napi_type_tag UnionClassMarker = { 0x5eaf2245526a4c7d, 0x8c86c9ee2b96ffc8 };
 
-Napi::Function MagicUnion::InitClass(Napi::Env env, const TypeInfo *type)
+Napi::Function UnionClass::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;
+    std::vector<Napi::ClassPropertyDescriptor<UnionClass>> 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);
+        Napi::ClassPropertyDescriptor<UnionClass> prop = InstanceAccessor(member.name, &UnionClass::Getter,
+                                                                          &UnionClass::Setter, attr, (void *)i);
 
         properties.push_back(prop);
     }
@@ -37,25 +37,39 @@ Napi::Function MagicUnion::InitClass(Napi::Env env, const TypeInfo *type)
     return constructor;
 }
 
-MagicUnion::MagicUnion(const Napi::CallbackInfo &info)
-    : Napi::ObjectWrap<MagicUnion>(info), type((const TypeInfo *)info.Data())
+UnionClass::UnionClass(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<UnionClass>(info), type((const TypeInfo *)info.Data())
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    instance = env.GetInstanceData<InstanceData>();
+}
 
-    active_symbol.Reset(instance->active_symbol.Value(), 1);
+void UnionClass::Finalize(Napi::BasicEnv env)
+{
+    napi_ref ref = (napi_ref)*this;
+
+    if (node_api_post_finalizer) {
+        node_api_post_finalizer(env, [](napi_env env, void *data, void *) {
+            napi_ref ref = (napi_ref)data;
+            napi_delete_reference(env, ref);
+        }, (void *)ref, nullptr);
+    } else {
+        napi_delete_reference(env, ref);
+    }
+
+    SuppressDestruct();
 }
 
-void MagicUnion::SetRaw(const uint8_t *ptr)
+void UnionClass::SetRaw(const uint8_t *ptr)
 {
     raw.RemoveFrom(0);
     raw.Append(MakeSpan(ptr, type->size));
 
-    Value().Set(active_symbol.Value(), Env().Undefined());
+    Value().Set(instance->active_symbol.Value(), Env().Undefined());
     active_idx = -1;
 }
 
-Napi::Value MagicUnion::Getter(const Napi::CallbackInfo &info)
+Napi::Value UnionClass::Getter(const Napi::CallbackInfo &info)
 {
     Size idx = (Size)info.Data();
     const RecordMember &member = type->members[idx];
@@ -63,7 +77,7 @@ Napi::Value MagicUnion::Getter(const Napi::CallbackInfo &info)
     Napi::Value value;
 
     if (idx == active_idx) {
-        value = Value().Get(active_symbol.Value());
+        value = Value().Get(instance->active_symbol.Value());
     } else {
         Napi::Env env = info.Env();
 
@@ -74,7 +88,7 @@ Napi::Value MagicUnion::Getter(const Napi::CallbackInfo &info)
 
         value = Decode(env, raw.ptr, member.type);
 
-        Value().Set(active_symbol.Value(), value);
+        Value().Set(instance->active_symbol.Value(), value);
         active_idx = idx;
     }
 
@@ -82,11 +96,11 @@ Napi::Value MagicUnion::Getter(const Napi::CallbackInfo &info)
     return value;
 }
 
-void MagicUnion::Setter(const Napi::CallbackInfo &info, const Napi::Value &value)
+void UnionClass::Setter(const Napi::CallbackInfo &info, const Napi::Value &value)
 {
     Size idx = (Size)info.Data();
 
-    Value().Set(active_symbol.Value(), value);
+    Value().Set(instance->active_symbol.Value(), value);
     active_idx = idx;
 
     raw.Clear();
@@ -180,8 +194,8 @@ const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
         }
 
         return type;
-    } else if (CheckValueTag(value, &TypeInfoMarker)) {
-        Napi::External<TypeInfo> external = value.As<Napi::External<TypeInfo>>();
+    } else if (GetKindOf(env, value) == napi_external && CheckValueTag(env, value, &TypeInfoMarker)) {
+        Napi::External<TypeInfo> external = Napi::External<TypeInfo>(env, value);
         const TypeInfo *raw = external.Data();
 
         const TypeInfo *type = AlignDown(raw, 4);
@@ -458,7 +472,7 @@ TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, A
 Napi::External<TypeInfo> WrapType(Napi::Env env, const TypeInfo *type)
 {
     Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
-    SetValueTag(external, &TypeInfoMarker);
+    SetValueTag(env, external, &TypeInfoMarker);
 
     return external;
 }
@@ -520,26 +534,31 @@ bool CanStoreType(const TypeInfo *type)
     return true;
 }
 
-const char *GetValueType(const InstanceData *instance, Napi::Value value)
+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();
+    Napi::Env env = instance->env;
+    napi_valuetype kind = GetKindOf(env, value);
 
-        return cast->type->name;
-    }
+    if (kind == napi_external) {
+        if (CheckValueTag(env, value, &CastMarker)) {
+            Napi::External<ValueCast> external = Napi::External<ValueCast>(env, value);
+            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 (CheckValueTag(env, value, &TypeInfoMarker))
+            return "Type";
+        for (const TypeInfo &type: instance->types) {
+            if (type.ref.type && CheckValueTag(env, value, type.ref.type))
+                return type.name;
+        }
     }
 
-    if (value.IsArray()) {
+    if (IsArray(env, value)) {
         return "Array";
-    } else if (value.IsTypedArray()) {
-        Napi::TypedArray array = value.As<Napi::TypedArray>();
+    } else if (IsTypedArray(env, value)) {
+        Napi::TypedArray array = Napi::TypedArray(env, value);
 
         switch (array.TypedArrayType()) {
             case napi_int8_array: return "Int8Array";
@@ -555,13 +574,13 @@ const char *GetValueType(const InstanceData *instance, Napi::Value value)
             case napi_bigint64_array: return "BigInt64Array";
             case napi_biguint64_array: return "BigUint64Array";
         }
-    } else if (value.IsArrayBuffer()) {
+    } else if (IsArrayBuffer(env, value)) {
         return "ArrayBuffer";
-    } else if (value.IsBuffer()) {
+    } else if (IsBuffer(env, value)) {
         return "Buffer";
     }
 
-    switch (value.Type()) {
+    switch (kind) {
         case napi_undefined: return "Undefined";
         case napi_null: return "Null";
         case napi_boolean: return "Boolean";
@@ -578,7 +597,7 @@ const char *GetValueType(const InstanceData *instance, Napi::Value value)
     return "Unknown";
 }
 
-void SetValueTag(Napi::Value value, const void *marker)
+void SetValueTag(napi_env env, napi_value value, const void *marker)
 {
     static_assert(K_SIZE(TypeInfo) >= 16);
 
@@ -593,18 +612,18 @@ void SetValueTag(Napi::Value value, const void *marker)
     // 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);
+    napi_status status = napi_type_tag_object(env, value, tag);
     K_ASSERT(status == napi_ok);
 }
 
-bool CheckValueTag(Napi::Value value, const void *marker)
+bool CheckValueTag(napi_env env, napi_value value, const void *marker)
 {
+    K_ASSERT(IsObject(env, value) || GetKindOf(env, value) == napi_external);
+
     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);
-    }
+    const napi_type_tag *tag = (const napi_type_tag *)marker;
+    napi_check_object_type_tag(env, value, tag, &match);
 
     return match;
 }
@@ -662,16 +681,17 @@ 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) {
         Napi::Object wrapper = type->construct.New({}).As<Napi::Object>();
-        SetValueTag(wrapper, &MagicUnionMarker);
+        SetValueTag(env, wrapper, &UnionClassMarker);
 
-        MagicUnion *u = MagicUnion::Unwrap(wrapper);
+        UnionClass *u = UnionClass::Unwrap(wrapper);
         u->SetRaw(origin);
 
         return wrapper;
     }
 
     Napi::Object obj = Napi::Object::New(env);
-    DecodeObject(obj, origin, type);
+    DecodeObject(env, obj, origin, type);
+
     return obj;
 }
 
@@ -689,52 +709,64 @@ static uint32_t DecodeDynamicLength(const uint8_t *origin, const RecordMember &b
             return (uint32_t)u;
         } break;
         case PrimitiveKind::Int16: {
-            int16_t i = *(int16_t *)src;
+            int16_t i;
+            memcpy(&i, src, 2);
             return (uint32_t)i;
         } break;
         case PrimitiveKind::Int16S: {
-            int16_t i = ReverseBytes(*(int16_t *)src);
-            return (uint32_t)i;
+            int16_t i;
+            memcpy(&i, src, 2);
+            return (uint32_t)ReverseBytes(i);
         } break;
         case PrimitiveKind::UInt16: {
-            uint16_t u = *(uint16_t *)src;
+            uint16_t u;
+            memcpy(&u, src, 2);
             return (uint32_t)u;
         } break;
         case PrimitiveKind::UInt16S: {
-            uint16_t u = ReverseBytes(*(uint16_t *)src);
-            return (uint32_t)u;
+            uint16_t u;
+            memcpy(&u, src, 2);
+            return (uint32_t)ReverseBytes(u);
         } break;
         case PrimitiveKind::Int32: {
-            int32_t i = *(int32_t *)src;
+            int32_t i;
+            memcpy(&i, src, 4);
             return (uint32_t)i;
         } break;
         case PrimitiveKind::Int32S: {
-            int32_t i = ReverseBytes(*(int32_t *)src);
-            return (uint32_t)i;
+            int32_t i;
+            memcpy(&i, src, 4);
+            return (uint32_t)ReverseBytes(i);
         } break;
         case PrimitiveKind::UInt32: {
-            uint32_t u = *(uint32_t *)src;
+            uint32_t u;
+            memcpy(&u, src, 4);
             return (uint32_t)u;
         } break;
         case PrimitiveKind::UInt32S: {
-            uint32_t u = ReverseBytes(*(uint32_t *)src);
-            return (uint32_t)u;
+            uint32_t u;
+            memcpy(&u, src, 4);
+            return (uint32_t)ReverseBytes(u);
         } break;
         case PrimitiveKind::Int64: {
-            int64_t i = *(int64_t *)src;
+            int64_t i;
+            memcpy(&i, src, 8);
             return (uint32_t)i;
         } break;
         case PrimitiveKind::Int64S: {
-            int64_t i = ReverseBytes(*(int64_t *)src);
-            return (uint32_t)i;
+            int64_t i;
+            memcpy(&i, src, 8);
+            return (uint32_t)ReverseBytes(i);
         } break;
         case PrimitiveKind::UInt64: {
-            uint64_t u = *(uint64_t *)src;
+            uint64_t u;
+            memcpy(&u, src, 8);
             return (uint32_t)u;
         } break;
         case PrimitiveKind::UInt64S: {
-            uint64_t u = ReverseBytes(*(uint64_t *)src);
-            return (uint32_t)u;
+            uint64_t u;
+            memcpy(&u, src, 8);
+            return (uint32_t)ReverseBytes(u);
         } break;
 
         case PrimitiveKind::Void:
@@ -755,15 +787,25 @@ static uint32_t DecodeDynamicLength(const uint8_t *origin, const RecordMember &b
     K_UNREACHABLE();
 }
 
-void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
+static inline void SetMemberValue(napi_env env, napi_value obj, const RecordMember &member, napi_value value)
 {
-    Napi::Env env = obj.Env();
+    if (member.key) {
+        napi_value key = nullptr;
+        napi_get_reference_value(env, member.key, &key);
 
-    K_ASSERT(type->primitive == PrimitiveKind::Record);
+        napi_status status = napi_set_property(env, obj, key, value);
+        K_ASSERT(status == napi_ok);
+    } else {
+        napi_status status = napi_set_named_property(env, obj, member.name, value);
+        K_ASSERT(status == napi_ok);
+    }
+}
 
-    for (Size i = 0; i < type->members.len; i++) {
-        const RecordMember &member = type->members[i];
+void DecodeObject(Napi::Env env, napi_value obj, const uint8_t *origin, const TypeInfo *type)
+{
+    K_ASSERT(type->primitive == PrimitiveKind::Record);
 
+    for (const RecordMember &member: type->members) {
         const uint8_t *src = origin + member.offset;
 
         switch (member.type->primitive) {
@@ -771,119 +813,133 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
 
             case PrimitiveKind::Bool: {
                 bool b = *(bool *)src;
-                obj.Set(member.name, Napi::Boolean::New(env, b));
+                SetMemberValue(env, obj, member, Napi::Boolean::New(env, b));
             } break;
             case PrimitiveKind::Int8: {
-                double d = (double)*(int8_t *)src;
-                obj.Set(member.name, Napi::Number::New(env, d));
+                int8_t i = *(int8_t *)src;
+                SetMemberValue(env, obj, member, NewInt(env, i));
             } break;
             case PrimitiveKind::UInt8: {
-                double d = (double)*(uint8_t *)src;
-                obj.Set(member.name, Napi::Number::New(env, d));
+                uint8_t u = *(uint8_t *)src;
+                SetMemberValue(env, obj, member, NewInt(env, u));
             } break;
             case PrimitiveKind::Int16: {
-                double d = (double)*(int16_t *)src;
-                obj.Set(member.name, Napi::Number::New(env, d));
+                int16_t i;
+                memcpy(&i, src, 2);
+                SetMemberValue(env, obj, member, NewInt(env, i));
             } break;
             case PrimitiveKind::Int16S: {
-                int16_t v = *(int16_t *)src;
-                double d = (double)ReverseBytes(v);
-
-                obj.Set(member.name, Napi::Number::New(env, d));
+                int16_t i;
+                memcpy(&i, src, 2);
+                SetMemberValue(env, obj, member, NewInt(env, ReverseBytes(i)));
             } break;
             case PrimitiveKind::UInt16: {
-                double d = (double)*(uint16_t *)src;
-                obj.Set(member.name, Napi::Number::New(env, d));
+                uint16_t u;
+                memcpy(&u, src, 2);
+                SetMemberValue(env, obj, member, NewInt(env, u));
             } break;
             case PrimitiveKind::UInt16S: {
-                uint16_t v = *(uint16_t *)src;
-                double d = (double)ReverseBytes(v);
-
-                obj.Set(member.name, Napi::Number::New(env, d));
+                uint16_t u;
+                memcpy(&u, src, 2);
+                SetMemberValue(env, obj, member, NewInt(env, ReverseBytes(u)));
             } break;
             case PrimitiveKind::Int32: {
-                double d = (double)*(int32_t *)src;
-                obj.Set(member.name, Napi::Number::New(env, d));
+                int32_t i;
+                memcpy(&i, src, 4);
+                SetMemberValue(env, obj, member, NewInt(env, i));
             } break;
             case PrimitiveKind::Int32S: {
-                int32_t v = *(int32_t *)src;
-                double d = (double)ReverseBytes(v);
-
-                obj.Set(member.name, Napi::Number::New(env, d));
+                int32_t i;
+                memcpy(&i, src, 4);
+                SetMemberValue(env, obj, member, NewInt(env, ReverseBytes(i)));
             } break;
             case PrimitiveKind::UInt32: {
-                double d = (double)*(uint32_t *)src;
-                obj.Set(member.name, Napi::Number::New(env, d));
+                uint32_t u;
+                memcpy(&u, src, 4);
+                SetMemberValue(env, obj, member, NewInt(env, u));
             } break;
             case PrimitiveKind::UInt32S: {
-                uint32_t v = *(uint32_t *)src;
-                double d = (double)ReverseBytes(v);
-
-                obj.Set(member.name, Napi::Number::New(env, d));
+                uint32_t u;
+                memcpy(&u, src, 4);
+                SetMemberValue(env, obj, member, NewInt(env, ReverseBytes(u)));
             } break;
             case PrimitiveKind::Int64: {
-                int64_t v = *(int64_t *)src;
-                obj.Set(member.name, NewBigInt(env, v));
+                int64_t i;
+                memcpy(&i, src, 8);
+                SetMemberValue(env, obj, member, NewInt(env, i));
             } break;
             case PrimitiveKind::Int64S: {
-                int64_t v = ReverseBytes(*(int64_t *)src);
-                obj.Set(member.name, NewBigInt(env, v));
+                int64_t i;
+                memcpy(&i, src, 8);
+                SetMemberValue(env, obj, member, NewInt(env, ReverseBytes(i)));
             } break;
             case PrimitiveKind::UInt64: {
-                uint64_t v = *(uint64_t *)src;
-                obj.Set(member.name, NewBigInt(env, v));
+                uint64_t u;
+                memcpy(&u, src, 8);
+                SetMemberValue(env, obj, member, NewInt(env, u));
             } break;
             case PrimitiveKind::UInt64S: {
-                uint64_t v = ReverseBytes(*(uint64_t *)src);
-                obj.Set(member.name, NewBigInt(env, v));
+                uint64_t u;
+                memcpy(&u, src, 8);
+                SetMemberValue(env, obj, member, NewInt(env, ReverseBytes(u)));
             } break;
             case PrimitiveKind::String: {
-                const char *str = *(const char **)src;
-                obj.Set(member.name, str ? Napi::String::New(env, str) : env.Null());
+                const char *str;
+                memcpy(&str, src, K_SIZE(void *));
+                SetMemberValue(env, obj, member, 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());
+                const char16_t *str16;
+                memcpy(&str16, src, K_SIZE(void *));
+                SetMemberValue(env, obj, member, 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());
+                const char32_t *str32;
+                memcpy(&str32, src, K_SIZE(void *));
+                SetMemberValue(env, obj, member, str32 ? MakeStringFromUTF32(env, str32) : env.Null());
             } break;
-            case PrimitiveKind::Pointer:
-            case PrimitiveKind::Callback: {
-                void *ptr2 = *(void **)src;
+            case PrimitiveKind::Pointer: {
+                void *ptr2;
+                memcpy(&ptr2, src, K_SIZE(void *));
 
                 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);
+                    SetMemberValue(env, obj, member, value);
                 } else {
-                    obj.Set(member.name, env.Null());
+                    Napi::Value p = ptr2 ? WrapPointer(env, member.type->ref.type, ptr2) : env.Null();
+                    SetMemberValue(env, obj, member, p);
                 }
 
                 if (member.type->dispose) {
                     member.type->dispose(env, member.type, ptr2);
                 }
             } break;
+            case PrimitiveKind::Callback: {
+                void *ptr2;
+                memcpy(&ptr2, src, K_SIZE(void *));
+
+                Napi::Value p = ptr2 ? WrapCallback(env, member.type->ref.type, ptr2) : env.Null();
+                SetMemberValue(env, obj, member, p);
+
+                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);
+                SetMemberValue(env, obj, member, obj2);
             } break;
             case PrimitiveKind::Array: {
                 if (member.countedby >= 0) {
@@ -896,19 +952,21 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
                     len = std::min(len, max);
 
                     Napi::Value value = DecodeArray(env, src, member.type, len);
-                    obj.Set(member.name, value);
+                    SetMemberValue(env, obj, member, value);
                 } else {
                     Napi::Value value = DecodeArray(env, src, member.type);
-                    obj.Set(member.name, value);
+                    SetMemberValue(env, obj, member, value);
                 }
             } break;
             case PrimitiveKind::Float32: {
-                float f = *(float *)src;
-                obj.Set(member.name, Napi::Number::New(env, (double)f));
+                float f;
+                memcpy(&f, src, 4);
+                SetMemberValue(env, obj, member, Napi::Number::New(env, (double)f));
             } break;
             case PrimitiveKind::Float64: {
-                double d = *(double *)src;
-                obj.Set(member.name, Napi::Number::New(env, d));
+                double d;
+                memcpy(&d, src, 8);
+                SetMemberValue(env, obj, member, Napi::Number::New(env, d));
             } break;
 
             case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
@@ -916,208 +974,129 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
     }
 }
 
+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);
+}
+
 Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type, uint32_t len)
 {
-    Size offset = 0;
+    K_ASSERT(type->primitive == PrimitiveKind::Array || type->primitive == PrimitiveKind::Pointer);
 
-#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 { \
+    const TypeInfo *ref = type->ref.type;
+
+    if (type->hint == ArrayHint::Typed) {
+#define POP_TYPEDARRAY(TypedArrayType, CType) \
+            do { \
                 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); \
+                DecodeBuffer(buffer, origin, ref); \
                  \
                 return array; \
-            } \
-        } while (false)
-
-    switch (type->ref.type->primitive) {
-        case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
+            } while (false)
+
+        switch (ref->primitive) {
+            case PrimitiveKind::Int8: { POP_TYPEDARRAY(Int8Array, int8_t); } break;
+            case PrimitiveKind::UInt8: { POP_TYPEDARRAY(Uint8Array, uint8_t); } break;
+            case PrimitiveKind::Int16: { POP_TYPEDARRAY(Int16Array, int16_t); } break;
+            case PrimitiveKind::Int16S: { POP_TYPEDARRAY(Int16Array, int16_t); } break;
+            case PrimitiveKind::UInt16: { POP_TYPEDARRAY(Uint16Array, uint16_t); } break;
+            case PrimitiveKind::UInt16S: { POP_TYPEDARRAY(Uint16Array, uint16_t); } break;
+            case PrimitiveKind::Int32: { POP_TYPEDARRAY(Int32Array, int32_t); } break;
+            case PrimitiveKind::Int32S: { POP_TYPEDARRAY(Int32Array, int32_t); } break;
+            case PrimitiveKind::UInt32: { POP_TYPEDARRAY(Uint32Array, uint32_t); } break;
+            case PrimitiveKind::UInt32S: { POP_TYPEDARRAY(Uint32Array, uint32_t); } break;
+            case PrimitiveKind::Float32: { POP_TYPEDARRAY(Float32Array, float); } break;
+            case PrimitiveKind::Float64: { POP_TYPEDARRAY(Float64Array, double); } break;
+
+            case PrimitiveKind::Void:
+            case PrimitiveKind::Bool:
+            case PrimitiveKind::Int64:
+            case PrimitiveKind::Int64S:
+            case PrimitiveKind::UInt64:
+            case PrimitiveKind::UInt64S:
+            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::Prototype: { 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) {
+#undef POP_TYPEDARRAY
+    } else if (type->hint == ArrayHint::String) {
+        switch (ref->primitive) {
+            case PrimitiveKind::Int8: {
                 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) {
+            } break;
+            case PrimitiveKind::Int16: {
                 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) {
+            } break;
+            case PrimitiveKind::Int32: {
                 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;
+            } break;
 
-                if (ptr2) {
-                    Napi::External<void> external = Napi::External<void>::New(env, ptr2);
-                    SetValueTag(external, type->ref.type->ref.marker);
+            case PrimitiveKind::Void:
+            case PrimitiveKind::Bool:
+            case PrimitiveKind::UInt8:
+            case PrimitiveKind::Int16S:
+            case PrimitiveKind::UInt16:
+            case PrimitiveKind::UInt16S:
+            case PrimitiveKind::Int32S:
+            case PrimitiveKind::UInt32:
+            case PrimitiveKind::UInt32S:
+            case PrimitiveKind::Int64:
+            case PrimitiveKind::Int64S:
+            case PrimitiveKind::UInt64:
+            case PrimitiveKind::UInt64S:
+            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;
+        }
+    } else {
+        K_ASSERT(type->hint == ArrayHint::Array);
 
-                    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;
+        Napi::Array array = Napi::Array::New(env);
+        DecodeElements(env, array, origin, type->ref.type, len);
 
-        case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
+        return array;
     }
 
-#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)
+void DecodeElements(Napi::Env env, napi_value array, const uint8_t *origin, const TypeInfo *ref, uint32_t len)
 {
-    Napi::Env env = array.Env();
-
-    K_ASSERT(array.IsArray());
+    K_ASSERT(IsArray(env, array));
 
     Size offset = 0;
-    uint32_t len = array.Length();
 
 #define POP_ARRAY(SetCode) \
         do { \
@@ -1131,19 +1110,19 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
                 offset += ref->size; \
             } \
         } while (false)
-#define POP_NUMBER_ARRAY(CType) \
+
+#define POP_INTEGERS(CType) \
         do { \
             POP_ARRAY({ \
-                double d = (double)*(CType *)src; \
-                array.Set(i, Napi::Number::New(env, d)); \
+                CType v = *(CType *)src; \
+                napi_set_element(env, array, i, NewInt(env, v)); \
             }); \
         } while (false)
-#define POP_NUMBER_ARRAY_SWAP(CType) \
+#define POP_INTEGERS_SWAP(CType) \
         do { \
             POP_ARRAY({ \
                 CType v = *(CType *)src; \
-                double d = (double)ReverseBytes(v); \
-                array.Set(i, Napi::Number::New(env, d)); \
+                napi_set_element(env, array, i, NewInt(env, ReverseBytes(v))); \
             }); \
         } while (false)
 
@@ -1153,47 +1132,27 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
         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));
+                napi_set_element(env, array, i, Napi::Boolean::New(env, b));
             });
         } break;
+        case PrimitiveKind::Int8: { POP_INTEGERS(int8_t); } break;
+        case PrimitiveKind::UInt8: { POP_INTEGERS(uint8_t); } break;
+        case PrimitiveKind::Int16: { POP_INTEGERS(int16_t); } break;
+        case PrimitiveKind::Int16S: { POP_INTEGERS_SWAP(int16_t); } break;
+        case PrimitiveKind::UInt16: { POP_INTEGERS(uint16_t); } break;
+        case PrimitiveKind::UInt16S: { POP_INTEGERS_SWAP(uint16_t); } break;
+        case PrimitiveKind::Int32: { POP_INTEGERS(int32_t); } break;
+        case PrimitiveKind::Int32S: { POP_INTEGERS_SWAP(int32_t); } break;
+        case PrimitiveKind::UInt32: { POP_INTEGERS(uint32_t); } break;
+        case PrimitiveKind::UInt32S: { POP_INTEGERS_SWAP(uint32_t); } break;
+        case PrimitiveKind::Int64: { POP_INTEGERS(int64_t); } break;
+        case PrimitiveKind::Int64S: { POP_INTEGERS_SWAP(int64_t); } break;
+        case PrimitiveKind::UInt64: { POP_INTEGERS(uint64_t); } break;
+        case PrimitiveKind::UInt64S: { POP_INTEGERS_SWAP(uint64_t); } break;
         case PrimitiveKind::String: {
             POP_ARRAY({
                 const char *str = *(const char **)src;
-                array.Set(i, str ? Napi::String::New(env, str) : env.Null());
+                napi_set_element(env, array, i, str ? Napi::String::New(env, str) : env.Null());
 
                 if (ref->dispose) {
                     ref->dispose(env, ref, str);
@@ -1203,7 +1162,7 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
         case PrimitiveKind::String16: {
             POP_ARRAY({
                 const char16_t *str16 = *(const char16_t **)src;
-                array.Set(i, str16 ? Napi::String::New(env, str16) : env.Null());
+                napi_set_element(env, array, i, str16 ? Napi::String::New(env, str16) : env.Null());
 
                 if (ref->dispose) {
                     ref->dispose(env, ref, str16);
@@ -1213,26 +1172,31 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
         case PrimitiveKind::String32: {
             POP_ARRAY({
                 const char32_t *str32 = *(const char32_t **)src;
-                array.Set(i, str32 ? MakeStringFromUTF32(env, str32) : env.Null());
+                napi_set_element(env, array, i, str32 ? MakeStringFromUTF32(env, str32) : env.Null());
 
                 if (ref->dispose) {
                     ref->dispose(env, ref, str32);
                 }
             });
         } break;
-        case PrimitiveKind::Pointer:
-        case PrimitiveKind::Callback: {
+        case PrimitiveKind::Pointer: {
             POP_ARRAY({
                 void *ptr2 = *(void **)src;
 
-                if (ptr2) {
-                    Napi::External<void> external = Napi::External<void>::New(env, ptr2);
-                    SetValueTag(external, ref->ref.marker);
+                Napi::Value p = ptr2 ? WrapPointer(env, ref->ref.type, ptr2) : env.Null();
+                napi_set_element(env, array, i, p);
 
-                    array.Set(i, external);
-                } else {
-                    array.Set(i, env.Null());
+                if (ref->dispose) {
+                    ref->dispose(env, ref, ptr2);
                 }
+            });
+        } break;
+        case PrimitiveKind::Callback: {
+            POP_ARRAY({
+                void *ptr2 = *(void **)src;
+
+                Napi::Value p = ptr2 ? WrapCallback(env, ref->ref.type, ptr2) : env.Null();
+                napi_set_element(env, array, i, p);
 
                 if (ref->dispose) {
                     ref->dispose(env, ref, ptr2);
@@ -1243,23 +1207,38 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
         case PrimitiveKind::Union: {
             POP_ARRAY({
                 Napi::Object obj = DecodeObject(env, src, ref);
-                array.Set(i, obj);
+                napi_set_element(env, array, i, obj);
             });
         } break;
         case PrimitiveKind::Array: {
             POP_ARRAY({
                 Napi::Value value = DecodeArray(env, src, ref);
-                array.Set(i, value);
+                napi_set_element(env, array, i, value);
+            });
+        } break;
+        case PrimitiveKind::Float32: {
+            POP_ARRAY({
+                float f;
+                memcpy(&f, src, 4);
+
+                napi_set_element(env, array, i, Napi::Number::New(env, (double)f));
+            });
+        } break;
+        case PrimitiveKind::Float64: {
+            POP_ARRAY({
+                double d;
+                memcpy(&d, src, 8);
+
+                napi_set_element(env, array, i, Napi::Number::New(env, d));
             });
         } 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_INTEGERS_SWAP
+#undef POP_INTEGERS
+
 #undef POP_ARRAY
 }
 
@@ -1294,14 +1273,9 @@ Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const S
     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);
+    const uint8_t *src = nullptr;
 
+    if (Span<uint8_t> buffer = {}; TryBuffer(env, value, &buffer)) {
         if (offset < 0) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Offset must be >= 0");
             return env.Null();
@@ -1312,17 +1286,19 @@ Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const S
             return env.Null();
         }
 
-        ptr = (const uint8_t *)buffer.ptr;
+        src = (const uint8_t *)buffer.ptr;
+    } else if (void *ptr = nullptr; TryPointer(env, value, &ptr)) {
+        src = (const uint8_t *)ptr;
     } else {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for variable, expected external or TypedArray", GetValueType(instance, value));
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for variable, expected pointer", GetValueType(instance, value));
         return env.Null();
     }
 
-    if (!ptr)
+    if (!src)
         return env.Null();
-    ptr += offset;
+    src += offset;
 
-    Napi::Value ret = Decode(env, ptr, type, len);
+    Napi::Value ret = Decode(env, src, type, len);
     return ret;
 }
 
@@ -1345,17 +1321,17 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
                 } break;
                 case PrimitiveKind::Int16:
                 case PrimitiveKind::UInt16: {
-                    Size count = NullTerminatedLength((const char16_t *)ptr, K_SIZE_MAX);
+                    Size count = NullTerminatedLength((const char16_t *)ptr);
                     type = MakeArrayType(instance, type, count);
                 } break;
                 case PrimitiveKind::Int32:
                 case PrimitiveKind::UInt32: {
-                    Size count = NullTerminatedLength((const char32_t *)ptr, K_SIZE_MAX);
+                    Size count = NullTerminatedLength((const char32_t *)ptr);
                     type = MakeArrayType(instance, type, count);
                 } break;
 
                 case PrimitiveKind::Pointer: {
-                    Size count = NullTerminatedLength((const void **)ptr, K_SIZE_MAX);
+                    Size count = NullTerminatedLength((const void **)ptr);
                     type = MakeArrayType(instance, type, count);
                 } break;
 
@@ -1388,20 +1364,20 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
             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::Int8: { RETURN_INT(int8_t, NewInt); } break;
+        case PrimitiveKind::UInt8: { RETURN_INT(uint8_t, NewInt); } break;
+        case PrimitiveKind::Int16: { RETURN_INT(int16_t, NewInt); } break;
+        case PrimitiveKind::Int16S: { RETURN_INT_SWAP(int16_t, NewInt); } break;
+        case PrimitiveKind::UInt16: { RETURN_INT(uint16_t, NewInt); } break;
+        case PrimitiveKind::UInt16S: { RETURN_INT_SWAP(uint16_t, NewInt); } break;
+        case PrimitiveKind::Int32: { RETURN_INT(int32_t, NewInt); } break;
+        case PrimitiveKind::Int32S: { RETURN_INT_SWAP(int32_t, NewInt); } break;
+        case PrimitiveKind::UInt32: { RETURN_INT(uint32_t, NewInt); } break;
+        case PrimitiveKind::UInt32S: { RETURN_INT_SWAP(uint32_t, NewInt); } break;
+        case PrimitiveKind::Int64: { RETURN_INT(int64_t, NewInt); } break;
+        case PrimitiveKind::Int64S: { RETURN_INT_SWAP(int64_t, NewInt); } break;
+        case PrimitiveKind::UInt64: { RETURN_INT(uint64_t, NewInt); } break;
+        case PrimitiveKind::UInt64S: { RETURN_INT_SWAP(uint64_t, NewInt); } break;
         case PrimitiveKind::String: {
             if (len) {
                 const char *str = *(const char **)ptr;
@@ -1429,10 +1405,13 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
                 return str32 ? MakeStringFromUTF32(env, str32) : env.Null();
             }
         } break;
-        case PrimitiveKind::Pointer:
+        case PrimitiveKind::Pointer: {
+            void *ptr2 = *(void **)ptr;
+            return ptr2 ? WrapPointer(env, type->ref.type, ptr2) : env.Null();
+        } break;
         case PrimitiveKind::Callback: {
             void *ptr2 = *(void **)ptr;
-            return ptr2 ? Napi::External<void>::New(env, ptr2, [](Napi::Env, void *) {}) : env.Null();
+            return ptr2 ? WrapCallback(env, type->ref.type, ptr2) : env.Null();
         } break;
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: {
@@ -1444,11 +1423,15 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
             return array;
         } break;
         case PrimitiveKind::Float32: {
-            float f = *(float *)ptr;
-            return Napi::Number::New(env, f);
+            float f;
+            memcpy(&f, ptr, 4);
+
+            return Napi::Number::New(env, (double)f);
         } break;
         case PrimitiveKind::Float64: {
-            double d = *(double *)ptr;
+            double d;
+            memcpy(&d, ptr, 8);
+
             return Napi::Number::New(env, d);
         } break;
 
@@ -1462,16 +1445,14 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
 
             memcpy((void *)func, proto, K_SIZE(*proto));
             memset((void *)&func->parameters, 0, K_SIZE(func->parameters));
-            func->parameters = proto->parameters;
+            memset((void *)&func->sync, 0, K_SIZE(func->sync));
+            memset((void *)&func->async, 0, K_SIZE(func->async));
 
             func->name = "<anonymous>";
             func->native = (void *)ptr;
-
-            // Fix back parameter offset
-            for (ParameterInfo &param: func->parameters) {
-                param.offset -= 2;
-            }
-            func->required_parameters -= 2;
+            func->parameters = proto->parameters;
+            func->sync = proto->sync;
+            func->async = proto->async;
 
             Napi::Function wrapper = WrapFunction(env, func);
             return wrapper;
@@ -1489,14 +1470,9 @@ bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *typ
     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);
+    uint8_t *dest = nullptr;
 
+    if (Span<uint8_t> buffer = {}; TryBuffer(env, ref, &buffer)) {
         if (offset < 0) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Offset must be >= 0");
             return env.Null();
@@ -1507,19 +1483,21 @@ bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *typ
             return env.Null();
         }
 
-        ptr = (uint8_t *)buffer.ptr;
+        dest = (uint8_t *)buffer.ptr;
+    } else if (void *ptr = nullptr; TryPointer(env, ref, &ptr)) {
+        dest = (uint8_t *)ptr;
     } else {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for reference, expected external or TypedArray", GetValueType(instance, ref));
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for reference, expected pointer", GetValueType(instance, ref));
         return env.Null();
     }
 
-    if (!ptr) [[unlikely]] {
+    if (!dest) [[unlikely]] {
         ThrowError<Napi::Error>(env, "Cannot encode data in NULL pointer");
         return env.Null();
     }
-    ptr += offset;
+    dest += offset;
 
-    return Encode(env, ptr, value, type, len);
+    return Encode(env, dest, value, type, len);
 }
 
 bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *type, const Size *len)
@@ -1539,26 +1517,26 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
     }
 
     InstanceMemory mem = {};
-    CallData call(env, instance, &mem);
+    CallData call(env, instance, &mem, nullptr);
 
 #define PUSH_INTEGER(CType) \
         do { \
-            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
+            CType v; \
+            if (!TryNumber(env, value, &v)) [[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]] { \
+            CType v; \
+            if (!TryNumber(env, value, &v)) [[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)
 
@@ -1566,12 +1544,14 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
         case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
 
         case PrimitiveKind::Bool: {
-            if (!value.IsBoolean()) [[unlikely]] {
+            bool b;
+            napi_status status = napi_get_value_bool(env, value, &b);
+
+            if (status != napi_ok) [[unlikely]] {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected boolean", GetValueType(instance, value));
                 return false;
             }
 
-            bool b = value.As<Napi::Boolean>();
             *(bool *)origin = b;
         } break;
         case PrimitiveKind::Int8: { PUSH_INTEGER(int8_t); } break;
@@ -1614,7 +1594,7 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
         } break;
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: {
-            if (!IsObject(value)) [[unlikely]] {
+            if (!IsObject(env, value)) [[unlikely]] {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                 return false;
             }
@@ -1626,11 +1606,10 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
         } break;
         case PrimitiveKind::Array: {
             if (value.IsArray()) {
-                Napi::Array array = value.As<Napi::Array>();
+                Napi::Array array = Napi::Array(env, value);
                 if (!call.PushNormalArray(array, type, type->size, origin))
                     return false;
-            } else if (IsRawBuffer(value)) {
-                Span<const uint8_t> buffer = GetRawBuffer(value);
+            } else if (Span<uint8_t> buffer = {}; TryBuffer(env, value, &buffer)) {
                 call.PushBuffer(buffer, type, origin);
             } else if (value.IsString()) {
                 if (!call.PushStringArray(value, type, origin))
@@ -1641,35 +1620,31 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
             }
         } break;
         case PrimitiveKind::Float32: {
-            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+            float f;
+            if (!TryNumber(env, value, &f)) [[unlikely]] {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                 return false;
             }
 
-            float f = GetNumber<float>(value);
-            *(float *)origin = f;
+            memcpy(origin, &f, 4);
         } break;
         case PrimitiveKind::Float64: {
-            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+            double d;
+            if (!TryNumber(env, value, &d)) [[unlikely]] {
                 ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                 return false;
             }
 
-            double d = GetNumber<double>(value);
-            *(double *)origin = d;
+            memcpy(origin, &d, 8);
         } 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);
+            if (!TryPointer(env, value, &ptr)) [[unlikely]] {
+                if (value.IsFunction()) {
+                    ThrowError<Napi::Error>(env, "Cannot encode non-registered callback");
+                } else {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected %2", GetValueType(instance, value), type->name);
+                }
                 return false;
             }
 
@@ -1683,15 +1658,53 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
 #undef PUSH_INTEGER
 
     // Keep memory around if any was allocated
-    if (call.alloc.IsUsed()) {
-        BlockAllocator *copy = instance->encode_map.FindValue(origin, nullptr);
+    if (mem.allocator.IsUsed()) {
+        LinkedAllocator *copy = instance->encode_map.FindValue(origin, nullptr);
 
         if (!copy) {
             copy = instance->encode_allocators.AppendDefault();
             instance->encode_map.Set(origin, copy);
         }
 
-        std::swap(call.alloc, *copy);
+        std::swap(mem.allocator, *copy);
+    }
+
+    return true;
+}
+
+static bool CanTypeAcceptCallbacks(const TypeInfo *type)
+{
+    if (type->primitive == PrimitiveKind::Pointer)
+        return true;
+    if (type->primitive == PrimitiveKind::Callback)
+        return true;
+
+    if (type->primitive == PrimitiveKind::Record ||
+            type->primitive == PrimitiveKind::Union) {
+        for (const RecordMember &member: type->members) {
+            if (CanTypeAcceptCallbacks(member.type))
+                return false;
+        }
+    }
+
+    return true;
+}
+
+static bool CanUseFastCall(const FunctionInfo *func)
+{
+    if (func->parameters.len > 6)
+        return false;
+
+    // Fast calls basically skip CallData::Finalize(), which handles output arguments
+    // and temporary callback trampolines. If the function does not use any
+    // output argument and cannot accept callbacks (so no pointer or callback arguments),
+    // we can skip finalization!
+
+    for (const ParameterInfo &param: func->parameters) {
+        if (param.directions & 2)
+            return false;
+        if (CanTypeAcceptCallbacks(param.type))
+            return false;
     }
 
     return true;
@@ -1700,20 +1713,38 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
 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());
+
+    // Pick appropriate wrapper
+    {
+        napi_value value;
+
+        if (func->variadic) {
+            napi_status status = napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateVariadicCall, (void *)func->Ref(), &value);
+            K_ASSERT(status == napi_ok);
+        } else if (!func->parameters.len) {
+            InstanceData *instance = env.GetInstanceData<InstanceData>();
+            napi_status status = napi_create_function(env, func->name, NAPI_AUTO_LENGTH, instance->translate_zero_call, (void *)func->Ref(), &value);
+            K_ASSERT(status == napi_ok);
+        } else if (CanUseFastCall(func)) {
+            napi_status status = napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateFastCall, (void *)func->Ref(), &value);
+            K_ASSERT(status == napi_ok);
+        } else {
+            napi_status status = napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateNormalCall, (void *)func->Ref(), &value);
+            K_ASSERT(status == napi_ok);
+        }
+
+        wrapper = Napi::Function(env, value);
+        wrapper.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, (FunctionInfo *)func);
     }
-    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());
+        napi_value value;
+        napi_status status = napi_create_function(env, func->name, NAPI_AUTO_LENGTH, TranslateAsyncCall, (void *)func->Ref(), &value);
+        K_ASSERT(status == napi_ok);
 
+        Napi::Function async = Napi::Function(env, value);
         async.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, (FunctionInfo *)func);
+
         wrapper.Set("async", async);
     }
 
@@ -1737,6 +1768,32 @@ Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func)
     return wrapper;
 }
 
+Napi::Value WrapPointer(Napi::Env env, const TypeInfo *ref, void *ptr)
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (instance->config.fast_pointers) {
+        Napi::BigInt big = Napi::BigInt::New(env, (uint64_t)(uintptr_t)ptr);
+        return big;
+    } else {
+        Napi::External<void> external = Napi::External<void>::New(env, ptr);
+        return external;
+    }
+}
+
+Napi::Value WrapCallback(Napi::Env env, const TypeInfo *ref, void *ptr)
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (instance->config.fast_callbacks) {
+        Napi::BigInt big = Napi::BigInt::New(env, (uint64_t)(uintptr_t)ptr);
+        return big;
+    } else {
+        Napi::External<void> external = Napi::External<void>::New(env, ptr);
+        return external;
+    }
+}
+
 bool DetectCallConvention(Span<const char> name, CallConvention *out_convention)
 {
     if (name == "__cdecl") {