koffi 2.14.0-beta.1 → 2.14.0-beta.3

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/index.d.ts

@@ -105,14 +105,15 @@ 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, hint?: ArrayHint | 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

@@ -4,9 +4,9 @@ var __commonJS = (cb, mod3) => function __require() {
   return mod3 || (0, cb[__getOwnPropNames(cb)[0]])((mod3 = { exports: {} }).exports, mod3), mod3.exports;
 };
 
-// ../../bin/Koffi/package/src/cnoke/src/tools.js
+// bin/Koffi/package/src/cnoke/src/tools.js
 var require_tools = __commonJS({
-  "../../bin/Koffi/package/src/cnoke/src/tools.js"(exports2, module2) {
+  "bin/Koffi/package/src/cnoke/src/tools.js"(exports2, module2) {
     "use strict";
     var crypto = require("crypto");
     var fs2 = require("fs");
@@ -397,12 +397,12 @@ var require_tools = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/package.json
+// bin/Koffi/package/src/koffi/package.json
 var require_package = __commonJS({
-  "../../bin/Koffi/package/src/koffi/package.json"(exports2, module2) {
+  "bin/Koffi/package/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.14.0-beta.1",
+      version: "2.14.0-beta.3",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -443,9 +443,9 @@ var require_package = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/src/init.js
+// bin/Koffi/package/src/koffi/src/init.js
 var require_init = __commonJS({
-  "../../bin/Koffi/package/src/koffi/src/init.js"(exports, module) {
+  "bin/Koffi/package/src/koffi/src/init.js"(exports, module) {
     var fs = require("fs");
     var path = require("path");
     var util = require("util");
@@ -528,7 +528,7 @@ var require_init = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/index.js
+// bin/Koffi/package/src/koffi/index.js
 var { detect: detect2, init: init2 } = require_init();
 var triplet2 = detect2();
 var native2 = null;

package/indirect.js

@@ -4,9 +4,9 @@ var __commonJS = (cb, mod3) => function __require() {
   return mod3 || (0, cb[__getOwnPropNames(cb)[0]])((mod3 = { exports: {} }).exports, mod3), mod3.exports;
 };
 
-// ../../bin/Koffi/package/src/cnoke/src/tools.js
+// bin/Koffi/package/src/cnoke/src/tools.js
 var require_tools = __commonJS({
-  "../../bin/Koffi/package/src/cnoke/src/tools.js"(exports2, module2) {
+  "bin/Koffi/package/src/cnoke/src/tools.js"(exports2, module2) {
     "use strict";
     var crypto = require("crypto");
     var fs2 = require("fs");
@@ -397,12 +397,12 @@ var require_tools = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/package.json
+// bin/Koffi/package/src/koffi/package.json
 var require_package = __commonJS({
-  "../../bin/Koffi/package/src/koffi/package.json"(exports2, module2) {
+  "bin/Koffi/package/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.14.0-beta.1",
+      version: "2.14.0-beta.3",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -443,9 +443,9 @@ var require_package = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/src/init.js
+// bin/Koffi/package/src/koffi/src/init.js
 var require_init = __commonJS({
-  "../../bin/Koffi/package/src/koffi/src/init.js"(exports, module) {
+  "bin/Koffi/package/src/koffi/src/init.js"(exports, module) {
     var fs = require("fs");
     var path = require("path");
     var util = require("util");
@@ -528,7 +528,7 @@ var require_init = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/indirect.js
+// bin/Koffi/package/src/koffi/indirect.js
 var { detect: detect2, init: init2 } = require_init();
 var triplet2 = detect2();
 var mod2 = init2(triplet2, null);

package/package.json

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

package/src/koffi/src/call.cc

@@ -523,6 +523,13 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
         const RecordMember &member = members[i];
         Napi::Value value = obj.Get(member.name);
 
+        if (member.countedby >= 0) {
+            const char *countedby = members[member.countedby].name;
+
+            if (!CheckDynamicLength(obj, member.type->ref.type->size, countedby, value)) [[unlikely]]
+                return false;
+        }
+
         if (value.IsUndefined())
             continue;
 
@@ -708,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;
@@ -756,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;
@@ -938,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;
@@ -994,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 { \
@@ -1124,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);
@@ -1359,6 +1365,49 @@ void CallData::DumpForward(const FunctionInfo *func) const
     DumpMemory("Heap", heap);
 }
 
+bool CallData::CheckDynamicLength(Napi::Object obj, Size element, const char *countedby, Napi::Value value)
+{
+    int64_t expected = -1;
+    int64_t size = -1;
+
+    // Get expected size
+    {
+        Napi::Value by = obj.Get(countedby);
+
+        if (!by.IsNumber() && !by.IsBigInt()) [[unlikely]] {
+            ThrowError<Napi::Error>(env, "Unexpected %1 value for dynamic length, expected number", GetValueType(instance, by));
+            return false;
+        }
+
+        // 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 size
+    if (value.IsArray()) {
+        Napi::Array array = value.As<Napi::Array>();
+        size = array.Length() * element;
+    } else if (value.IsTypedArray()) {
+        Napi::TypedArray typed = value.As<Napi::TypedArray>();
+        size = typed.ByteLength();
+    } else if (value.IsArrayBuffer()) {
+        Napi::ArrayBuffer buffer = value.As<Napi::ArrayBuffer>();
+        size = buffer.ByteLength();
+    } else if (!IsNullOrUndefined(value)) {
+        size = element;
+    } else {
+        size = 0;
+    }
+
+    if (size != expected) {
+        ThrowError<Napi::Error>(env, "Mismatched dynamic length between '%1' and actual array", countedby);
+        return false;
+    }
+
+    return true;
+}
+
 static inline Napi::Value GetReferenceValue(Napi::Env env, napi_ref ref)
 {
     napi_value value;

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);
@@ -138,6 +138,8 @@ private:
     template <typename T = uint8_t>
     T *AllocHeap(Size size, Size align);
 
+    bool CheckDynamicLength(Napi::Object obj, Size element, const char *countedby, Napi::Value value);
+
     void PopOutArguments();
 };
 

package/src/koffi/src/ffi.cc

@@ -232,33 +232,6 @@ static bool MapType(Napi::Env env, InstanceData *instance, const TypeInfo *type,
     return true;
 }
 
-static bool CheckDynamicMembers(Napi::Env env, TypeInfo *type)
-{
-    for (RecordMember &member: type->members) {
-        const char *countedby = member.type->countedby;
-
-        if (countedby) {
-            const RecordMember *by = std::find_if(type->members.begin(), type->members.end(),
-                [&](const RecordMember &member) { return TestStr(member.name, countedby); });
-
-            if (by == member.type->members.end()) {
-                ThrowError<Napi::Error>(env, "Record type %1 does not have member '%2'", type->name, countedby);
-                return false;
-            }
-            if (!IsInteger(by->type)) {
-                ThrowError<Napi::Error>(env, "Dynamic length member %1 is not an integer", countedby);
-                return false;
-            }
-
-            member.countedby = by - type->members.ptr;
-        } else {
-            member.countedby = -1;
-        }
-    }
-
-    return true;
-}
-
 static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 {
     Napi::Env env = info.Env();
@@ -375,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();
@@ -399,8 +374,30 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         type->members.Append(member);
     }
 
-    if (!CheckDynamicMembers(env, type))
-        return env.Null();
+    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(),
+                [&](const RecordMember &member) { return TestStr(member.name, countedby); });
+
+            if (by == type->members.end()) {
+                ThrowError<Napi::Error>(env, "Record type %1 does not have member '%2'", type->name, countedby);
+                return env.Null();
+            }
+            if (!IsInteger(by->type)) {
+                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;
+        }
+    }
 
     size = (int32_t)AlignLen(size, type->align);
     if (!size) {
@@ -537,11 +534,17 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
             ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a member (maybe try %1 *)", member.type->name);
             return env.Null();
         }
+        if (member.type->countedby) {
+            ThrowError<Napi::TypeError>(env, "Cannot use dynamic-length array or pointer inside of union");
+            return env.Null();
+        }
 
         align = align ? align : member.type->align;
         size = std::max(size, member.type->size);
         type->align = std::max(type->align, align);
 
+        member.countedby = -1;
+
         if (TestStr(member.name, "_"))
             continue;
 
@@ -561,9 +564,6 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
         type->members.Append(member);
     }
 
-    if (!CheckDynamicMembers(env, type))
-        return env.Null();
-
     size = (int32_t)AlignLen(size, type->align);
     if (!size) {
         ThrowError<Napi::Error>(env, "Empty union '%1' is not allowed in C", type->name);
@@ -971,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();
     }
 
@@ -979,27 +979,22 @@ 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();
-        }
-    } else {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for length, expected integer or string", GetValueType(instance, info[1]));
+    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()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for %2, expected integer", GetValueType(instance, info[1]), dynamic ? "maxLen" : "len");
+        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);
@@ -1008,25 +1003,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() >= 3 + 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();
@@ -1043,8 +1038,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;
     }
 

package/src/koffi/src/util.cc

@@ -483,6 +483,9 @@ Napi::External<TypeInfo> WrapType(Napi::Env env, InstanceData *instance, const T
 
 bool CanPassType(const TypeInfo *type, int directions)
 {
+    if (type->countedby)
+        return false;
+
     if (directions & 2) {
         if (type->primitive == PrimitiveKind::Pointer)
             return true;
@@ -510,6 +513,9 @@ bool CanPassType(const TypeInfo *type, int directions)
 
 bool CanReturnType(const TypeInfo *type)
 {
+    if (type->countedby)
+        return false;
+
     if (type->primitive == PrimitiveKind::Void && !TestStr(type->name, "void"))
         return false;
     if (type->primitive == PrimitiveKind::Array)
@@ -900,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);
@@ -1628,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;