koffi 2.14.0-beta.2 → 2.14.0

package/CHANGELOG.md

@@ -5,6 +5,17 @@
 
 ## Koffi 2
 
+### Koffi 2.14
+
+#### Koffi 2.14.0
+
+*Released on 2025-08-17*
+
+- Improve support for structs with [flexible array member](input#flexible-arrays)
+- Automatically encode/decode dynamic arrays pointers when length is known though struct member
+- Fix parser crash when direction qualifier is followed by unknown type
+- Add missing TypeScript types and arguments
+
 ### Koffi 2.13
 
 #### Koffi 2.13.0

package/doc/pages/benchmarks.md

@@ -15,7 +15,7 @@ These results are detailed and explained below, and compared to node-ffi/node-ff
 
 # Linux x86_64
 
-The results presented below were measured on my x86_64 Linux machine (Intel® Core™ i5-4460).
+The results presented below were measured on my x86_64 Linux machine (AMD Ryzen™ 5 2600).
 
 ## rand results
 
@@ -27,9 +27,9 @@ This test is based around repeated calls to a simple standard C function `rand`,
 
 Benchmark     | Iteration time | Relative performance | Overhead
 ------------- | -------------- | -------------------- | --------
-rand_napi     | 700 ns         | x1.00                | (ref)
-rand_koffi    | 1152 ns        | x0.61                | +64%
-rand_node_ffi | 32750 ns       | x0.02                | +4576%
+rand_napi     | 569 ns         | x1.00                | (ref)
+rand_koffi    | 855 ns         | x0.67                | +50%
+rand_node_ffi | 58730 ns       | x0.010               | +10228%
 
 Because rand is a pretty small function, the FFI overhead is clearly visible.
 
@@ -39,9 +39,9 @@ This test is similar to the rand one, but it is based on `atoi`, which takes a s
 
 Benchmark     | Iteration time | Relative performance | Overhead
 ------------- | -------------- | -------------------- | --------
-atoi_napi     | 1028 ns        | x1.00                | (ref)
-atoi_koffi    | 1730 ns        | x0.59                | +68%
-atoi_node_ffi | 121670 ns      | x0.008               | +11738%
+atoi_napi     | 1039 ns        | x1.00                | (ref)
+atoi_koffi    | 1642 ns        | x0.63                | +58%
+atoi_node_ffi | 164790 ns      | x0.006               | +15767%
 
 Because atoi is a pretty small function, the FFI overhead is clearly visible.
 
@@ -54,10 +54,10 @@ This benchmark uses the CPU-based image drawing functions in Raylib. The calls a
 
 Benchmark          | Iteration time | Relative performance | Overhead
 ------------------ | -------------- | -------------------- | --------
-raylib_cc          | 18.5 µs        | x1.42                | -30%
-raylib_node_raylib | 26.3 µs        | x1.00                | (ref)
-raylib_koffi       | 28.0 µs        | x0.94                | +6%
-raylib_node_ffi    | 87.0 µs        | x0.30                | +230%
+raylib_cc          | 17.5 µs        | x1.34                | -25%
+raylib_node_raylib | 23.4 µs        | x1.00                | (ref)
+raylib_koffi       | 28.8 µs        | x0.81                | +23%
+raylib_node_ffi    | 103.9 µs       | x0.23                | +344%
 
 # Windows x86_64
 

package/doc/pages/input.md

@@ -396,6 +396,72 @@ Koffi can also convert JS strings to fixed-sized arrays in the following cases:
 
 The reverse case is also true, Koffi can convert a C fixed-size buffer to a JS string. This happens by default for char, char16_t and char32_t arrays, but you can also explicitly ask for this with the `String` array hint (e.g. `koffi.array('char', 8, 'String')`).
 
+## Flexible arrays
+
+*Added in Koffi 2.14.0*
+
+C structs ending with a flexible array member are often used for variable-sized structs, and are generally paired with dynamic memory allocation. In many cases, the number of elements is described by another struct member.
+
+Use `koffi.array(type, countedBy, maxLen)` to make a flexible array type, for which the array length is determined by the struct member indicated by the `countedBy` parameter. Flexible array types can only be used as the last member of a struct, as shown below:
+
+```js
+const FlexibleArray = koffi.struct('FlexibleArray', {
+    count: 'size_t',
+    numbers: koffi.array('int', 'count', 128)
+});
+````
+
+For various reasons, Koffi requires you to specify an upper bound (`maxLen`) for the number of elements in the flexible array member.
+
+> [!WARNING]
+> Also, unlike C flexible arrays, the struct size will expand to accomodate the maximum size of the flexible array.
+
+The following example illustrates how to use a flexible array API in C from Koffi.
+
+```c
+// Build with: clang -fPIC -o flexible.so -shared flexible.c -Wall -O2
+
+#include <stddef.h>
+
+struct FlexibleArray {
+    size_t count;
+    int numbers[];
+};
+
+void AppendValues(struct FlexibleArray *arr, size_t count, int start, int step)
+{
+    for (size_t i = 0; i < count; i++) {
+        arr->numbers[arr->count + i] = start + i * step;
+    }
+    arr->count += count;
+}
+```
+
+```js
+// ES6 syntax: import koffi from 'koffi';
+const koffi = require('koffi');
+
+const lib = koffi.load('./flexible.so');
+
+const FlexibleArray = koffi.struct('FlexibleArray', {
+    count: 'size_t',
+    numbers: koffi.array('int', 'count', 256, 'Array')
+});
+
+const AppendValues = lib.func('void AppendValues(_Inout_ FlexibleArray *arr, int count, int start, int step)');
+
+let array = { count: 0, numbers: [] };
+
+AppendValues(array, 5, 1, 1);
+console.log(array); // Prints { count: 5, numbers: [1, 2, 3, 4, 5] }
+
+AppendValues(array, 3, 10, 2);
+console.log(array); // Prints { count: 8, numbers: [1, 2, 3, 4, 5, 10, 12, 14] }
+```
+
+> [!NOTE]
+> This is frequently used in the Win32 API, an exemple of this is [AllocateAndInitializeSid()](https://learn.microsoft.com/windows/win32/api/securitybaseapi/nf-securitybaseapi-allocateandinitializesid).
+
 ## Dynamic arrays (pointers)
 
 In C, dynamically-sized arrays are usually passed around as pointers. Read more about [array pointers](pointers#dynamic-arrays) in the relevant section.

package/index.d.ts

@@ -105,14 +105,14 @@ export class Union {
 }
 
 export function array(ref: TypeSpec, len: number, hint?: ArrayHint | null): IKoffiCType;
-export function array(ref: TypeSpec, countedBy: string, hint?: ArrayHint | null, len?: number | null): IKoffiCType;
+export function array(ref: TypeSpec, countedBy: string, maxLen: number, hint?: ArrayHint | null): IKoffiCType;
 
 export function opaque(name: string | null | undefined): IKoffiCType;
 export function opaque(): IKoffiCType;
 /** @deprecated */ export function handle(name: string | null | undefined): IKoffiCType;
 /** @deprecated */ export function handle(): IKoffiCType;
 
-export function pointer(ref: TypeSpec, countedBy?: string | null): IKoffiCType;
+export function pointer(ref: TypeSpec): IKoffiCType;
 export function pointer(ref: TypeSpec, count: number): IKoffiCType;
 export function pointer(name: string | null | undefined, ref: TypeSpec, countedBy?: string | null): IKoffiCType;
 export function pointer(name: string | null | undefined, ref: TypeSpec, count: number): IKoffiCType;

package/index.js

@@ -402,7 +402,7 @@ var require_package = __commonJS({
   "../../../bin/Koffi/package/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.14.0-beta.2",
+      version: "2.14.0",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",

package/indirect.js

@@ -402,7 +402,7 @@ var require_package = __commonJS({
   "../../../bin/Koffi/package/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.14.0-beta.2",
+      version: "2.14.0",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "2.14.0-beta.2",
+    "version": "2.14.0",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",

package/src/core/base/base.cc

@@ -854,6 +854,31 @@ TimeSpec DecomposeTimeLocal(int64_t time)
     return spec;
 }
 
+int64_t ComposeTimeUTC(const TimeSpec &spec)
+{
+    RG_ASSERT(!spec.offset);
+
+    struct tm ti = {};
+
+    ti.tm_year = spec.year - 1900;
+    ti.tm_mon = spec.month - 1;
+    ti.tm_mday = spec.day;
+    ti.tm_hour = spec.hour;
+    ti.tm_min = spec.min;
+    ti.tm_sec = spec.sec;
+
+#if defined(_WIN32)
+    int64_t time = (int64_t)_mkgmtime64(&ti);
+#else
+    int64_t time = (int64_t)timegm(&ti);
+#endif
+
+    time *= 1000;
+    time += spec.msec;
+
+    return time;
+}
+
 // ------------------------------------------------------------------------
 // Strings
 // ------------------------------------------------------------------------

package/src/core/base/base.hh

@@ -3669,6 +3669,7 @@ struct TimeSpec {
 
 TimeSpec DecomposeTimeUTC(int64_t time);
 TimeSpec DecomposeTimeLocal(int64_t time);
+int64_t ComposeTimeUTC(const TimeSpec &spec);
 
 // ------------------------------------------------------------------------
 // Format

package/src/koffi/src/call.cc

@@ -517,7 +517,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
         RG_UNREACHABLE();
     }
 
-    memset(origin, 0, type->size);
+    MemSet(origin, 0, type->size);
 
     for (Size i = 0; i < members.len; i++) {
         const RecordMember &member = members[i];
@@ -715,13 +715,11 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             case PrimitiveKind::Array: {
                 if (value.IsArray()) {
                     Napi::Array array = value.As<Napi::Array>();
-                    Size len = (Size)member.type->size / member.type->ref.type->size;
-
-                    if (!PushNormalArray(array, len, member.type, dest))
+                    if (!PushNormalArray(array, member.type, member.type->size, dest))
                         return false;
                 } else if (IsRawBuffer(value)) {
                     Span<const uint8_t> buffer = GetRawBuffer(value);
-                    PushBuffer(buffer, member.type->size, member.type, dest);
+                    PushBuffer(buffer, member.type, dest);
                 } else if (value.IsString()) {
                     if (!PushStringArray(value, member.type, dest))
                         return false;
@@ -763,15 +761,18 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
     return true;
 }
 
-bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *type, uint8_t *origin)
+bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size size, uint8_t *origin)
 {
     RG_ASSERT(array.IsArray());
 
     const TypeInfo *ref = type->ref.type;
+    Size len = (Size)array.Length();
+    Size available = len * ref->size;
 
-    if (array.Length() != (size_t)len) [[unlikely]] {
-        ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.Length());
-        return false;
+    if (available > size) {
+        len = size / ref->size;
+    } else {
+        MemSet(origin + available, 0, size - available);
     }
 
     Size offset = 0;
@@ -945,13 +946,11 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *type
 
                 if (value.IsArray()) {
                     Napi::Array array2 = value.As<Napi::Array>();
-                    Size len2 = (Size)ref->size / ref->ref.type->size;
-
-                    if (!PushNormalArray(array2, len2, ref, dest))
+                    if (!PushNormalArray(array2, ref, (Size)ref->size, dest))
                         return false;
                 } else if (IsRawBuffer(value)) {
                     Span<const uint8_t> buffer = GetRawBuffer(value);
-                    PushBuffer(buffer, ref->size, ref, dest);
+                    PushBuffer(buffer, ref, dest);
                 } else if (value.IsString()) {
                     if (!PushStringArray(value, ref, dest))
                         return false;
@@ -1001,13 +1000,13 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *type
     return true;
 }
 
-void CallData::PushBuffer(Span<const uint8_t> buffer, Size size, const TypeInfo *type, uint8_t *origin)
+void CallData::PushBuffer(Span<const uint8_t> buffer, const TypeInfo *type, uint8_t *origin)
 {
-    buffer.len = std::min(buffer.len, size);
+    buffer.len = std::min(buffer.len, (Size)type->size);
 
     // Go fast brrrrrrr :)
-    MemCpy(origin, buffer.ptr, (size_t)buffer.len);
-    MemSet(origin + buffer.len, 0, (size_t)(size - buffer.len));
+    MemCpy(origin, buffer.ptr, buffer.len);
+    MemSet(origin + buffer.len, 0, (Size)type->size - buffer.len);
 
 #define SWAP(CType) \
         do { \
@@ -1131,7 +1130,7 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                     ptr = AllocHeap(size, 16);
 
                     if (directions & 1) {
-                        if (!PushNormalArray(array, len, type, ptr))
+                        if (!PushNormalArray(array, type, size, ptr))
                             return false;
                     } else {
                         MemSet(ptr, 0, size);
@@ -1369,9 +1368,9 @@ void CallData::DumpForward(const FunctionInfo *func) const
 bool CallData::CheckDynamicLength(Napi::Object obj, Size element, const char *countedby, Napi::Value value)
 {
     int64_t expected = -1;
-    int64_t len = -1;
+    int64_t size = -1;
 
-    // Get expected length
+    // Get expected size
     {
         Napi::Value by = obj.Get(countedby);
 
@@ -1380,24 +1379,28 @@ bool CallData::CheckDynamicLength(Napi::Object obj, Size element, const char *co
             return false;
         }
 
-        expected = GetNumber<int64_t>(by);
+        // If we get anywhere near overflow there are other problems to worry about.
+        // So let's not worry about that.
+        expected = GetNumber<int64_t>(by) * element;
     }
 
-    // Get actual length
+    // Get actual size
     if (value.IsArray()) {
         Napi::Array array = value.As<Napi::Array>();
-        len = array.Length();
+        size = array.Length() * element;
     } else if (value.IsTypedArray()) {
         Napi::TypedArray typed = value.As<Napi::TypedArray>();
-        len = typed.ByteLength() / element;
+        size = typed.ByteLength();
     } else if (value.IsArrayBuffer()) {
         Napi::ArrayBuffer buffer = value.As<Napi::ArrayBuffer>();
-        len = buffer.ByteLength() / element;
+        size = buffer.ByteLength();
+    } else if (!IsNullOrUndefined(value)) {
+        size = element;
     } else {
-        len = !IsNullOrUndefined(value);
+        size = 0;
     }
 
-    if (len != expected) {
+    if (size != expected) {
         ThrowError<Napi::Error>(env, "Mismatched dynamic length between '%1' and actual array", countedby);
         return false;
     }

package/src/koffi/src/call.hh

@@ -121,8 +121,8 @@ public:
     bool PushString32(Napi::Value value, int directions, const char32_t **out_str32);
     Size PushString32Value(Napi::Value value, const char32_t **out_str32);
     bool PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin);
-    bool PushNormalArray(Napi::Array array, Size len, const TypeInfo *type, uint8_t *origin);
-    void PushBuffer(Span<const uint8_t> buffer, Size size, const TypeInfo *type, uint8_t *origin);
+    bool PushNormalArray(Napi::Array array, const TypeInfo *type, Size size, uint8_t *origin);
+    void PushBuffer(Span<const uint8_t> buffer, const TypeInfo *type, uint8_t *origin);
     bool PushStringArray(Napi::Value value, const TypeInfo *type, uint8_t *origin);
     bool PushPointer(Napi::Value value, const TypeInfo *type, int directions, void **out_ptr);
     bool PushCallback(Napi::Value value, const TypeInfo *type, void **out_ptr);
@@ -156,7 +156,7 @@ inline bool CallData::AllocStack(Size size, Size align, T **out_ptr)
     }
 
 #if defined(RG_DEBUG)
-    memset(ptr, 0, delta);
+    MemSet(ptr, 0, delta);
 #endif
 
     mem->stack.len -= delta;
@@ -173,7 +173,7 @@ inline T *CallData::AllocHeap(Size size, Size align)
 
     if (size < 4096 && delta <= mem->heap.len) [[likely]] {
 #if defined(RG_DEBUG)
-        memset(mem->heap.ptr, 0, (size_t)delta);
+        MemSet(mem->heap.ptr, 0, delta);
 #endif
 
         mem->heap.ptr += delta;

package/src/koffi/src/ffi.cc

@@ -348,6 +348,8 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         size = member.offset + member.type->size;
         type->align = std::max(type->align, align);
 
+        member.countedby = -1;
+
         if (size > instance->config.max_type_size) {
             ThrowError<Napi::Error>(env, "Struct '%1' size is too high (max = %2)", type->name, FmtMemSize(size));
             return env.Null();
@@ -372,8 +374,9 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         type->members.Append(member);
     }
 
-    for (RecordMember &member: type->members) {
-        const char *countedby = member.type->countedby;
+    for (Size i = 0; i < type->members.len; i++) {
+        RecordMember *member = &type->members[i];
+        const char *countedby = member->type->countedby;
 
         if (countedby) {
             const RecordMember *by = std::find_if(type->members.begin(), type->members.end(),
@@ -387,10 +390,12 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
                 ThrowError<Napi::Error>(env, "Dynamic length member %1 is not an integer", countedby);
                 return env.Null();
             }
+            if (member->type->primitive == PrimitiveKind::Array && i < type->members.len - 1) {
+                ThrowError<Napi::Error>(env, "Flexible array '%1' is not the last member of struct", member->name);
+                return env.Null();
+            }
 
-            member.countedby = by - type->members.ptr;
-        } else {
-            member.countedby = -1;
+            member->countedby = by - type->members.ptr;
         }
     }
 
@@ -966,7 +971,7 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     if (info.Length() < 2) {
-        ThrowError<Napi::TypeError>(env, "Expected 2 to 3 arguments, got %1", info.Length());
+        ThrowError<Napi::TypeError>(env, "Expected 2 to 4 arguments, got %1", info.Length());
         return env.Null();
     }
 
@@ -974,27 +979,26 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
     if (!ref)
         return env.Null();
 
-    int64_t len = 0;
-    Napi::Value countedby;
-
-    if (info[1].IsNumber()) {
-        len = info[1].As<Napi::Number>().Int64Value();
-    } else if (info[1].IsString()) {
-        countedby = info[1];
+    bool dynamic = (info.Length() >= 3) && info[1].IsString();
 
-        if (info.Length() >= 4 && !IsNullOrUndefined(info[3])) {
-            len = info[3].As<Napi::Number>().Int64Value();
+    if (dynamic && !info[1].IsString()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for countedBy, expected string", GetValueType(instance, info[1]));
+        return env.Null();
+    }
+    if (!info[1 + dynamic].IsNumber()) {
+        if (info.Length() == 2 && info[1].IsString()) {
+            ThrowError<Napi::TypeError>(env, "Missing maxLen argument");
+        } else {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for %2, expected integer", GetValueType(instance, info[1]), dynamic ? "maxLen" : "len");
         }
-    } else {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for length, expected integer or string", GetValueType(instance, info[1]));
+        return env.Null();
     }
 
-    if (countedby.IsEmpty() && len <= 0) {
+    int64_t len = info[1 + dynamic].As<Napi::Number>().Int64Value();
+
+    if (len <= 0) {
         ThrowError<Napi::TypeError>(env, "Array length must be positive and non-zero");
         return env.Null();
-    } else if (len < 0) {
-        ThrowError<Napi::TypeError>(env, "Array length must be positive");
-        return env.Null();
     }
     if (len > instance->config.max_type_size / ref->size) {
         ThrowError<Napi::TypeError>(env, "Array length is too high (max = %1)", instance->config.max_type_size / ref->size);
@@ -1003,25 +1007,25 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
 
     TypeInfo *type = nullptr;
 
-    if (info.Length() >= 3 && !IsNullOrUndefined(info[2])) {
-        if (!info[2].IsString()) {
+    if (info.Length() >= 3u + dynamic && !IsNullOrUndefined(info[2 + dynamic])) {
+        if (!info[2 + dynamic].IsString()) {
             ThrowError<Napi::TypeError>(env, "Unexpected %1 value for hint, expected string", GetValueType(instance, info[2]));
             return env.Null();
         }
 
-        std::string to = info[2].As<Napi::String>();
+        std::string str = info[2 + dynamic].As<Napi::String>();
         ArrayHint hint = {};
 
-        if (to == "Typed" || to == "typed") {
+        if (str == "Typed" || str == "typed") {
             if (!(ref->flags & (int)TypeFlag::HasTypedArray)) {
                 ThrowError<Napi::Error>(env, "Array hint 'Typed' cannot be used with type %1", ref->name);
                 return env.Null();
             }
 
             hint = ArrayHint::Typed;
-        } else if (to == "Array" || to == "array") {
+        } else if (str == "Array" || str == "array") {
             hint = ArrayHint::Array;
-        } else if (to == "String" || to == "string") {
+        } else if (str == "String" || str == "string") {
             if (ref->primitive != PrimitiveKind::Int8 && ref->primitive != PrimitiveKind::Int16) {
                 ThrowError<Napi::Error>(env, "Array hint 'String' can only be used with 8 and 16-bit signed integer types");
                 return env.Null();
@@ -1038,8 +1042,8 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
         type = MakeArrayType(instance, ref, len);
     }
 
-    if (!countedby.IsEmpty()) {
-        Napi::String str = countedby.As<Napi::String>();
+    if (dynamic) {
+        Napi::String str = info[1].As<Napi::String>();
         type->countedby = DuplicateString(str.Utf8Value().c_str(), &instance->str_alloc).ptr;
     }
 
@@ -2087,7 +2091,7 @@ static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
 
     bool has_offset = (info.Length() >= 2 && info[1].IsNumber());
-    bool has_len = (info.Length() >= 3u + has_offset && info[2u + has_offset].IsNumber());
+    bool has_len = (info.Length() >= 3u + has_offset && info[2 + has_offset].IsNumber());
 
     if (info.Length() < 2u + has_offset) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected %1 to 4 arguments, got %2", 2 + has_offset, info.Length());
@@ -2102,7 +2106,7 @@ static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
     int64_t offset = has_offset ? info[1].As<Napi::Number>().Int64Value() : 0;
 
     if (has_len) {
-        Size len = info[2u + has_offset].As<Napi::Number>();
+        Size len = info[2 + has_offset].As<Napi::Number>();
 
         Napi::Value ret = Decode(value, offset, type, &len);
         return ret;
@@ -2164,7 +2168,7 @@ static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
 
     bool has_offset = (info.Length() >= 2 && info[1].IsNumber());
-    bool has_len = (info.Length() >= 4u + has_offset && info[3u + has_offset].IsNumber());
+    bool has_len = (info.Length() >= 4u + has_offset && info[3 + has_offset].IsNumber());
 
     if (info.Length() < 3u + has_offset) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Expected %1 to 5 arguments, got %2", 3 + has_offset, info.Length());
@@ -2177,10 +2181,10 @@ static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
 
     Napi::Value ref = info[0];
     int64_t offset = has_offset ? info[1].As<Napi::Number>().Int64Value() : 0;
-    Napi::Value value = info[2u + has_offset];
+    Napi::Value value = info[2 + has_offset];
 
     if (has_len) {
-        Size len = info[3u + has_offset].As<Napi::Number>();
+        Size len = info[3 + has_offset].As<Napi::Number>();
 
         if (!Encode(ref, offset, value, type, &len))
             return env.Null();

package/src/koffi/src/util.cc

@@ -906,7 +906,12 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
             case PrimitiveKind::Array: {
                 if (member.countedby >= 0) {
                     const RecordMember &by = type->members[member.countedby];
+
                     uint32_t len = DecodeDynamicLength(origin, by);
+                    uint32_t max = member.type->size / member.type->ref.type->size;
+
+                    // Silently truncate result
+                    len = std::min(len, max);
 
                     Napi::Value value = DecodeArray(env, src, member.type, len);
                     obj.Set(member.name, value);
@@ -1634,13 +1639,11 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
         case PrimitiveKind::Array: {
             if (value.IsArray()) {
                 Napi::Array array = value.As<Napi::Array>();
-                Size len = (Size)type->size / type->ref.type->size;
-
-                if (!call.PushNormalArray(array, len, type, origin))
+                if (!call.PushNormalArray(array, type, type->size, origin))
                     return false;
             } else if (IsRawBuffer(value)) {
                 Span<const uint8_t> buffer = GetRawBuffer(value);
-                call.PushBuffer(buffer, type->size, type, origin);
+                call.PushBuffer(buffer, type, origin);
             } else if (value.IsString()) {
                 if (!call.PushStringArray(value, type, origin))
                     return false;