koffi 2.13.0 → 2.14.0-beta.2

package/index.d.ts

@@ -19,7 +19,13 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 
-export function load(path: string | null): IKoffiLib;
+type LoadOptions = {
+    lazy?: boolean,
+    global?: boolean,
+    deep?: boolean
+};
+
+export function load(path: string | null, options?: LoadOptions): IKoffiLib;
 
 interface IKoffiCType { __brand: 'IKoffiCType' }
 interface IKoffiPointerCast { __brand: 'IKoffiPointerCast' }
@@ -65,17 +71,17 @@ export type KoffiFunc<T extends (...args: any) => any> = T & {
 
 export interface IKoffiLib {
     func(definition: string): KoffiFunction;
-    func(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
-    func(convention: string, name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
+    func(name: string | number, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
+    func(convention: string, name: string | number, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
 
     /** @deprecated */ cdecl(definition: string): KoffiFunction;
-    /** @deprecated */ cdecl(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
+    /** @deprecated */ cdecl(name: string | number, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
     /** @deprecated */ stdcall(definition: string): KoffiFunction;
-    /** @deprecated */ stdcall(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
+    /** @deprecated */ stdcall(name: string | number, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
     /** @deprecated */ fastcall(definition: string): KoffiFunction;
-    /** @deprecated */ fastcall(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
+    /** @deprecated */ fastcall(name: string | number, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
     /** @deprecated */ thiscall(definition: string): KoffiFunction;
-    /** @deprecated */ thiscall(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
+    /** @deprecated */ thiscall(name: string | number, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
 
     symbol(name: string, type: TypeSpec): any;
 
@@ -99,15 +105,16 @@ 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 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): IKoffiCType;
+export function pointer(ref: TypeSpec, countedBy?: string | null): IKoffiCType;
 export function pointer(ref: TypeSpec, count: number): IKoffiCType;
-export function pointer(name: string | null | undefined, ref: TypeSpec): 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;
 
 export function out(type: TypeSpec): IKoffiCType;
@@ -155,9 +162,22 @@ export function introspect(type: TypeSpec): TypeInfo;
 
 export function alias(name: string, type: TypeSpec): IKoffiCType;
 
-export function config(): Record<string, unknown>;
-export function config(cfg: Record<string, unknown>): Record<string, unknown>;
-export function stats(): Record<string, unknown>;
+type KoffiConfig = {
+    sync_stack_size: number
+    sync_heap_size: number
+    async_stack_size: number
+    async_heap_size: number
+    resident_async_pools: number
+    max_async_calls: number
+    max_type_size: number
+};
+type KoffiStats = {
+    disposed: number
+};
+
+export function config(): KoffiConfig;
+export function config(cfg: KoffiConfig): KoffiConfig;
+export function stats(): KoffiStats;
 
 export function alloc(type: TypeSpec, length: number): any;
 export function free(value: any): void;
@@ -254,5 +274,10 @@ type PrimitiveTypes =
     | 'ushort'
     | 'void'
     | 'wchar'
-    | 'wchar_t'
-export const types: Record<PrimitiveTypes, IKoffiCType>
+    | 'wchar_t';
+export const types: Record<PrimitiveTypes, IKoffiCType>;
+
+// Internal stuff, don't use!
+export const node: {
+    env: { __brand: 'IKoffiNodeEnv' }
+};

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.13.0",
+      version: "2.14.0-beta.2",
       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.13.0",
+      version: "2.14.0-beta.2",
       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.13.0",
+    "version": "2.14.0-beta.2",
     "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;
 
@@ -1359,6 +1366,45 @@ 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 len = -1;
+
+    // Get expected length
+    {
+        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;
+        }
+
+        expected = GetNumber<int64_t>(by);
+    }
+
+    // Get actual length
+    if (value.IsArray()) {
+        Napi::Array array = value.As<Napi::Array>();
+        len = array.Length();
+    } else if (value.IsTypedArray()) {
+        Napi::TypedArray typed = value.As<Napi::TypedArray>();
+        len = typed.ByteLength() / element;
+    } else if (value.IsArrayBuffer()) {
+        Napi::ArrayBuffer buffer = value.As<Napi::ArrayBuffer>();
+        len = buffer.ByteLength() / element;
+    } else {
+        len = !IsNullOrUndefined(value);
+    }
+
+    if (len != 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

@@ -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

@@ -372,6 +372,28 @@ 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;
+
+        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();
+            }
+
+            member.countedby = by - type->members.ptr;
+        } else {
+            member.countedby = -1;
+        }
+    }
+
     size = (int32_t)AlignLen(size, type->align);
     if (!size) {
         ThrowError<Napi::Error>(env, "Empty struct '%1' is not allowed in C", type->name);
@@ -507,11 +529,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;
 
@@ -633,39 +661,46 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
 
     std::string name = named ? info[0].As<Napi::String>() : std::string();
 
-    const TypeInfo *type = ResolveType(info[skip]);
-    if (!type)
+    const TypeInfo *ref = ResolveType(info[skip]);
+    if (!ref)
         return env.Null();
 
-    int count = 0;
-    if (info.Length() >= 2u + skip) {
-        if (!info[1 + skip].IsNumber()) {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for count, expected number", GetValueType(instance, info[1 + skip]));
-            return env.Null();
-        }
+    Napi::Value countedby;
+    int count = 1;
 
-        count = info[1 + skip].As<Napi::Number>();
+    if (info.Length() >= 2u + skip) {
+        if (info[1 + skip].IsString()) {
+            countedby = info[1 + skip];
+        } else if (info[1 + skip].IsNumber()) {
+            count = info[1 + skip].As<Napi::Number>();
 
-        if (count < 1 || count > 4) {
-            ThrowError<Napi::TypeError>(env, "Value of count must be between 1 and 4");
+            if (count < 1 || count > 4) {
+                ThrowError<Napi::TypeError>(env, "Value of count must be between 1 and 4");
+                return env.Null();
+            }
+        } else {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for count, expected number", GetValueType(instance, info[1 + skip]));
             return env.Null();
         }
-    } else {
-        count = 1;
     }
 
-    type = MakePointerType(instance, type, count);
+    TypeInfo *type = MakePointerType(instance, ref, count);
     RG_ASSERT(type);
 
-    if (named) {
+    if (named || !countedby.IsEmpty()) {
         TypeInfo *copy = instance->types.AppendDefault();
         RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
         memcpy((void *)copy, type, RG_SIZE(*type));
-        copy->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
+        copy->name = named ? DuplicateString(name.c_str(), &instance->str_alloc).ptr : copy->name;
+
+        if (!countedby.IsEmpty()) {
+            Napi::String str = countedby.As<Napi::String>();
+            copy->countedby = DuplicateString(str.Utf8Value().c_str(), &instance->str_alloc).ptr;
+        }
 
         // If the insert succeeds, we cannot fail anymore
-        if (!MapType(env, instance, copy, copy->name))
+        if (named && !MapType(env, instance, copy, copy->name))
             return env.Null();
         err_guard.Disable();
 
@@ -931,29 +966,42 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     if (info.Length() < 2) {
-        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
-        return env.Null();
-    }
-    if (!info[1].IsNumber()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for length, expected integer", GetValueType(instance, info[1]));
+        ThrowError<Napi::TypeError>(env, "Expected 2 to 3 arguments, got %1", info.Length());
         return env.Null();
     }
 
     const TypeInfo *ref = ResolveType(info[0]);
-    int64_t len = info[1].As<Napi::Number>().Int64Value();
-
     if (!ref)
         return env.Null();
-    if (len <= 0) {
+
+    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];
+
+        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 (countedby.IsEmpty() && 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);
         return env.Null();
     }
 
-    const TypeInfo *type = nullptr;
+    TypeInfo *type = nullptr;
 
     if (info.Length() >= 3 && !IsNullOrUndefined(info[2])) {
         if (!info[2].IsString()) {
@@ -990,6 +1038,11 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
         type = MakeArrayType(instance, ref, len);
     }
 
+    if (!countedby.IsEmpty()) {
+        Napi::String str = countedby.As<Napi::String>();
+        type->countedby = DuplicateString(str.Utf8Value().c_str(), &instance->str_alloc).ptr;
+    }
+
     return WrapType(env, instance, type);
 }
 
@@ -1334,6 +1387,9 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
                     obj.Set("name", member.name);
                     obj.Set("type", WrapType(env, instance, member.type));
                     obj.Set("offset", member.offset);
+                    if (member.countedby >= 0) {
+                        obj.Set("countedBy", type->members[member.countedby].name);
+                    }
 
                     members.Set(member.name, obj);
                 }

package/src/koffi/src/ffi.hh

@@ -147,6 +147,7 @@ struct TypeInfo {
         const FunctionInfo *proto; // Callback only
     } ref;
     ArrayHint hint; // Array only
+    const char *countedby; // Pointer or array
 
     mutable Napi::FunctionReference construct; // Union only
     mutable Napi::ObjectReference defn;
@@ -158,6 +159,7 @@ struct RecordMember {
     const char *name;
     const TypeInfo *type;
     int32_t offset;
+    Size countedby;
 };
 
 struct LibraryHolder {

package/src/koffi/src/parser.cc

@@ -164,9 +164,20 @@ const TypeInfo *PrototypeParser::ParseType(int *out_directions)
     }
     offset--;
 
+    if (out_directions && offset > start) {
+        int directions = ResolveDirections(tokens[start]);
+
+        if (directions) {
+            *out_directions = directions;
+            start++;
+        } else {
+            *out_directions = 1;
+        }
+    }
+
     while (offset >= start) {
         Span<const char> str = MakeSpan(tokens[start].ptr, tokens[offset].end() - tokens[start].ptr);
-        const TypeInfo *type = ResolveType(env, str, out_directions);
+        const TypeInfo *type = ResolveType(env, str);
 
         if (type) {
             offset++;

package/src/koffi/src/util.cc

@@ -110,6 +110,45 @@ void MagicUnion::Setter(const Napi::CallbackInfo &info, const Napi::Value &value
     raw.Clear();
 }
 
+static inline bool IsIdentifierStart(char c)
+{
+    return IsAsciiAlpha(c) || c == '_';
+}
+
+static inline bool IsIdentifierChar(char c)
+{
+    return IsAsciiAlphaOrDigit(c) || c == '_';
+}
+
+static inline Span<const char> SplitIdentifier(Span<const char> str)
+{
+    Size offset = 0;
+
+    if (str.len && IsIdentifierStart(str[0])) {
+        offset++;
+
+        while (offset < str.len && IsIdentifierChar(str[offset])) {
+            offset++;
+        }
+    }
+
+    Span<const char> token = str.Take(0, offset);
+    return token;
+}
+
+int ResolveDirections(Span<const char> str)
+{
+    if (str == "_In_") {
+        return 1;
+    } else if (str == "_Out_") {
+        return 2;
+    } else if (str == "_Inout_") {
+        return 3;
+    } else {
+        return 0;
+    }
+}
+
 const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
 {
     Napi::Env env = value.Env();
@@ -117,12 +156,27 @@ const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
 
     if (value.IsString()) {
         std::string str = value.As<Napi::String>();
+        Span<const char> remain = str.c_str();
 
         // Quick path for known types (int, float *, etc.)
-        const TypeInfo *type = instance->types_map.FindValue(str.c_str(), nullptr);
+        const TypeInfo *type = instance->types_map.FindValue(remain.ptr, nullptr);
 
         if (!type || (type->flags & (int)TypeFlag::IsIncomplete)) {
-            type = ResolveType(env, str.c_str(), out_directions);
+            if (out_directions) {
+                Span<const char> prefix = SplitIdentifier(remain);
+                int directions = ResolveDirections(prefix);
+
+                if (directions) {
+                    remain = remain.Take(prefix.len, remain.len - prefix.len);
+                    remain = TrimStrLeft(remain);
+
+                    *out_directions = directions;
+                } else {
+                    *out_directions = 1;
+                }
+            }
+
+            type = ResolveType(env, remain.ptr);
 
             if (!type) {
                 if (!env.IsExceptionPending()) {
@@ -133,10 +187,10 @@ const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
 
             // Cache for quick future access
             bool inserted;
-            auto bucket = instance->types_map.TrySetDefault(str.c_str(), &inserted);
+            auto bucket = instance->types_map.TrySetDefault(remain.ptr, &inserted);
 
             if (inserted) {
-                bucket->key = DuplicateString(str.c_str(), &instance->str_alloc).ptr;
+                bucket->key = DuplicateString(remain, &instance->str_alloc).ptr;
                 bucket->value = type;
             }
         } else if (out_directions) {
@@ -155,6 +209,7 @@ const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
             Size delta = (uint8_t *)raw - (uint8_t *)type;
             *out_directions = 1 + (int)delta;
         }
+
         return type;
     } else {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value as type specifier, expected string or type", GetValueType(instance, value));
@@ -162,33 +217,7 @@ const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
     }
 }
 
-static inline bool IsIdentifierStart(char c)
-{
-    return IsAsciiAlpha(c) || c == '_';
-}
-
-static inline bool IsIdentifierChar(char c)
-{
-    return IsAsciiAlphaOrDigit(c) || c == '_';
-}
-
-static inline Span<const char> SplitIdentifier(Span<const char> str)
-{
-    Size offset = 0;
-
-    if (str.len && IsIdentifierStart(str[0])) {
-        offset++;
-
-        while (offset < str.len && IsIdentifierChar(str[offset])) {
-            offset++;
-        }
-    }
-
-    Span<const char> token = str.Take(0, offset);
-    return token;
-}
-
-const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_directions)
+const TypeInfo *ResolveType(Napi::Env env, Span<const char> str)
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
@@ -196,28 +225,6 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
     LocalArray<Size, 8> arrays;
     uint8_t disposables = 0;
 
-    // Consume parameter direction qualifier
-    if (out_directions) {
-        if (str.len && str[0] == '_') {
-            Span<const char> qualifier = SplitIdentifier(str);
-
-            if (qualifier == "_In_") {
-                *out_directions = 1;
-                str = str.Take(5, str.len - 5);
-            } else if (qualifier == "_Out_") {
-                *out_directions = 2;
-                str = str.Take(6, str.len - 6);
-            } else if (qualifier == "_Inout_") {
-                *out_directions = 3;
-                str = str.Take(8, str.len - 8);
-            } else {
-                *out_directions = 1;
-            }
-        } else {
-            *out_directions = 1;
-        }
-    }
-
     Span<const char> name;
     Span<const char> after;
     {
@@ -383,7 +390,7 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
     return type;
 }
 
-const TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count)
+TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count)
 {
     RG_ASSERT(count >= 1);
 
@@ -404,6 +411,7 @@ const TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int
                 type->size = RG_SIZE(void *);
                 type->align = RG_SIZE(void *);
                 type->ref.type = ref;
+                type->hint = (ref->flags & (int)TypeFlag::HasTypedArray) ? ArrayHint::Typed : ArrayHint::Array;
             } else {
                 type->primitive = PrimitiveKind::Callback;
                 type->size = RG_SIZE(void *);
@@ -418,13 +426,12 @@ const TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int
         ref = bucket->value;
     }
 
-    return ref;
+    return (TypeInfo *)ref;
 }
 
-static const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len,
-                                     ArrayHint hint, bool insert)
+static TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint, bool insert)
 {
-    RG_ASSERT(len > 0);
+    RG_ASSERT(len >= 0);
     RG_ASSERT(len <= instance->config.max_type_size / ref->size);
 
     TypeInfo *type = instance->types.AppendDefault();
@@ -446,7 +453,7 @@ static const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref
     return type;
 }
 
-const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len)
+TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len)
 {
     ArrayHint hint = {};
 
@@ -461,7 +468,7 @@ const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size
     return MakeArrayType(instance, ref, len, hint, true);
 }
 
-const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint)
+TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint)
 {
     return MakeArrayType(instance, ref, len, hint, false);
 }
@@ -476,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;
@@ -503,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)
@@ -679,6 +692,86 @@ Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *
     return obj;
 }
 
+static uint32_t DecodeDynamicLength(const uint8_t *origin, const RecordMember &by)
+{
+    const uint8_t *src = origin + by.offset;
+
+    switch (by.type->primitive) {
+        case PrimitiveKind::Int8: {
+            int8_t i = *(int8_t *)src;
+            return (uint32_t)i;
+        } break;
+        case PrimitiveKind::UInt8: {
+            uint8_t u = *(uint8_t *)src;
+            return (uint32_t)u;
+        } break;
+        case PrimitiveKind::Int16: {
+            int16_t i = *(int16_t *)src;
+            return (uint32_t)i;
+        } break;
+        case PrimitiveKind::Int16S: {
+            int16_t i = ReverseBytes(*(int16_t *)src);
+            return (uint32_t)i;
+        } break;
+        case PrimitiveKind::UInt16: {
+            uint16_t u = *(uint16_t *)src;
+            return (uint32_t)u;
+        } break;
+        case PrimitiveKind::UInt16S: {
+            uint16_t u = ReverseBytes(*(uint16_t *)src);
+            return (uint32_t)u;
+        } break;
+        case PrimitiveKind::Int32: {
+            int32_t i = *(int32_t *)src;
+            return (uint32_t)i;
+        } break;
+        case PrimitiveKind::Int32S: {
+            int32_t i = ReverseBytes(*(int32_t *)src);
+            return (uint32_t)i;
+        } break;
+        case PrimitiveKind::UInt32: {
+            uint32_t u = *(uint32_t *)src;
+            return (uint32_t)u;
+        } break;
+        case PrimitiveKind::UInt32S: {
+            uint32_t u = ReverseBytes(*(uint32_t *)src);
+            return (uint32_t)u;
+        } break;
+        case PrimitiveKind::Int64: {
+            int64_t i = *(int64_t *)src;
+            return (uint32_t)i;
+        } break;
+        case PrimitiveKind::Int64S: {
+            int64_t i = ReverseBytes(*(int64_t *)src);
+            return (uint32_t)i;
+        } break;
+        case PrimitiveKind::UInt64: {
+            uint64_t u = *(uint64_t *)src;
+            return (uint32_t)u;
+        } break;
+        case PrimitiveKind::UInt64S: {
+            uint64_t u = ReverseBytes(*(uint64_t *)src);
+            return (uint32_t)u;
+        } break;
+
+        case PrimitiveKind::Void:
+        case PrimitiveKind::Bool:
+        case PrimitiveKind::String:
+        case PrimitiveKind::String16:
+        case PrimitiveKind::String32:
+        case PrimitiveKind::Pointer:
+        case PrimitiveKind::Callback:
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union:
+        case PrimitiveKind::Array:
+        case PrimitiveKind::Float32:
+        case PrimitiveKind::Float64:
+        case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
+    }
+
+    RG_UNREACHABLE();
+}
+
 void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
 {
     Napi::Env env = obj.Env();
@@ -786,7 +879,13 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
             case PrimitiveKind::Callback: {
                 void *ptr2 = *(void **)src;
 
-                if (ptr2) {
+                if (member.countedby >= 0) {
+                    const RecordMember &by = type->members[member.countedby];
+                    uint32_t len = DecodeDynamicLength(origin, by);
+
+                    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(instance, external, member.type->ref.marker);
 
@@ -805,8 +904,16 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
                 obj.Set(member.name, obj2);
             } break;
             case PrimitiveKind::Array: {
-                Napi::Value value = DecodeArray(env, src, member.type);
-                obj.Set(member.name, value);
+                if (member.countedby >= 0) {
+                    const RecordMember &by = type->members[member.countedby];
+                    uint32_t len = DecodeDynamicLength(origin, by);
+
+                    Napi::Value value = DecodeArray(env, src, member.type, len);
+                    obj.Set(member.name, value);
+                } else {
+                    Napi::Value value = DecodeArray(env, src, member.type);
+                    obj.Set(member.name, value);
+                }
             } break;
             case PrimitiveKind::Float32: {
                 float f = *(float *)src;
@@ -822,13 +929,9 @@ 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)
+Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type, uint32_t len)
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();
-
-    RG_ASSERT(type->primitive == PrimitiveKind::Array);
-
-    uint32_t len = type->size / type->ref.type->size;
     Size offset = 0;
 
 #define POP_ARRAY(SetCode) \
@@ -1013,6 +1116,14 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
     RG_UNREACHABLE();
 }
 
+Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type)
+{
+    RG_ASSERT(type->primitive == PrimitiveKind::Array);
+
+    uint32_t len = type->size / type->ref.type->size;
+    return DecodeArray(env, origin, type, len);
+}
+
 void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref)
 {
     Napi::Env env = array.Env();

package/src/koffi/src/util.hh

@@ -86,12 +86,13 @@ static inline bool IsRegularSize(Size size, Size max)
     return regular;
 }
 
+int ResolveDirections(Span<const char> str);
 const TypeInfo *ResolveType(Napi::Value value, int *out_directions = nullptr);
-const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_directions = nullptr);
+const TypeInfo *ResolveType(Napi::Env env, Span<const char> str);
 
-const TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count = 1);
-const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len);
-const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint);
+TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count = 1);
+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);
 
@@ -197,6 +198,7 @@ static inline Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *pt
 
 Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *type);
 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);
 Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type);
 void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref);
 void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *ref);