koffi 3.0.1 → 3.0.2

package/src/koffi/src/util.hh

@@ -10,53 +10,6 @@
 
 namespace K {
 
-#if defined(_MSC_VER)
-    #define FORCE_INLINE __forceinline
-#else
-    #define FORCE_INLINE __attribute__((always_inline)) inline
-#endif
-#if defined(UNITY_BUILD)
-    #define INLINE_UNITY FORCE_INLINE
-#else
-    #define INLINE_UNITY
-#endif
-
-#if defined(__GNUC__) || defined(__clang__)
-    #if  __has_attribute(musttail) && __has_attribute(preserve_none)
-        #define MUST_TAIL __attribute__((musttail))
-        #define PRESERVE_NONE __attribute__((preserve_none))
-    #elif  __has_attribute(musttail) && !defined(__clang__)
-        // GCC regalloc seems better, so the generated code is not too bad even without preserve_none
-        #define MUST_TAIL __attribute__((musttail))
-        #define PRESERVE_NONE
-    #endif
-#endif
-
-extern const napi_type_tag LibraryHandleMarker;
-extern const napi_type_tag TypeObjectMarker;
-extern const napi_type_tag DirectionMarker;
-extern const napi_type_tag UnionValueMarker;
-extern const napi_type_tag CastMarker;
-
-#if !defined(EXTERNAL_TYPES)
-
-class TypeObject: public Napi::ObjectWrap<TypeObject> {
-    const TypeInfo *type;
-
-    mutable Napi::Object members;
-
-public:
-    static Napi::Function InitClass(Napi::Env env);
-
-    TypeObject(const Napi::CallbackInfo &info);
-
-    void Finalize(Napi::BasicEnv env) override;
-
-    const TypeInfo *GetType() { return type; }
-};
-
-#endif
-
 class UnionValue: public Napi::ObjectWrap<UnionValue> {
     InstanceData *instance;
     const TypeInfo *type;
@@ -66,7 +19,7 @@ class UnionValue: public Napi::ObjectWrap<UnionValue> {
     HeapArray<uint8_t> raw;
 
 public:
-    static Napi::Function InitClass(Napi::Env env, const TypeInfo *type);
+    static Napi::Function InitClass(InstanceData *instance, const TypeInfo *type);
 
     UnionValue(const Napi::CallbackInfo &info);
 
@@ -93,58 +46,14 @@ void ThrowError(Napi::Env env, const char *msg, Args... args)
     err.ThrowAsJavaScriptException();
 }
 
-static FORCE_INLINE bool IsInteger(const TypeInfo *type)
-{
-    bool integer = ((int)type->primitive >= (int)PrimitiveKind::Int8 &&
-                    (int)type->primitive <= (int)PrimitiveKind::UInt64);
-    return integer;
-}
-
-static FORCE_INLINE bool IsFloat(const TypeInfo *type)
-{
-    bool fp = (type->primitive == PrimitiveKind::Float32 ||
-               type->primitive == PrimitiveKind::Float64);
-    return fp;
-}
-
-static FORCE_INLINE bool IsRegularSize(Size size, Size max)
-{
-    bool regular = (size <= max && !(size & (size - 1)));
-    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);
-
-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::Value WrapType(Napi::Env env, const TypeInfo *type, bool freeze = true);
-
-const TypeInfo *ReshapeType(InstanceData *instance, const TypeInfo *type, int32_t stride, uint16_t flags);
-
-bool CanPassType(const TypeInfo *type, int directions);
-bool CanReturnType(const TypeInfo *type);
-bool CanStoreType(const TypeInfo *type);
-
 static FORCE_INLINE napi_valuetype GetKindOf(napi_env env, napi_value value)
 {
     napi_valuetype kind = napi_undefined;
-    napi_typeof(env, value, &kind);
+    NAPI_OK(napi_typeof(env, value, &kind));
 
     return kind;
 }
 
-static FORCE_INLINE napi_valuetype GetKindOf(Napi::Value value)
-{
-    return GetKindOf(value.Env(), value);
-}
-
-// Can be slow, only use for error messages
-const char *GetValueType(const InstanceData *instance, napi_value value);
-
 void SetValueTag(napi_env env, napi_value value, const void *marker);
 bool CheckValueTag(napi_env env, napi_value value, const void *marker);
 
@@ -203,9 +112,7 @@ static FORCE_INLINE bool IsBuffer(napi_env env, napi_value value)
 static FORCE_INLINE napi_value GetReferenceValue(napi_env env, napi_ref ref)
 {
     napi_value value;
-
-    napi_status status = napi_get_reference_value(env, ref, &value);
-    K_ASSERT(status == napi_ok);
+    NAPI_OK(napi_get_reference_value(env, ref, &value));
 
     return value;
 }
@@ -213,9 +120,7 @@ static FORCE_INLINE napi_value GetReferenceValue(napi_env env, napi_ref ref)
 static FORCE_INLINE uint32_t GetArrayLength(napi_env env, napi_value array)
 {
     uint32_t length = 0;
-
-    napi_status status = napi_get_array_length(env, array, &length);
-    K_ASSERT(status == napi_ok);
+    NAPI_OK(napi_get_array_length(env, array, &length));
 
     return length;
 }
@@ -307,6 +212,62 @@ static FORCE_INLINE bool TryPointer(napi_env env, napi_value value, void **out_p
     return false;
 }
 
+static FORCE_INLINE bool TryPointer(napi_env env, napi_value value, void **out_ptr, Size *out_len)
+{
+    // Fast path for BigInt
+    {
+        uint64_t u64;
+        bool lossless;
+        napi_status status = napi_get_value_bigint_uint64(env, value, &u64, &lossless);
+
+        if (status == napi_ok) {
+            *out_ptr = (void *)(uintptr_t)u64;
+            *out_len = -1;
+
+            return true;
+        }
+    }
+
+    if (size_t len = 0; node_api_get_buffer_info(env, value, out_ptr, &len) == napi_ok) {
+        *out_len = (Size)len;
+        return true;
+    }
+
+    napi_valuetype kind = GetKindOf(env, value);
+
+    if (IsNullOrUndefined(kind)) {
+        *out_ptr = nullptr;
+        *out_len = -1;
+
+        return true;
+    } else if (kind == napi_number) {
+        int64_t i;
+        napi_status status = napi_get_value_int64(env, value, &i);
+        K_ASSERT(status == napi_ok);
+
+        *out_ptr = (void *)(uintptr_t)i;
+        *out_len = -1;
+
+        return true;
+#if defined(EXTERNAL_POINTERS)
+    } else if (kind == napi_external) {
+        Napi::External<void> external = Napi::External<void>(env, value);
+
+        *out_ptr = (void *)external.Data();
+        *out_len = -1;
+
+        return true;
+#endif
+    }
+
+    if (size_t len = 0; napi_get_arraybuffer_info(env, value, out_ptr, &len) == napi_ok) {
+        *out_len = (Size)len;
+        return true;
+    }
+
+    return false;
+}
+
 static FORCE_INLINE bool TryPointer(napi_env env, napi_value value, void **out_ptr, napi_valuetype *out_kind)
 {
     // Fast path for BigInt
@@ -413,11 +374,7 @@ napi_value DecodeArray(InstanceData *instance, const uint8_t *origin, const Type
 void DecodeElements(InstanceData *instance, napi_value array, const uint8_t *origin, const TypeInfo *type, uint32_t len);
 INLINE_UNITY void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *type);
 
-napi_value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len = nullptr);
-napi_value Decode(InstanceData *instance, const uint8_t *ptr, const TypeInfo *type, const Size *len = nullptr);
-
-bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
-bool Encode(InstanceData *instance, uint8_t *ptr, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
+napi_value Decode(InstanceData *instance, const uint8_t *ptr, const TypeInfo *type);
 
 static FORCE_INLINE napi_value NewInt(Napi::Env env, char i) { napi_value value; napi_create_int32(env, (int32_t)i, &value); return value; }
 static FORCE_INLINE napi_value NewInt(Napi::Env env, signed char i) { napi_value value; napi_create_int32(env, (int32_t)i, &value); return value; }
@@ -436,22 +393,24 @@ static FORCE_INLINE napi_value NewInt(Napi::Env env, T i)
 {
     static_assert(sizeof(T) == 8);
 
+    napi_value value;
+
     if constexpr (std::is_signed_v<T>) {
         if (i <= 9007199254740992ll && i >= -9007199254740992ll) {
-            napi_value value;
-            napi_create_int64(env, (int64_t)i, &value);
-            return Napi::Value(env, value);
+            NAPI_OK(napi_create_int64(env, (int64_t)i, &value));
+            return value;
         }
 
-        return Napi::BigInt::New(env, (int64_t)i);
+        NAPI_OK(napi_create_bigint_int64(env, (int64_t)i, &value));
+        return value;
     } else {
         if (i <= 9007199254740992ull) {
-            napi_value value;
-            napi_create_int64(env, (int64_t)i, &value);
-            return Napi::Value(env, value);
+            NAPI_OK(napi_create_int64(env, (int64_t)i, &value));
+            return value;
         }
 
-        return Napi::BigInt::New(env, (uint64_t)i);
+        NAPI_OK(napi_create_bigint_uint64(env, (uint64_t)i, &value));
+        return value;
     }
 }
 
@@ -468,18 +427,20 @@ static FORCE_INLINE Napi::Array GetOwnPropertyNames(napi_env env, napi_value obj
     return Napi::Array(env, result);
 }
 
-Napi::Object DescribeFunction(Napi::Env env, const FunctionInfo *func);
-Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func);
+napi_value DescribeFunction(Napi::Env env, const FunctionInfo *func);
+napi_value WrapFunction(Napi::Env env, const FunctionInfo *func);
 
-static FORCE_INLINE Napi::Value WrapPointer(Napi::Env env, const TypeInfo *ref, void *ptr)
+static FORCE_INLINE napi_value WrapPointer(Napi::Env env, const TypeInfo *ref, void *ptr)
 {
+    napi_value value;
+
 #if defined(EXTERNAL_POINTERS)
-    Napi::External<void> external = Napi::External<void>::New(env, ptr);
-    return external;
+    NAPI_OK(napi_create_external(env, ptr, nullptr, nullptr, &value));
 #else
-    Napi::BigInt big = Napi::BigInt::New(env, (uint64_t)(uintptr_t)ptr);
-    return big;
+    NAPI_OK(napi_create_bigint_uint64(env, (uint64_t)(uintptr_t)ptr, &value));
 #endif
+
+    return value;
 }
 
 bool DetectCallConvention(Span<const char> name, CallConvention *out_convention);

package/src/koffi/src/uv.cc

@@ -1,19 +1,25 @@
 // SPDX-License-Identifier: MIT
 
-#include "uv.hh"
+#include "lib/native/base/base.hh"
+#include "type.hh"
 #include "util.hh"
+#include "uv.hh"
+
+#include <napi.h>
 
 namespace K {
 
-Napi::Function PollHandle::InitClass(Napi::Env env)
+Napi::Function PollHandle::InitClass(InstanceData *instance)
 {
+    Napi::Env env = instance->env;
+
     // node-addon-api wants std::vector
     std::vector<Napi::ClassPropertyDescriptor<PollHandle>> properties = {
-        InstanceMethod("start", &PollHandle::Start),
-        InstanceMethod("stop", &PollHandle::Stop),
-        InstanceMethod("close", &PollHandle::Close),
-        InstanceMethod("unref", &PollHandle::Unref),
-        InstanceMethod("ref", &PollHandle::Ref)
+        InstanceMethod("start", &PollHandle::Start, napi_default, instance),
+        InstanceMethod("stop", &PollHandle::Stop, napi_default, instance),
+        InstanceMethod("close", &PollHandle::Close, napi_default, instance),
+        InstanceMethod("unref", &PollHandle::Unref, napi_default, instance),
+        InstanceMethod("ref", &PollHandle::Ref, napi_default, instance)
     };
 
     if (Napi::Value dispose = env.RunScript("Symbol.dispose"); !IsNullOrUndefined(env, dispose)) {
@@ -21,7 +27,7 @@ Napi::Function PollHandle::InitClass(Napi::Env env)
         properties.push_back(prop);
     }
 
-    Napi::Function constructor = DefineClass(env, "PollHandle", properties);
+    Napi::Function constructor = DefineClass(env, "PollHandle", properties, instance);
     return constructor;
 }
 
@@ -62,7 +68,7 @@ PollHandle::PollHandle(const Napi::CallbackInfo &info)
 
 void PollHandle::Start(const Napi::CallbackInfo &info)
 {
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     bool has_opts = (info.Length() >= 2 && info[0].IsObject());
 
@@ -165,7 +171,7 @@ void PollHandle::OnPoll(uv_poll_t *h, int status, int events)
 Napi::Value Poll(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     bool has_opts = (info.Length() >= 3 && info[1].IsObject());
 

package/src/koffi/src/uv.hh

@@ -3,6 +3,7 @@
 #pragma once
 
 #include "lib/native/base/base.hh"
+#include "ffi.hh"
 
 #include <napi.h>
 
@@ -88,7 +89,7 @@ class PollHandle: public Napi::ObjectWrap<PollHandle> {
     Napi::FunctionReference callback;
 
 public:
-    static Napi::Function InitClass(Napi::Env env);
+    static Napi::Function InitClass(InstanceData *instance);
 
     PollHandle(const Napi::CallbackInfo &info);
 

package/indirect.d.ts

@@ -1,322 +0,0 @@
-// SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: 2026 Niels Martignène <niels.martignene@protonmail.com>
-
-declare module "koffi/indirect" {
-    type PrimitiveKind = 'Void' | 'Bool' | 'Int8' | 'UInt8' | 'Int16' | 'Int16S' | 'UInt16' | 'UInt16S' |
-                         'Int32' | 'Int32S' | 'UInt32' | 'UInt32S' | 'Int64' | 'Int64S' | 'UInt64' | 'UInt64S' |
-                         'String' | 'String16' | 'Pointer' | 'Record' | 'Union' | 'Array' | 'Float32' | 'Float64' |
-                         'Prototype' | 'Callback';
-    type ArrayHint = 'Array' | 'Typed' | 'String';
-
-    type PrototypeInfo = {
-        name: string;
-        arguments: TypeObject[];
-        result: TypeObject
-    };
-
-    interface IKoffiDirectionMarker { __brand: 'IKoffiDirectionMarker' }
-    interface IKoffiPointerCast { __brand: 'IKoffiPointerCast' }
-
-    export type TypeObject = {
-        name: string;
-        primitive: PrimitiveKind;
-        size: number;
-        alignment: number;
-        disposable: boolean;
-        length?: number;
-        hint?: ArrayHint;
-        ref?: TypeObject;
-        members?: Record<string, { name: string, type: TypeObject, offset: number }>;
-        proto?: PrototypeInfo;
-        values?: Record<string, number | bigint>;
-    };
-
-    type TypeSpec = string | TypeObject | IKoffiDirectionMarker;
-    type TypeSpecWithAlignment = TypeSpec | [number, TypeSpec];
-
-    type KoffiFunction = {
-        (...args: any[]) : any;
-        async: (...args: any[]) => any;
-        info: PrototypeInfo;
-    };
-    export type KoffiFunc<T extends (...args: any) => any> = T & {
-       async: (...args: [...Parameters<T>, (err: any, result: ReturnType<T>) => void]) => void;
-       info: PrototypeInfo;
-    };
-
-    type LoadOptions = {
-        lazy?: boolean,
-        global?: boolean,
-        deep?: boolean
-    };
-
-    export type LibraryHandle = {
-        func(definition: string): 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 | number, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
-        /** @deprecated */ stdcall(definition: string): KoffiFunction;
-        /** @deprecated */ stdcall(name: string | number, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
-        /** @deprecated */ fastcall(definition: string): KoffiFunction;
-        /** @deprecated */ fastcall(name: string | number, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
-        /** @deprecated */ thiscall(definition: string): KoffiFunction;
-        /** @deprecated */ thiscall(name: string | number, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
-
-        symbol(name: string, type: TypeSpec): any;
-
-        unload(): void;
-    };
-
-    export function load(path: string | null, options?: LoadOptions): LibraryHandle;
-
-    export function struct(name: string | null | undefined, def: Record<string, TypeSpecWithAlignment>): TypeObject;
-    export function struct(ref: TypeObject, def: Record<string, TypeSpecWithAlignment>): TypeObject;
-    export function struct(def: Record<string, TypeSpecWithAlignment>): TypeObject;
-    export function pack(name: string | null | undefined, def: Record<string, TypeSpecWithAlignment>): TypeObject;
-    export function pack(ref: TypeObject, def: Record<string, TypeSpecWithAlignment>): TypeObject;
-    export function pack(def: Record<string, TypeSpecWithAlignment>): TypeObject;
-
-    export function union(name: string | null | undefined, def: Record<string, TypeSpecWithAlignment>): TypeObject;
-    export function union(ref: TypeObject, def: Record<string, TypeSpecWithAlignment>): TypeObject;
-    export function union(def: Record<string, TypeSpecWithAlignment>): TypeObject;
-
-    export class Union {
-        constructor(type: TypeSpec);
-        [s: string]: any;
-    }
-
-    export function enumeration(name: string | null | undefined, def: Record<string, number | bigint>, storage?: TypeSpec | null) : TypeObject;
-    export function enumeration(def: Record<string, number | bigint>, storage?: TypeSpec | null) : TypeObject;
-
-    export function array(ref: TypeSpec, len: number, hint?: ArrayHint | null): TypeObject;
-    export function array(ref: TypeSpec, countedBy: string, maxLen: number, hint?: ArrayHint | null): TypeObject;
-
-    export function opaque(name: string | null | undefined): TypeObject;
-    export function opaque(): TypeObject;
-
-    export function pointer(ref: TypeSpec): TypeObject;
-    export function pointer(ref: TypeSpec, count: number): TypeObject;
-    export function pointer(name: string | null | undefined, ref: TypeSpec, countedBy?: string | null): TypeObject;
-    export function pointer(name: string | null | undefined, ref: TypeSpec, count: number): TypeObject;
-
-    export function out(type: TypeSpec): IKoffiDirectionMarker;
-    export function inout(type: TypeSpec): IKoffiDirectionMarker;
-
-    export function disposable(type: TypeSpec): TypeObject;
-    export function disposable(type: TypeSpec, freeFunction: Function): TypeObject;
-    export function disposable(name: string | null | undefined, type: TypeSpec): TypeObject;
-    export function disposable(name: string | null | undefined, type: TypeSpec, freeFunction: Function): TypeObject;
-
-    export function proto(definition: string): TypeObject;
-    export function proto(result: TypeSpec, arguments: TypeSpec[]): TypeObject;
-    export function proto(convention: string, result: TypeSpec, arguments: TypeSpec[]): TypeObject;
-    export function proto(name: string | null | undefined, result: TypeSpec, arguments: TypeSpec[]): TypeObject;
-    export function proto(convention: string, name: string | null | undefined, result: TypeSpec, arguments: TypeSpec[]): TypeObject;
-
-    export function register(callback: Function, type: TypeSpec): bigint;
-    /** @deprecated */ export function register(thisValue: any, callback: Function, type: TypeSpec): bigint;
-    export function unregister(callback: bigint): void;
-
-    export function as(value: any, type: TypeSpec): IKoffiPointerCast;
-    export function address(value: any): bigint;
-    export function call(value: any, type: TypeSpec, ...args: any[]): any;
-    export function view(ref: any, len: number): ArrayBuffer;
-
-    export const decode: {
-        (value: any, type: TypeSpec): any;
-        (value: any, type: TypeSpec, len: number): any;
-        (value: any, offset: number, type: TypeSpec): any;
-        (value: any, offset: number, type: TypeSpec, len: number): any;
-
-        char(ptr: any): number;
-        short(ptr: any): number;
-        int(ptr: any): number;
-        long(ptr: any): number | bigint;
-        longlong(ptr: any): number | bigint;
-        uchar(ptr: any): number;
-        ushort(ptr: any): number;
-        uint(ptr: any): number;
-        ulong(ptr: any): number | bigint;
-        ulonglong(ptr: any): number | bigint;
-
-        int8(ptr: any): number;
-        int16(ptr: any): number;
-        int32(ptr: any): number;
-        int64(ptr: any): number | bigint;
-        uint8(ptr: any): number;
-        uint16(ptr: any): number;
-        uint32(ptr: any): number;
-        uint64(ptr: any): number | bigint;
-
-        float(ptr: any): number;
-        double(ptr: any): number;
-
-        string(ptr: any, length?: number | bigint | null): string;
-        string16(ptr: any, length?: number | bigint | null): string;
-        string32(ptr: any, length?: number | bigint | null): string;
-    };
-
-    export function encode(ref: any, type: TypeSpec, value: any): void;
-    export function encode(ref: any, type: TypeSpec, value: any, len: number): void;
-    export function encode(ref: any, offset: number, type: TypeSpec): void;
-    export function encode(ref: any, offset: number, type: TypeSpec, value: any): void;
-    export function encode(ref: any, offset: number, type: TypeSpec, value: any, len: number): void;
-
-    export function type(type: TypeSpec): TypeObject;
-    export function sizeof(type: TypeSpec): number;
-    export function alignof(type: TypeSpec): number;
-    export function offsetof(type: TypeSpec, member_name: string): number;
-    /** @deprecated */ export function resolve(type: TypeSpec): TypeObject;
-    /** @deprecated */ export function introspect(type: TypeSpec): TypeObject;
-
-    export function alias(name: string, type: TypeSpec): TypeObject;
-
-    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;
-
-    export function errno(): number;
-    export function errno(value: number): number;
-
-    export function reset(): void;
-
-    export const internal: boolean;
-    export const extension: string;
-
-    export const os: {
-        errno: Record<string, number>
-    };
-
-    // https://koffi.dev/input#standard-types
-    type PrimitiveTypes =
-        | 'bool'
-        | 'char'
-        | 'char16_t'
-        | 'char16'
-        | 'char32_t'
-        | 'char32'
-        | 'double'
-        | 'float'
-        | 'float32'
-        | 'float64'
-        | 'int'
-        | 'int8_t'
-        | 'int8'
-        | 'int16_be_t'
-        | 'int16_be'
-        | 'int16_le_t'
-        | 'int16_le'
-        | 'int16_t'
-        | 'int16'
-        | 'int32_be_t'
-        | 'int32_be'
-        | 'int32_le_t'
-        | 'int32_le'
-        | 'int32_t'
-        | 'int32'
-        | 'int64_be_t'
-        | 'int64_be'
-        | 'int64_le_t'
-        | 'int64_le'
-        | 'int64_t'
-        | 'int64'
-        | 'intptr_t'
-        | 'intptr'
-        | 'long long'
-        | 'long'
-        | 'longlong'
-        | 'short'
-        | 'size_t'
-        | 'str'
-        | 'str16'
-        | 'str32'
-        | 'string'
-        | 'string16'
-        | 'string32'
-        | 'uchar'
-        | 'uint'
-        | 'uint8_t'
-        | 'uint8'
-        | 'uint16_be_t'
-        | 'uint16_be'
-        | 'uint16_le_t'
-        | 'uint16_le'
-        | 'uint16_t'
-        | 'uint16'
-        | 'uint32_be_t'
-        | 'uint32_be'
-        | 'uint32_le_t'
-        | 'uint32_le'
-        | 'uint32_t'
-        | 'uint32'
-        | 'uint64_be_t'
-        | 'uint64_be'
-        | 'uint64_le_t'
-        | 'uint64_le'
-        | 'uint64_t'
-        | 'uint64'
-        | 'uintptr_t'
-        | 'uintptr'
-        | 'ulong'
-        | 'ulonglong'
-        | 'unsigned char'
-        | 'unsigned int'
-        | 'unsigned long long'
-        | 'unsigned long'
-        | 'unsigned short'
-        | 'ushort'
-        | 'void'
-        | 'wchar'
-        | 'wchar_t';
-    export const types: Record<PrimitiveTypes, TypeObject>;
-
-    export namespace node {
-        export const env: { __brand: 'IKoffiNodeEnv' };
-
-        type PollOptions = {
-            readable?: boolean;
-            writable?: boolean;
-            disconnect?: boolean;
-        };
-
-        type PollEvents = {
-            readable: boolean;
-            writable: boolean;
-            disconnect: boolean;
-        };
-
-        export class PollHandle {
-            start(opts: PollOptions, callback: (ev: PollEvents) => void): void;
-            start(callback: (ev: PollEvents) => void): void;
-            stop(): void;
-
-            close(): void;
-
-            unref(): void;
-            ref(): void;
-        }
-
-        export function poll(fd: number, opts: PollOptions, callback: (ev: PollEvents) => void): PollHandle;
-        export function poll(fd: number, callback: (ev: PollEvents) => void): PollHandle;
-    }
-
-    export const version: string;
-}