koffi 2.16.0-beta.2 → 2.16.1

package/src/koffi/src/ffi.hh

@@ -22,18 +22,70 @@ static const Size MaxParameters = 64;
 static const Size MaxTrampolines = 8192;
 
 enum class PrimitiveKind {
-    #define PRIMITIVE(Name) Name,
-    #include "primitives.inc"
+    // Void is explictly not first so that it is not 0, for reasons related to N-API type tags.
+    // Look at TypeInfo definition for more information!
+    Bool,
+    Void,
+    Int8,
+    UInt8,
+    Int16,
+    Int16S,  // Keep behind Int16
+    UInt16,
+    UInt16S, // Keep behind UInt16
+    Int32,
+    Int32S,  // Keep behind Int32
+    UInt32,
+    UInt32S, // Keep behind UInt32
+    Int64,
+    Int64S,  // Keep behind Int64
+    UInt64,
+    UInt64S, // Keep behind UInt64
+    String,
+    String16,
+    String32,
+    Pointer,
+    Record,
+    Union,
+    Array,
+    Float32,
+    Float64,
+    Prototype,
+    Callback
 };
 static const char *const PrimitiveKindNames[] = {
-    #define PRIMITIVE(Name) K_STRINGIFY(Name),
-    #include "primitives.inc"
+    "Bool",
+    "Void",
+    "Int8",
+    "UInt8",
+    "Int16",
+    "Int16S",
+    "UInt16",
+    "UInt16S",
+    "Int32",
+    "Int32S",
+    "UInt32",
+    "UInt32S",
+    "Int64",
+    "Int64S",
+    "UInt64",
+    "UInt64S",
+    "String",
+    "String16",
+    "String32",
+    "Pointer",
+    "Record",
+    "Union",
+    "Array",
+    "Float32",
+    "Float64",
+    "Prototype",
+    "Callback"
 };
 
 struct TypeInfo;
 struct RecordMember;
 struct FunctionInfo;
-class CallData;
+struct CallData;
 
 typedef void DisposeFunc (Napi::Env env, const TypeInfo *type, const void *ptr);
 
