koffi 2.14.1 → 2.15.1

package/src/koffi/src/trampolines/masm64.inc

@@ -1,24 +1,3 @@
-; Copyright (C) 2025  Niels Martignène <niels.martignene@protonmail.com>
-;
-; Permission is hereby granted, free of charge, to any person obtaining a copy of
-; this software and associated documentation files (the “Software”), to deal in
-; the Software without restriction, including without limitation the rights to use,
-; copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
-; Software, and to permit persons to whom the Software is furnished to do so,
-; subject to the following conditions:
-;
-; The above copyright notice and this permission notice shall be included in all
-; copies or substantial portions of the Software.
-;
-; THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
-; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-; OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-; OTHER DEALINGS IN THE SOFTWARE.
-
 public Trampoline0
 public Trampoline1
 public Trampoline2

package/src/koffi/src/trampolines/prototypes.inc

@@ -1,24 +1,3 @@
-// Copyright (C) 2025  Niels Martignène <niels.martignene@protonmail.com>
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the “Software”), to deal in
-// the Software without restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
-// Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-
 extern "C" int Trampoline0; extern "C" int TrampolineX0;
 extern "C" int Trampoline1; extern "C" int TrampolineX1;
 extern "C" int Trampoline2; extern "C" int TrampolineX2;

package/src/koffi/src/util.cc

@@ -1,25 +1,7 @@
-// Copyright (C) 2025  Niels Martignène <niels.martignene@protonmail.com>
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the “Software”), to deal in
-// the Software without restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
-// Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-
-#include "src/core/base/base.hh"
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
+
+#include "lib/native/base/base.hh"
 #include "call.hh"
 #include "ffi.hh"
 #include "util.hh"
@@ -38,7 +20,7 @@ Napi::Function MagicUnion::InitClass(Napi::Env env, const TypeInfo *type)
     K_ASSERT(type->primitive == PrimitiveKind::Union);
 
     // node-addon-api wants std::vector
-    std::vector<Napi::ClassPropertyDescriptor<MagicUnion>> properties; 
+    std::vector<Napi::ClassPropertyDescriptor<MagicUnion>> properties;
     properties.reserve(type->members.len);
 
     for (Size i = 0; i < type->members.len; i++) {
@@ -61,7 +43,7 @@ MagicUnion::MagicUnion(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    active_symbol = instance->active_symbol;
+    active_symbol.Reset(instance->active_symbol.Value(), 1);
 }
 
 void MagicUnion::SetRaw(const uint8_t *ptr)
@@ -69,7 +51,7 @@ void MagicUnion::SetRaw(const uint8_t *ptr)
     raw.RemoveFrom(0);
     raw.Append(MakeSpan(ptr, type->size));
 
-    Value().Set(active_symbol, Env().Undefined());
+    Value().Set(active_symbol.Value(), Env().Undefined());
     active_idx = -1;
 }
 
@@ -81,7 +63,7 @@ Napi::Value MagicUnion::Getter(const Napi::CallbackInfo &info)
     Napi::Value value;
 
     if (idx == active_idx) {
-        value = Value().Get(active_symbol);
+        value = Value().Get(active_symbol.Value());
     } else {
         Napi::Env env = info.Env();
 
@@ -92,7 +74,7 @@ Napi::Value MagicUnion::Getter(const Napi::CallbackInfo &info)
 
         value = Decode(env, raw.ptr, member.type);
 
-        Value().Set(active_symbol, value);
+        Value().Set(active_symbol.Value(), value);
         active_idx = idx;
     }
 
