koffi 2.15.1 → 2.16.0-beta.1

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.marker && CheckValueTag(value, type.ref.marker))
+        if (type.ref.type && CheckValueTag(value, type.ref.type))
             return type.name;
     }
 
@@ -857,8 +857,7 @@ 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::Callback: {
+            case PrimitiveKind::Pointer: {
                 void *ptr2 = *(void **)src;
 
                 if (member.countedby >= 0) {
@@ -867,19 +866,25 @@ 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 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());
+                    Napi::Value p = ptr2 ? WrapPointer(env, member.type->ref.type, ptr2) : env.Null();
+                    obj.Set(member.name, p);
                 }
 
                 if (member.type->dispose) {
                     member.type->dispose(env, member.type, ptr2);
                 }
             } 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);
+                }
+            } break;
             case PrimitiveKind::Record:
             case PrimitiveKind::Union: {
                 Napi::Object obj2 = DecodeObject(env, src, member.type);
@@ -936,7 +941,8 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
              \
             return array; \
         } while (false)
-#define POP_NUMBER_ARRAY(TypedArrayType, CType) \
+
+#define POP_NUMBERS(TypedArrayType, CType) \
         do { \
             if (type->hint == ArrayHint::Array) { \
                 POP_ARRAY({ \
@@ -952,7 +958,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 return array; \
             } \
         } while (false)
-#define POP_NUMBER_ARRAY_SWAP(TypedArrayType, CType) \
+#define POP_NUMBERS_SWAP(TypedArrayType, CType) \
         do { \
             if (type->hint == ArrayHint::Array) { \
                 POP_ARRAY({ \
@@ -988,9 +994,9 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 return str;
             }
 
-            POP_NUMBER_ARRAY(Int8Array, int8_t);
+            POP_NUMBERS(Int8Array, int8_t);
         } break;
-        case PrimitiveKind::UInt8: { POP_NUMBER_ARRAY(Uint8Array, uint8_t); } break;
+        case PrimitiveKind::UInt8: { POP_NUMBERS(Uint8Array, uint8_t); } break;
         case PrimitiveKind::Int16: {
             if (type->hint == ArrayHint::String) {
                 const char16_t *ptr = (const char16_t *)origin;
@@ -1000,11 +1006,11 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 return str;
             }
 
-            POP_NUMBER_ARRAY(Int16Array, int16_t);
+            POP_NUMBERS(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::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::Int32: {
             if (type->hint == ArrayHint::String) {
                 const char32_t *ptr = (const char32_t *)origin;
@@ -1014,11 +1020,11 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 return str;
             }
 
-            POP_NUMBER_ARRAY(Int32Array, int32_t);
+            POP_NUMBERS(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::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::Int64: {
             POP_ARRAY({
                 int64_t v = *(int64_t *)src;
@@ -1061,19 +1067,20 @@ 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:
-        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, type->ref.type->ref.marker);
+                Napi::Value p = ptr2 ? WrapPointer(env, type->ref.type->ref.type, ptr2) : env.Null();
+                array.Set(i, p);
+            });
+        } break;
+        case PrimitiveKind::Callback: {
+            POP_ARRAY({
+                void *ptr2 = *(void **)src;
 
-                    array.Set(i, external);
-                } else {
-                    array.Set(i, env.Null());
-                }
+                Napi::Value p = ptr2 ? WrapCallback(env, type->ref.type->ref.type, ptr2) : env.Null();
+                array.Set(i, p);
             });
         } break;
         case PrimitiveKind::Record:
@@ -1089,14 +1096,15 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 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::Float32: { POP_NUMBERS(Float32Array, float); } break;
+        case PrimitiveKind::Float64: { POP_NUMBERS(Float64Array, double); } break;
 
         case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
     }
 
-#undef POP_NUMBER_ARRAY_SWAP
-#undef POP_NUMBER_ARRAY
+#undef POP_NUMBERS_SWAP
+#undef POP_NUMBERS
+
 #undef POP_ARRAY
 
     K_UNREACHABLE();
@@ -1131,14 +1139,15 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
                 offset += ref->size; \
             } \
         } while (false)
-#define POP_NUMBER_ARRAY(CType) \
+
+#define POP_NUMBERS(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) \
+#define POP_NUMBERS_SWAP(CType) \
         do { \
             POP_ARRAY({ \
                 CType v = *(CType *)src; \
@@ -1156,16 +1165,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_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::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::Int64: {
             POP_ARRAY({
                 int64_t v = *(int64_t *)src;
@@ -1220,19 +1229,24 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
                 }
             });
         } 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();
+                array.Set(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();
+                array.Set(i, p);
 
                 if (ref->dispose) {
                     ref->dispose(env, ref, ptr2);
@@ -1252,14 +1266,15 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
                 array.Set(i, value);
             });
         } break;
-        case PrimitiveKind::Float32: { POP_NUMBER_ARRAY(float); } break;
-        case PrimitiveKind::Float64: { POP_NUMBER_ARRAY(double); } break;
+        case PrimitiveKind::Float32: { POP_NUMBERS(float); } break;
+        case PrimitiveKind::Float64: { POP_NUMBERS(double); } break;
 
         case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
     }
 
-#undef POP_NUMBER_ARRAY_SWAP
-#undef POP_NUMBER_ARRAY
+#undef POP_NUMBERS_SWAP
+#undef POP_NUMBERS
+
 #undef POP_ARRAY
 }
 
@@ -1294,14 +1309,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(value, &buffer)) {
         if (offset < 0) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Offset must be >= 0");
             return env.Null();
@@ -1312,17 +1322,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(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;
 }
 
@@ -1429,10 +1441,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: {
@@ -1462,10 +1477,12 @@ 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->primitives, 0, K_SIZE(func->primitives));
 
             func->name = "<anonymous>";
             func->native = (void *)ptr;
+            func->parameters = proto->parameters;
+            func->primitives = proto->primitives;
 
             // Fix back parameter offset
             for (ParameterInfo &param: func->parameters) {
@@ -1489,14 +1506,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(ref, &buffer)) {
         if (offset < 0) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Offset must be >= 0");
             return env.Null();
@@ -1507,19 +1519,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(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)
@@ -1543,22 +1557,24 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
 
 #define PUSH_INTEGER(CType) \
         do { \
-            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] { \
+            CType v; \
+            \
+            if (!TryNumber(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(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 +1582,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;
@@ -1629,8 +1647,7 @@ 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 (IsRawBuffer(value)) {
-                Span<const uint8_t> buffer = GetRawBuffer(value);
+            } else if (Span<uint8_t> buffer = {}; TryBuffer(value, &buffer)) {
                 call.PushBuffer(buffer, type, origin);
             } else if (value.IsString()) {
                 if (!call.PushStringArray(value, type, origin))
@@ -1641,35 +1658,34 @@ 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(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;
         } break;
         case PrimitiveKind::Float64: {
-            if (!value.IsNumber() && !value.IsBigInt()) [[unlikely]] {
+            double d;
+
+            if (!TryNumber(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;
         } 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(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;
             }
 
@@ -1741,6 +1757,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") {
@@ -1797,7 +1839,7 @@ void DumpMemory(const char *type, Span<const uint8_t> bytes)
         PrintLn(StdErr, "%1 at 0x%2 (%3):", type, bytes.ptr, FmtMemSize(bytes.len));
 
         for (const uint8_t *ptr = bytes.begin(); ptr < bytes.end();) {
-            Print(StdErr, "  [0x%1 %2 %3]  ", FmtInt((uintptr_t)ptr, 16),
+            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++) {

package/src/koffi/src/util.hh

@@ -98,64 +98,97 @@ static inline bool IsObject(Napi::Value value)
     return value.IsObject() && !IsNullOrUndefined(value) && !value.IsArray();
 }
 
-static inline bool IsRawBuffer(Napi::Value value)
-{
-    return value.IsTypedArray() || value.IsArrayBuffer();
-}
-
-static inline Span<uint8_t> GetRawBuffer(Napi::Value value)
+template <typename T>
+bool TryNumber(Napi::Value value, T *out_value)
 {
-    if (value.IsTypedArray()) {
-        napi_typedarray_type type = napi_int8_array;
-        size_t length = 0;
-        void *ptr = nullptr;
+    // Assume number first
+    {
+        T v;
+        napi_status status;
+
+        if constexpr (std::is_same_v<T, double>) {
+            status = napi_get_value_double(value.Env(), value, &v);
+        } else if constexpr (std::is_same_v<T, float>) {
+            double d;
+            status = napi_get_value_double(value.Env(), value, &d);
+            v = (float)d;
+        } else {
+            int64_t i64;
+            status = napi_get_value_int64(value.Env(), value, &i64);
+            v = (T)i64;
+        }
 
-        napi_get_typedarray_info(value.Env(), value, &type, &length, &ptr, nullptr, nullptr);
-
-        switch (type) {
-            case napi_int8_array: { length *= 1; } break;
-            case napi_uint8_array: { length *= 1; } break;
-            case napi_uint8_clamped_array: { length *= 1; } break;
-            case napi_int16_array: { length *= 2; } break;
-            case napi_uint16_array: { length *= 2; } break;
-            case napi_int32_array: { length *= 4; } break;
-            case napi_uint32_array: { length *= 4; } break;
-            case napi_float16_array: { length *= 2; } break;
-            case napi_float32_array: { length *= 4; } break;
-            case napi_float64_array: { length *= 8; } break;
-            case napi_bigint64_array: { length *= 8; } break;
-            case napi_biguint64_array: { length *= 8; } break;
+        if (status == napi_ok) [[likely]] {
+            *out_value = v;
+            return true;
         }
+    }
+
+    if (value.IsBigInt()) {
+        Napi::BigInt bigint = value.As<Napi::BigInt>();
+
+        bool lossless;
+        *out_value = (T)bigint.Uint64Value(&lossless);
+
+        return true;
+    }
+
+    return false;
+}
 
-        return MakeSpan((uint8_t *)ptr, (Size)length);
+static inline bool TryPointer(Napi::Value value, void **out_ptr)
+{
+    if (IsNullOrUndefined(value)) {
+        *out_ptr = nullptr;
+        return true;
+    } else if (uintptr_t ptr = 0; TryNumber(value, &ptr)) {
+        *out_ptr = (void *)ptr;
+        return true;
+    } else if (value.IsTypedArray()) {
+        napi_get_typedarray_info(value.Env(), value, nullptr, nullptr, out_ptr, nullptr, nullptr);
+        return true;
+    } else if (value.IsExternal()) {
+        Napi::External<void> external = value.As<Napi::External<void>>();
+
+        *out_ptr = (void *)external.Data();
+        return true;
     } else if (value.IsArrayBuffer()) {
         Napi::ArrayBuffer buffer = value.As<Napi::ArrayBuffer>();
 
-        return MakeSpan((uint8_t *)buffer.Data(), (Size)buffer.ByteLength());
+        *out_ptr = (void *)buffer.Data();
+        return true;
     }
 
-    K_UNREACHABLE();
+    return false;
 }
 
-int GetTypedArrayType(const TypeInfo *type);
-
-template <typename T>
-T GetNumber(Napi::Value value)
+static inline bool TryBuffer(Napi::Value value, Span<uint8_t> *out_buffer)
 {
-    K_ASSERT(value.IsNumber() || value.IsBigInt());
+    // Before somewhere around Node 20.12, napi_get_buffer_info() would assert/crash
+    // when used with something it did not support, instead of returning napi_invalid_arg.
+    // So we need to call napi_is_buffer(), at least for now.
 
-    if (value.IsNumber()) [[likely]] {
-        return (T)value.As<Napi::Number>().DoubleValue();
-    } else if (value.IsBigInt()) {
-        Napi::BigInt bigint = value.As<Napi::BigInt>();
+    if (value.IsBuffer()) {
+        void *ptr = nullptr;
+        size_t length = 0;
 
-        bool lossless;
-        return (T)bigint.Uint64Value(&lossless);
+        // Assume it works
+        napi_get_buffer_info(value.Env(), value, &ptr, &length);
+
+        *out_buffer = MakeSpan((uint8_t *)ptr, (Size)length);
+        return true;
+    } else if (value.IsArrayBuffer()) {
+        Napi::ArrayBuffer buffer = value.As<Napi::ArrayBuffer>();
+
+        *out_buffer = MakeSpan((uint8_t *)buffer.Data(), (Size)buffer.ByteLength());
+        return true;
     }
 
-    K_UNREACHABLE();
+    return false;
 }
 
+int GetTypedArrayType(const TypeInfo *type);
+
 template <typename T>
 Size NullTerminatedLength(const T *ptr)
 {
@@ -227,6 +260,9 @@ static inline Napi::Array GetOwnPropertyNames(Napi::Object obj)
 
 Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func);
 
+Napi::Value WrapPointer(Napi::Env env, const TypeInfo *ref, void *ptr);
+Napi::Value WrapCallback(Napi::Env env, const TypeInfo *ref, void *ptr);
+
 bool DetectCallConvention(Span<const char> name, CallConvention *out_convention);
 
 int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func);