@@ -57,7 +109,7 @@ static const char *const ArrayHintNames[] = {
 struct TypeInfo {
     const char *name;
 
-    // Make sure primitive ends up as the upper N-API tag value when we cast TypeInfo pointers to
+    // Make sure primitie ends up as the upper N-API tag value when we cast TypeInfo pointers to
     // napi_type_tag pointers. Yes, I want to do this. We don't do strict aliasing here.
     // N.B. Some node versions don't like when one of the two tag values is 0, so make sure
     // this does not happen! It would happen if primitive is 0 and size is 0. To avoid this
@@ -72,6 +124,7 @@ struct TypeInfo {
 
     HeapArray<RecordMember> members; // Record only
     union {
+        const void *marker;
         const TypeInfo *type; // Pointer or array
         const FunctionInfo *proto; // Callback only
     } ref;
@@ -170,7 +223,6 @@ struct FunctionInfo {
 
     ParameterInfo ret;
     HeapArray<ParameterInfo> parameters;
-    HeapArray<PrimitiveKind> primitives;
     int8_t required_parameters;
     int8_t out_parameters;
     bool variadic;
@@ -197,8 +249,6 @@ struct InstanceMemory {
     Span<uint8_t> stack0;
     Span<uint8_t> heap;
 
-    uint16_t generation; // Can wrap without risk
-
     bool busy;
     bool temporary;
     int depth;
@@ -228,9 +278,6 @@ struct InstanceData {
     LocalArray<InstanceMemory *, 17> memories;
     int temporaries = 0;
 
-    // Variadic cache
-    FunctionInfo *variadic_func = nullptr;
-
     std::thread::id main_thread_id;
     napi_threadsafe_function broker = nullptr;
 
@@ -256,9 +303,6 @@ struct InstanceData {
         int resident_async_pools = DefaultResidentAsyncPools;
         int max_temporaries = DefaultMaxAsyncCalls - DefaultResidentAsyncPools;
         Size max_type_size = DefaultMaxTypeSize;
-
-        bool fast_pointers = false;
-        bool fast_callbacks = false;
     } config;
 
     struct {
@@ -276,7 +320,7 @@ struct TrampolineInfo {
     Napi::FunctionReference func;
     Napi::Reference<Napi::Value> recv;
 
-    int32_t generation;
+    bool used;
 };
 
 struct SharedData {

package/src/koffi/src/init.js

@@ -38,6 +38,7 @@ function init(triplet, native) {
         }
 
         let filenames = roots.flatMap(root => triplets.flatMap(triplet => [
+            `${root}/koffi/build/koffi/${triplet}/koffi.node`,
             `${root}/build/koffi/${triplet}/koffi.node`,
             `${root}/koffi/${triplet}/koffi.node`,
             `${root}/node_modules/koffi/build/koffi/${triplet}/koffi.node`,

package/src/koffi/src/util.cc

@@ -532,7 +532,7 @@ const char *GetValueType(const InstanceData *instance, Napi::Value value)
     if (CheckValueTag(value, &TypeInfoMarker))
         return "Type";
     for (const TypeInfo &type: instance->types) {
-        if (type.ref.type && CheckValueTag(value, type.ref.type))
+        if (type.ref.marker && CheckValueTag(value, type.ref.marker))
             return type.name;
     }
 
@@ -857,7 +857,8 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
                 const char32_t *str32 = *(const char32_t **)src;
                 obj.Set(member.name, str32 ? MakeStringFromUTF32(env, str32) : env.Null());
             } break;
-            case PrimitiveKind::Pointer: {
+            case PrimitiveKind::Pointer:
+            case PrimitiveKind::Callback: {
                 void *ptr2 = *(void **)src;
 
                 if (member.countedby >= 0) {
@@ -866,20 +867,14 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
 
                     Napi::Value value = DecodeArray(env, (const uint8_t *)ptr2, member.type, len);
                     obj.Set(member.name, value);
-                } else {
-                    Napi::Value p = ptr2 ? WrapPointer(env, member.type->ref.type, ptr2) : env.Null();
-                    obj.Set(member.name, p);
-                }
+                } else if (ptr2) {
+                    Napi::External<void> external = Napi::External<void>::New(env, ptr2);
+                    SetValueTag(external, member.type->ref.marker);
 
-                if (member.type->dispose) {
-                    member.type->dispose(env, member.type, ptr2);
+                    obj.Set(member.name, external);
+                } else {
+                    obj.Set(member.name, env.Null());
                 }
-            } break;
-            case PrimitiveKind::Callback: {
-                void *ptr2 = *(void **)src;
-
-                Napi::Value p = ptr2 ? WrapCallback(env, member.type->ref.type, ptr2) : env.Null();
-                obj.Set(member.name, p);
 
                 if (member.type->dispose) {
                     member.type->dispose(env, member.type, ptr2);
@@ -941,8 +936,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
              \
             return array; \
         } while (false)
-
-#define POP_NUMBERS(TypedArrayType, CType) \
+#define POP_NUMBER_ARRAY(TypedArrayType, CType) \
         do { \
             if (type->hint == ArrayHint::Array) { \
                 POP_ARRAY({ \
@@ -958,7 +952,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 return array; \
             } \
         } while (false)
-#define POP_NUMBERS_SWAP(TypedArrayType, CType) \
+#define POP_NUMBER_ARRAY_SWAP(TypedArrayType, CType) \
         do { \
             if (type->hint == ArrayHint::Array) { \
                 POP_ARRAY({ \
@@ -994,9 +988,9 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 return str;
             }
 
-            POP_NUMBERS(Int8Array, int8_t);
+            POP_NUMBER_ARRAY(Int8Array, int8_t);
         } break;
-        case PrimitiveKind::UInt8: { POP_NUMBERS(Uint8Array, uint8_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;
@@ -1006,11 +1000,11 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 return str;
             }
 
-            POP_NUMBERS(Int16Array, int16_t);
+            POP_NUMBER_ARRAY(Int16Array, int16_t);
         } break;
-        case PrimitiveKind::Int16S: { POP_NUMBERS_SWAP(Int16Array, int16_t); } break;
-        case PrimitiveKind::UInt16: { POP_NUMBERS(Uint16Array, uint16_t); } break;
-        case PrimitiveKind::UInt16S: { POP_NUMBERS_SWAP(Uint16Array, uint16_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;
@@ -1020,11 +1014,11 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 return str;
             }
 
-            POP_NUMBERS(Int32Array, int32_t);
+            POP_NUMBER_ARRAY(Int32Array, int32_t);
         } break;
-        case PrimitiveKind::Int32S: { POP_NUMBERS_SWAP(Int32Array, int32_t); } break;
-        case PrimitiveKind::UInt32: { POP_NUMBERS(Uint32Array, uint32_t); } break;
-        case PrimitiveKind::UInt32S: { POP_NUMBERS_SWAP(Uint32Array, uint32_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;
@@ -1067,20 +1061,19 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 array.Set(i, str32 ? MakeStringFromUTF32(env, str32) : env.Null());
             });
         } break;
-        case PrimitiveKind::Pointer: {
-            POP_ARRAY({
-                void *ptr2 = *(void **)src;
-
-                Napi::Value p = ptr2 ? WrapPointer(env, type->ref.type->ref.type, ptr2) : env.Null();
-                array.Set(i, p);
-            });
-        } break;
+        case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: {
             POP_ARRAY({
                 void *ptr2 = *(void **)src;
 
-                Napi::Value p = ptr2 ? WrapCallback(env, type->ref.type->ref.type, ptr2) : env.Null();
-                array.Set(i, p);
+                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:
@@ -1096,15 +1089,14 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 array.Set(i, value);
             });
         } break;
-        case PrimitiveKind::Float32: { POP_NUMBERS(Float32Array, float); } break;
-        case PrimitiveKind::Float64: { POP_NUMBERS(Float64Array, double); } 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_NUMBERS_SWAP
-#undef POP_NUMBERS
-
+#undef POP_NUMBER_ARRAY_SWAP
+#undef POP_NUMBER_ARRAY
 #undef POP_ARRAY
 
     K_UNREACHABLE();
@@ -1139,15 +1131,14 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
                 offset += ref->size; \
             } \
         } while (false)
-
-#define POP_NUMBERS(CType) \
+#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_NUMBERS_SWAP(CType) \
+#define POP_NUMBER_ARRAY_SWAP(CType) \
         do { \
             POP_ARRAY({ \
                 CType v = *(CType *)src; \
@@ -1165,16 +1156,16 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
                 array.Set(i, Napi::Boolean::New(env, b));
             });
         } break;
-        case PrimitiveKind::Int8: { POP_NUMBERS(int8_t); } break;
-        case PrimitiveKind::UInt8: { POP_NUMBERS(uint8_t); } break;
-        case PrimitiveKind::Int16: { POP_NUMBERS(int16_t); } break;
-        case PrimitiveKind::Int16S: { POP_NUMBERS_SWAP(int16_t); } break;
-        case PrimitiveKind::UInt16: { POP_NUMBERS(uint16_t); } break;
-        case PrimitiveKind::UInt16S: { POP_NUMBERS_SWAP(uint16_t); } break;
-        case PrimitiveKind::Int32: { POP_NUMBERS(int32_t); } break;
-        case PrimitiveKind::Int32S: { POP_NUMBERS_SWAP(int32_t); } break;
-        case PrimitiveKind::UInt32: { POP_NUMBERS(uint32_t); } break;
-        case PrimitiveKind::UInt32S: { POP_NUMBERS_SWAP(uint32_t); } 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;
@@ -1229,24 +1220,19 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
                 }
             });
         } break;
-        case PrimitiveKind::Pointer: {
+        case PrimitiveKind::Pointer:
+        case PrimitiveKind::Callback: {
             POP_ARRAY({
                 void *ptr2 = *(void **)src;
 
-                Napi::Value p = ptr2 ? WrapPointer(env, ref->ref.type, ptr2) : env.Null();
-                array.Set(i, p);
+                if (ptr2) {
+                    Napi::External<void> external = Napi::External<void>::New(env, ptr2);
+                    SetValueTag(external, ref->ref.marker);
 
-                if (ref->dispose) {
-                    ref->dispose(env, ref, ptr2);
+                    array.Set(i, external);
+                } else {
+                    array.Set(i, env.Null());
                 }
-            });
-        } break;
-        case PrimitiveKind::Callback: {
-            POP_ARRAY({
-                void *ptr2 = *(void **)src;
-
-                Napi::Value p = ptr2 ? WrapCallback(env, ref->ref.type, ptr2) : env.Null();
-                array.Set(i, p);
 
                 if (ref->dispose) {
                     ref->dispose(env, ref, ptr2);
@@ -1266,15 +1252,14 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
                 array.Set(i, value);
             });
         } break;
-        case PrimitiveKind::Float32: { POP_NUMBERS(float); } break;
-        case PrimitiveKind::Float64: { POP_NUMBERS(double); } 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_NUMBERS_SWAP
-#undef POP_NUMBERS
-
+#undef POP_NUMBER_ARRAY_SWAP
+#undef POP_NUMBER_ARRAY
 #undef POP_ARRAY
 }
 
@@ -1309,9 +1294,14 @@ 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 *src = nullptr;
+    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 (Span<uint8_t> buffer = {}; TryBuffer(value, &buffer)) {
         if (offset < 0) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Offset must be >= 0");
             return env.Null();
@@ -1322,19 +1312,17 @@ Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const S
             return env.Null();
         }
 
-        src = (const uint8_t *)buffer.ptr;
-    } else if (void *ptr = nullptr; TryPointer(value, &ptr)) {
-        src = (const uint8_t *)ptr;
+        ptr = (const uint8_t *)buffer.ptr;
     } else {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for variable, expected pointer", GetValueType(instance, value));
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for variable, expected external or TypedArray", GetValueType(instance, value));
         return env.Null();
     }
 
-    if (!src)
+    if (!ptr)
         return env.Null();
-    src += offset;
+    ptr += offset;
 
-    Napi::Value ret = Decode(env, src, type, len);
+    Napi::Value ret = Decode(env, ptr, type, len);
     return ret;
 }
 
@@ -1441,13 +1429,10 @@ 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: {
-            void *ptr2 = *(void **)ptr;
-            return ptr2 ? WrapPointer(env, type->ref.type, ptr2) : env.Null();
-        } break;
+        case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: {
             void *ptr2 = *(void **)ptr;
-            return ptr2 ? WrapCallback(env, type->ref.type, ptr2) : env.Null();
+            return ptr2 ? Napi::External<void>::New(env, ptr2, [](Napi::Env, void *) {}) : env.Null();
         } break;
         case PrimitiveKind::Record:
         case PrimitiveKind::Union: {
@@ -1477,12 +1462,10 @@ 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));
-            memset((void *)&func->primitives, 0, K_SIZE(func->primitives));
+            func->parameters = proto->parameters;
 
             func->name = "<anonymous>";
             func->native = (void *)ptr;
-            func->parameters = proto->parameters;
-            func->primitives = proto->primitives;
 
             // Fix back parameter offset
             for (ParameterInfo &param: func->parameters) {
@@ -1506,9 +1489,14 @@ 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 *dest = nullptr;
+    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 (Span<uint8_t> buffer = {}; TryBuffer(ref, &buffer)) {
         if (offset < 0) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Offset must be >= 0");
             return env.Null();
@@ -1519,21 +1507,19 @@ bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *typ
             return env.Null();
         }
 
-        dest = (uint8_t *)buffer.ptr;
-    } else if (void *ptr = nullptr; TryPointer(ref, &ptr)) {
-        dest = (uint8_t *)ptr;
+        ptr = (uint8_t *)buffer.ptr;
     } else {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for reference, expected pointer", GetValueType(instance, ref));
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for reference, expected external or TypedArray", GetValueType(instance, ref));
         return env.Null();
     }
 
-    if (!dest) [[unlikely]] {
+    if (!ptr) [[unlikely]] {
         ThrowError<Napi::Error>(env, "Cannot encode data in NULL pointer");
         return env.Null();
     }
-    dest += offset;
+    ptr += offset;
 
-    return Encode(env, dest, value, type, len);
+    return Encode(env, ptr, value, type, len);
 }
 
 bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *type, const Size *len)
@@ -1557,24 +1543,22 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
 
 #define PUSH_INTEGER(CType) \
         do { \
-            CType v; \
-            \
-            if (!TryNumber(value, &v)) [[unlikely]] { \
+            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 { \
-            CType v; \
-            \
-            if (!TryNumber(value, &v)) [[unlikely]] { \
+            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)
 
@@ -1582,14 +1566,12 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
         case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
 
         case PrimitiveKind::Bool: {
-            bool b;
-            napi_status status = napi_get_value_bool(env, value, &b);
-
-            if (status != napi_ok) [[unlikely]] {
+            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;
@@ -1647,7 +1629,8 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
                 Napi::Array array = value.As<Napi::Array>();
                 if (!call.PushNormalArray(array, type, type->size, origin))
                     return false;
-            } else if (Span<uint8_t> buffer = {}; TryBuffer(value, &buffer)) {
+            } 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))
@@ -1658,34 +1641,35 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
             }
         } break;
         case PrimitiveKind::Float32: {
-            float f;
-
-            if (!TryNumber(value, &f)) [[unlikely]] {
+            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: {
-            double d;
-
-            if (!TryNumber(value, &d)) [[unlikely]] {
+            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 (!TryPointer(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);
-                }
+            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;
             }
 
@@ -1699,19 +1683,15 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
 #undef PUSH_INTEGER
 
     // Keep memory around if any was allocated
-    {
-        BlockAllocator *alloc = call.GetAllocator();
-
-        if (alloc->IsUsed()) {
-            BlockAllocator *copy = instance->encode_map.FindValue(origin, nullptr);
+    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(*alloc, *copy);
+        if (!copy) {
+            copy = instance->encode_allocators.AppendDefault();
+            instance->encode_map.Set(origin, copy);
         }
+
+        std::swap(call.alloc, *copy);
     }
 
     return true;
@@ -1757,32 +1737,6 @@ 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") {