@@ -104,7 +86,7 @@ void MagicUnion::Setter(const Napi::CallbackInfo &info, const Napi::Value &value
 {
     Size idx = (Size)info.Data();
 
-    Value().Set(active_symbol, value);
+    Value().Set(active_symbol.Value(), value);
     active_idx = idx;
 
     raw.Clear();
@@ -187,7 +169,7 @@ const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
 
             // Cache for quick future access
             bool inserted;
-            auto bucket = instance->types_map.TrySetDefault(remain.ptr, &inserted);
+            auto bucket = instance->types_map.InsertOrGetDefault(remain.ptr, &inserted);
 
             if (inserted) {
                 bucket->key = DuplicateString(remain, &instance->str_alloc).ptr;
@@ -198,7 +180,7 @@ const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
         }
 
         return type;
-    } else if (CheckValueTag(instance, value, &TypeInfoMarker)) {
+    } else if (CheckValueTag(value, &TypeInfoMarker)) {
         Napi::External<TypeInfo> external = value.As<Napi::External<TypeInfo>>();
         const TypeInfo *raw = external.Data();
 
@@ -399,7 +381,7 @@ TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count
         Fmt(name_buf, "%1%2*", ref->name, EndsWith(ref->name, "*") ? "" : " ");
 
         bool inserted;
-        auto bucket = instance->types_map.TrySetDefault(name_buf, &inserted);
+        auto bucket = instance->types_map.InsertOrGetDefault(name_buf, &inserted);
 
         if (inserted) {
             TypeInfo *type = instance->types.AppendDefault();
@@ -446,7 +428,7 @@ static TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size
 
     if (insert) {
         bool inserted;
-        type = (TypeInfo *)*instance->types_map.TrySet(type->name, type, &inserted);
+        type = (TypeInfo *)*instance->types_map.InsertOrGet(type->name, type, &inserted);
         instance->types.RemoveLast(!inserted);
     }
 
@@ -473,10 +455,10 @@ TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, A
     return MakeArrayType(instance, ref, len, hint, false);
 }
 
-Napi::External<TypeInfo> WrapType(Napi::Env env, InstanceData *instance, const TypeInfo *type)
+Napi::External<TypeInfo> WrapType(Napi::Env env, const TypeInfo *type)
 {
     Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
-    SetValueTag(instance, external, &TypeInfoMarker);
+    SetValueTag(external, &TypeInfoMarker);
 
     return external;
 }
@@ -540,17 +522,17 @@ bool CanStoreType(const TypeInfo *type)
 
 const char *GetValueType(const InstanceData *instance, Napi::Value value)
 {
-    if (CheckValueTag(instance, value, &CastMarker)) {
+    if (CheckValueTag(value, &CastMarker)) {
         Napi::External<ValueCast> external = value.As<Napi::External<ValueCast>>();
         ValueCast *cast = external.Data();
 
         return cast->type->name;
     }
 
-    if (CheckValueTag(instance, value, &TypeInfoMarker))
+    if (CheckValueTag(value, &TypeInfoMarker))
         return "Type";
     for (const TypeInfo &type: instance->types) {
-        if (type.ref.marker && CheckValueTag(instance, value, type.ref.marker))
+        if (type.ref.marker && CheckValueTag(value, type.ref.marker))
             return type.name;
     }
 
@@ -567,6 +549,7 @@ const char *GetValueType(const InstanceData *instance, Napi::Value value)
             case napi_uint16_array: return "Uint16Array";
             case napi_int32_array: return "Int32Array";
             case napi_uint32_array: return "Uint32Array";
+            case napi_float16_array: return "Float16Array";
             case napi_float32_array: return "Float32Array";
             case napi_float64_array: return "Float64Array";
             case napi_bigint64_array: return "BigInt64Array";
@@ -595,7 +578,7 @@ const char *GetValueType(const InstanceData *instance, Napi::Value value)
     return "Unknown";
 }
 
-void SetValueTag(const InstanceData *instance, Napi::Value value, const void *marker)
+void SetValueTag(Napi::Value value, const void *marker)
 {
     static_assert(K_SIZE(TypeInfo) >= 16);
 
@@ -614,7 +597,7 @@ void SetValueTag(const InstanceData *instance, Napi::Value value, const void *ma
     K_ASSERT(status == napi_ok);
 }
 
-bool CheckValueTag(const InstanceData *instance, Napi::Value value, const void *marker)
+bool CheckValueTag(Napi::Value value, const void *marker)
 {
     bool match = false;
 
@@ -646,25 +629,27 @@ int GetTypedArrayType(const TypeInfo *type)
 
 Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr, Size len)
 {
+    static const char16_t ReplacementChar = 0xFFFD;
+
     HeapArray<char16_t> buf;
     buf.Reserve(len * 2);
 
     for (Size i = 0; i < len; i++) {
         char32_t uc = ptr[i];
 
-        if (uc < 0xFFFF) {
+        if (uc <= 0xFFFF) {
             if (uc < 0xD800 || uc > 0xDFFF) {
                 buf.Append((char16_t)uc);
             } else {
-                buf.Append('?');
+                buf.Append(ReplacementChar);
             }
-        } else if (uc < 0x10FFFF) {
+        } else if (uc <= 0x10FFFF) {
             uc -= 0x0010000UL;
 
             buf.Append((char16_t)((uc >> 10) + 0xD800));
             buf.Append((char16_t)((uc & 0x3FFul) + 0xDC00));
         } else {
-            buf.Append('?');
+            buf.Append(ReplacementChar);
         }
     }
 
@@ -676,10 +661,8 @@ Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *
 {
     // We can't decode unions because we don't know which member is valid
     if (type->primitive == PrimitiveKind::Union) {
-        InstanceData *instance = env.GetInstanceData<InstanceData>();
-
         Napi::Object wrapper = type->construct.New({}).As<Napi::Object>();
-        SetValueTag(instance, wrapper, &MagicUnionMarker);
+        SetValueTag(wrapper, &MagicUnionMarker);
 
         MagicUnion *u = MagicUnion::Unwrap(wrapper);
         u->SetRaw(origin);
@@ -775,7 +758,6 @@ static uint32_t DecodeDynamicLength(const uint8_t *origin, const RecordMember &b
 void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
 {
     Napi::Env env = obj.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     K_ASSERT(type->primitive == PrimitiveKind::Record);
 
@@ -887,7 +869,7 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
                     obj.Set(member.name, value);
                 } else if (ptr2) {
                     Napi::External<void> external = Napi::External<void>::New(env, ptr2);
-                    SetValueTag(instance, external, member.type->ref.marker);
+                    SetValueTag(external, member.type->ref.marker);
 
                     obj.Set(member.name, external);
                 } else {
@@ -936,7 +918,6 @@ 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, uint32_t len)
 {
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
     Size offset = 0;
 
 #define POP_ARRAY(SetCode) \
@@ -1087,7 +1068,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
 
                 if (ptr2) {
                     Napi::External<void> external = Napi::External<void>::New(env, ptr2);
-                    SetValueTag(instance, external, type->ref.type->ref.marker);
+                    SetValueTag(external, type->ref.type->ref.marker);
 
                     array.Set(i, external);
                 } else {
@@ -1132,7 +1113,6 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
 void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref)
 {
     Napi::Env env = array.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     K_ASSERT(array.IsArray());
 
@@ -1247,7 +1227,7 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
 
                 if (ptr2) {
                     Napi::External<void> external = Napi::External<void>::New(env, ptr2);
-                    SetValueTag(instance, external, ref->ref.marker);
+                    SetValueTag(external, ref->ref.marker);
 
                     array.Set(i, external);
                 } else {
@@ -1322,6 +1302,10 @@ Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const S
     } else if (IsRawBuffer(value)) {
         Span<uint8_t> buffer = GetRawBuffer(value);
 
+        if (offset < 0) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "Offset must be >= 0");
+            return env.Null();
+        }
         if (buffer.len - offset < type->size) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Expected buffer with size superior or equal to type %1 (%2 bytes)",
                                     type->name, type->size + offset);
@@ -1354,12 +1338,12 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
             type = MakeArrayType(instance, type, *len);
         } else {
             switch (type->primitive) {
-                case PrimitiveKind::Int8: 
+                case PrimitiveKind::Int8:
                 case PrimitiveKind::UInt8: {
                     Size count = strlen((const char *)ptr);
                     type = MakeArrayType(instance, type, count);
                 } break;
-                case PrimitiveKind::Int16: 
+                case PrimitiveKind::Int16:
                 case PrimitiveKind::UInt16: {
                     Size count = NullTerminatedLength((const char16_t *)ptr, K_SIZE_MAX);
                     type = MakeArrayType(instance, type, count);
@@ -1513,6 +1497,10 @@ bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *typ
     } else if (IsRawBuffer(ref)) {
         Span<uint8_t> buffer = GetRawBuffer(ref);
 
+        if (offset < 0) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "Offset must be >= 0");
+            return env.Null();
+        }
         if (buffer.len - offset < type->size) [[unlikely]] {
             ThrowError<Napi::Error>(env, "Expected buffer with size superior or equal to type %1 (%2 bytes)",
                                     type->name, type->size + offset);
@@ -1521,7 +1509,7 @@ bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *typ
 
         ptr = (uint8_t *)buffer.ptr;
     } else {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for reference, expected external or TypedArray", GetValueType(instance, value));
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for reference, expected external or TypedArray", GetValueType(instance, ref));
         return env.Null();
     }
 
@@ -1676,7 +1664,7 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
             if (value.IsFunction()) {
                 ThrowError<Napi::Error>(env, "Cannot encode non-registered callback");
                 return false;
-            } else if (CheckValueTag(instance, value, type->ref.marker)) {
+            } else if (CheckValueTag(value, type->ref.marker)) {
                 ptr = value.As<Napi::External<void>>().Data();
             } else if (IsNullOrUndefined(value)) {
                 ptr = nullptr;
@@ -1715,8 +1703,6 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
 
 Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func)
 {
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
     Napi::Function wrapper;
     if (func->variadic) {
         Napi::Function::Callback call = TranslateVariadicCall;
@@ -1742,11 +1728,11 @@ Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func)
 
         meta.Set("name", Napi::String::New(env, func->name));
         meta.Set("arguments", arguments);
-        meta.Set("result", WrapType(env, instance, func->ret.type));
+        meta.Set("result", WrapType(env, func->ret.type));
 
         for (Size i = 0; i < func->parameters.len; i++) {
             const ParameterInfo &param = func->parameters[i];
-            arguments.Set((uint32_t)i, WrapType(env, instance, param.type));
+            arguments.Set((uint32_t)i, WrapType(env, param.type));
         }
 
         wrapper.Set("info", meta);
@@ -1811,11 +1797,11 @@ void DumpMemory(const char *type, Span<const uint8_t> bytes)
         PrintLn(StdErr, "%1 at 0x%2 (%3):", type, bytes.ptr, FmtMemSize(bytes.len));
 
         for (const uint8_t *ptr = bytes.begin(); ptr < bytes.end();) {
-            Print(StdErr, "  [0x%1 %2 %3]  ", FmtArg(ptr).Pad0(-16),
-                                              FmtArg((ptr - bytes.begin()) / sizeof(void *)).Pad(-4),
-                                              FmtArg(ptr - bytes.begin()).Pad(-4));
+            Print(StdErr, "  [0x%1 %2 %3]  ", FmtInt((uintptr_t)ptr, 16),
+                                              FmtInt((ptr - bytes.begin()) / sizeof(void *), 4, ' '),
+                                              FmtInt(ptr - bytes.begin(), 4, ' '));
             for (int i = 0; ptr < bytes.end() && i < (int)sizeof(void *); i++, ptr++) {
-                Print(StdErr, " %1", FmtHex(*ptr).Pad0(-2));
+                Print(StdErr, " %1", FmtHex(*ptr, 2));
             }
             PrintLn(StdErr);
         }

package/src/koffi/src/util.hh

@@ -1,27 +1,9 @@
-// Copyright (C) 2025  Niels Martignène <niels.martignene@protonmail.com>
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the “Software”), to deal in
-// the Software without restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
-// Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
 
 #pragma once
 
-#include "src/core/base/base.hh"
+#include "lib/native/base/base.hh"
 #include "ffi.hh"
 
 #include <napi.h>
@@ -35,7 +17,7 @@ extern const napi_type_tag MagicUnionMarker;
 class MagicUnion: public Napi::ObjectWrap<MagicUnion> {
     const TypeInfo *type;
 
-    napi_value active_symbol;
+    Napi::Reference<Napi::Symbol> active_symbol;
     Size active_idx = -1;
 
     HeapArray<uint8_t> raw;
@@ -94,7 +76,7 @@ TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count
 TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len);
 TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint);
 
-Napi::External<TypeInfo> WrapType(Napi::Env env, InstanceData *instance, const TypeInfo *type);
+Napi::External<TypeInfo> WrapType(Napi::Env env, const TypeInfo *type);
 
 bool CanPassType(const TypeInfo *type, int directions);
 bool CanReturnType(const TypeInfo *type);
@@ -103,8 +85,8 @@ bool CanStoreType(const TypeInfo *type);
 // Can be slow, only use for error messages
 const char *GetValueType(const InstanceData *instance, Napi::Value value);
 
-void SetValueTag(const InstanceData *instance, Napi::Value value, const void *marker);
-bool CheckValueTag(const InstanceData *instance, Napi::Value value, const void *marker);
+void SetValueTag(Napi::Value value, const void *marker);
+bool CheckValueTag(Napi::Value value, const void *marker);
 
 static inline bool IsNullOrUndefined(Napi::Value value)
 {
@@ -138,6 +120,7 @@ static inline Span<uint8_t> GetRawBuffer(Napi::Value value)
             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;

package/src/koffi/src/uv.cc

@@ -0,0 +1,193 @@
+// SPDX-License-Identifier: MIT
+
+#include "uv.hh"
+#include "util.hh"
+
+#include <uv.h>
+
+namespace K {
+
+Napi::Function PollHandle::Define(Napi::Env env)
+{
+    return DefineClass(env, "PollHandle", {
+        InstanceMethod("start", &PollHandle::Start),
+        InstanceMethod("stop", &PollHandle::Stop),
+        InstanceMethod("close", &PollHandle::Close),
+        InstanceMethod("unref", &PollHandle::Unref),
+        InstanceMethod("ref", &PollHandle::Ref)
+    });
+}
+
+PollHandle::PollHandle(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<PollHandle>(info), env(info.Env())
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        ThrowError<Napi::Error>(env, "Expected 1 argument, got %1", info.Length());
+        return;
+    }
+    if (!info[0].IsNumber()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for descriptor, expected number", GetValueType(instance, info[0]));
+        return;
+    }
+
+    int fd = info[0].As<Napi::Number>().Int32Value();
+
+    uv_loop_t *loop = nullptr;
+    if (napi_get_uv_event_loop(env, &loop) != napi_ok || !loop) {
+        ThrowError<Napi::Error>(env, "napi_get_uv_event_loop() failed");
+        return;
+    }
+
+    // We would store it inside the class, but the definition of uv_poll_t involves windows.h...
+    // and we won't want that on Windows. Heap allocation it is!
+    // Also, it may have to outlive the object, because uv_close() is asynchronous.
+    handle = new uv_poll_t();
+
+    if (int ret = uv_poll_init_socket(loop, handle, (uv_os_sock_t)fd); ret != 0) {
+        ThrowError<Napi::Error>(env, "Failed to init UV poll: %1", uv_strerror(ret));
+        return;
+    }
+
+    handle->data = this;
+}
+
+void PollHandle::Start(const Napi::CallbackInfo &info)
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    bool has_opts = (info.Length() >= 2 && info[0].IsObject());
+
+    if (info.Length() < 1u + has_opts) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 to 2 arguments, got %1", info.Length());
+        return;
+    }
+    if (!info[0u + has_opts].IsFunction()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for callback, expected function", GetValueType(instance, info[0u + has_opts]));
+        return;
+    }
+
+    int events = 0;
+    Napi::Function cb = info[0 + has_opts].As<Napi::Function>();
+
+    if (has_opts) {
+        Napi::Object opts = has_opts ? info[0].As<Napi::Object>() : Napi::Object::New(env);
+
+        events |= opts.Get("readable").ToBoolean() ? UV_READABLE : 0;
+        events |= opts.Get("writable").ToBoolean() ? UV_WRITABLE : 0;
+        events |= opts.Get("disconnect").ToBoolean() ? UV_DISCONNECT : 0;
+    } else {
+        events = UV_READABLE;
+    }
+
+    callback.Reset(cb, 1);
+
+    if (int ret = uv_poll_start(handle, events, &PollHandle::OnPoll); ret != 0) {
+        callback.Reset();
+        ThrowError<Napi::Error>(env, "Failed to start UV poll: %1", uv_strerror(ret));
+    }
+}
+
+void PollHandle::Stop(const Napi::CallbackInfo &)
+{
+    uv_poll_stop(handle);
+    callback.Reset();
+}
+
+void PollHandle::Close(const Napi::CallbackInfo &)
+{
+    Close();
+    callback.Reset();
+}
+
+void PollHandle::Ref(const Napi::CallbackInfo &)
+{
+    uv_ref((uv_handle_t *)handle);
+}
+
+void PollHandle::Unref(const Napi::CallbackInfo &)
+{
+    uv_unref((uv_handle_t *)handle);
+}
+
+void PollHandle::Close()
+{
+    if (!handle)
+        return;
+
+    const auto release = [](uv_handle_t *ptr) {
+        uv_poll_t *handle = (uv_poll_t *)ptr;
+        delete handle;
+    };
+
+    uv_poll_stop(handle);
+    uv_close((uv_handle_t *)handle, release);
+
+    handle = nullptr;
+}
+
+void PollHandle::OnPoll(uv_poll_t *h, int status, int events)
+{
+    PollHandle *poll = (PollHandle *)h->data;
+
+    if (poll->callback.IsEmpty()) [[unlikely]]
+        return;
+
+    Napi::Env env = poll->env;
+    Napi::HandleScope scope(env);
+
+    Napi::Object obj = Napi::Object::New(env);
+
+    obj.Set("readable", !!(events & UV_READABLE));
+    obj.Set("writable", !!(events & UV_WRITABLE));
+    obj.Set("disconnect", !!(events & UV_DISCONNECT));
+
+    napi_value args[] = { Napi::Number::New(env, status), obj };
+    poll->callback.Call(poll->Value(), K_LEN(args), args);
+}
+
+Napi::Value Poll(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    bool has_opts = (info.Length() >= 3 && info[1].IsObject());
+
+    if (info.Length() < 2u + has_opts) {
+        ThrowError<Napi::TypeError>(env, "Expected 2 to 3 arguments, got %1", info.Length());
+        return env.Null();
+    }
+
+    if (!info[0].IsNumber()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for descriptor, expected number", GetValueType(instance, info[0]));
+        return env.Null();
+    }
+    if (!info[1 + has_opts].IsFunction()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for callback, expected function", GetValueType(instance, info[1 + has_opts]));
+        return env.Null();
+    }
+
+    int fd = info[0].As<Napi::Number>().Int32Value();
+
+    Napi::Function ctor = PollHandle::Define(env);
+    Napi::Object inst = ctor.New({ Napi::Number::New(env, fd) });
+    Napi::Function start = inst.Get("start").As<Napi::Function>();
+
+    if (env.IsExceptionPending()) [[unlikely]]
+        return env.Null();
+
+    if (has_opts) {
+        Napi::Value opts = info[1];
+        Napi::Function cb = info[2].As<Napi::Function>();
+
+        start.Call(inst, { opts, cb });
+    } else {
+        Napi::Function cb = info[1].As<Napi::Function>();
+        start.Call(inst, { cb });
+    }
+
+    return inst;
+}
+
+}

package/src/koffi/src/uv.def

@@ -0,0 +1,10 @@
+NAME NODE.EXE
+EXPORTS
+uv_close
+uv_ref
+uv_unref
+uv_strerror
+uv_poll_init
+uv_poll_init_socket
+uv_poll_start
+uv_poll_stop