koffi 2.7.4-beta.1 → 2.7.4

package/CHANGELOG.md

@@ -4,6 +4,13 @@
 
 ### Koffi 2.7
 
+#### Koffi 2.7.4 (2024-02-04)
+
+- Support callbacks happening on main thread but outside JS call (such as during event loop)
+- Improve stability after `koffi.reset()`
+- Expose internal Node/NAPI `env` pointer
+- Name main Koffi API functions
+
 #### Koffi 2.7.3 (2024-01-26)
 
 - Support decoding NULL terminated arrays

package/index.js

@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.7.4-beta.1",
-      stable: "2.7.3",
+      version: "2.7.4",
+      stable: "2.7.4",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",

package/indirect.js

@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.7.4-beta.1",
-      stable: "2.7.3",
+      version: "2.7.4",
+      stable: "2.7.4",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",

package/package.json

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

package/src/cnoke/assets/FindCNoke.cmake

@@ -30,12 +30,16 @@ function(add_node_addon)
     cmake_parse_arguments(ARG "" "NAME" "SOURCES" ${ARGN})
 
     add_library(${ARG_NAME} SHARED ${ARG_SOURCES} ${NODE_JS_SOURCES})
+    target_link_node(${ARG_NAME})
     set_target_properties(${ARG_NAME} PROPERTIES PREFIX "" SUFFIX ".node")
-    target_include_directories(${ARG_NAME} PRIVATE ${NODE_JS_INCLUDE_DIRS})
-    target_link_libraries(${ARG_NAME} PRIVATE ${NODE_JS_LIBRARIES})
-    target_compile_options(${ARG_NAME} PRIVATE ${NODE_JS_COMPILE_FLAGS})
+endfunction()
+
+function(target_link_node TARGET)
+    target_include_directories(${TARGET} PRIVATE ${NODE_JS_INCLUDE_DIRS})
+    target_link_libraries(${TARGET} PRIVATE ${NODE_JS_LIBRARIES})
+    target_compile_options(${TARGET} PRIVATE ${NODE_JS_COMPILE_FLAGS})
     if (NODE_JS_LINK_FLAGS)
-        target_link_options(${ARG_NAME} PRIVATE ${NODE_JS_LINK_FLAGS})
+        target_link_options(${TARGET} PRIVATE ${NODE_JS_LINK_FLAGS})
     endif()
 endfunction()
 

package/src/core/libcc/libcc.hh

@@ -3142,10 +3142,10 @@ static inline void Log(LogLevel level, const char *ctx, const char *fmt, Args...
 #ifdef RG_DEBUG
     const char *DebugLogContext(const char *filename, int line);
 
-    #define LogDebug(...) Log(LogLevel::Debug, DebugLogContext(__FILE__, __LINE__) __VA_OPT__(,) __VA_ARGS__)
-    #define LogInfo(...) Log(LogLevel::Info, nullptr __VA_OPT__(,) __VA_ARGS__)
-    #define LogWarning(...) Log(LogLevel::Warning, DebugLogContext(__FILE__, __LINE__) __VA_OPT__(,) __VA_ARGS__)
-    #define LogError(...) Log(LogLevel::Error, DebugLogContext(__FILE__, __LINE__) __VA_OPT__(,) __VA_ARGS__)
+    #define LogDebug(...) Log(LogLevel::Debug, DebugLogContext(__FILE__, __LINE__),  __VA_ARGS__)
+    #define LogInfo(...) Log(LogLevel::Info, nullptr, __VA_ARGS__)
+    #define LogWarning(...) Log(LogLevel::Warning, DebugLogContext(__FILE__, __LINE__), __VA_ARGS__)
+    #define LogError(...) Log(LogLevel::Error, DebugLogContext(__FILE__, __LINE__), __VA_ARGS__)
 #else
     template <typename... Args>
     static inline void LogDebug(Args...) {}

package/src/koffi/CMakeLists.txt

@@ -21,13 +21,12 @@
 
 cmake_minimum_required(VERSION 3.6)
 cmake_policy(SET CMP0091 NEW)
-
 project(koffi C CXX ASM)
 
-include(CheckCXXCompilerFlag)
-
 find_package(CNoke)
 
+include(CheckCXXCompilerFlag)
+
 set(CMAKE_CXX_STANDARD 20)
 if(MSVC)
     set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)

package/src/koffi/src/ffi.cc

@@ -1997,6 +1997,40 @@ static Napi::Value EncodeValue(const Napi::CallbackInfo &info)
     return env.Undefined();
 }
 
+static Napi::Value ResetKoffi(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (instance->broker) {
+        napi_release_threadsafe_function(instance->broker, napi_tsfn_abort);
+        instance->broker = nullptr;
+    }
+
+    instance->types.RemoveFrom(instance->base_types_len);
+
+    {
+        HashSet<const void *> base_types;
+        HashMap<const char *, const TypeInfo *> new_map;
+
+        for (const TypeInfo &type: instance->types) {
+            base_types.Set(&type);
+        }
+
+        for (const auto &bucket: instance->types_map.table) {
+            if (base_types.Find(bucket.value)) {
+                new_map.Set(bucket.key, bucket.value);
+            }
+        }
+
+        std::swap(instance->types_map, new_map);
+    }
+
+    instance->callbacks.Clear();
+
+    return env.Undefined();
+}
+
 void LibraryHolder::Unload()
 {
 #ifdef _WIN32
@@ -2153,83 +2187,6 @@ static inline PrimitiveKind GetBigEndianPrimitive(PrimitiveKind kind)
 #endif
 }
 
-static Napi::Object InitBaseTypes(Napi::Env env)
-{
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
-    Napi::Object types = Napi::Object::New(env);
-
-    RegisterPrimitiveType(env, types, {"void"}, PrimitiveKind::Void, 0, 0);
-    RegisterPrimitiveType(env, types, {"bool"}, PrimitiveKind::Bool, RG_SIZE(bool), alignof(bool));
-    RegisterPrimitiveType(env, types, {"int8_t", "int8"}, PrimitiveKind::Int8, 1, 1);
-    RegisterPrimitiveType(env, types, {"uint8_t", "uint8"}, PrimitiveKind::UInt8, 1, 1);
-    RegisterPrimitiveType(env, types, {"char"}, PrimitiveKind::Int8, 1, 1);
-    RegisterPrimitiveType(env, types, {"unsigned char", "uchar"}, PrimitiveKind::UInt8, 1, 1);
-    RegisterPrimitiveType(env, types, {"char16_t", "char16"}, PrimitiveKind::Int16, 2, 2);
-    RegisterPrimitiveType(env, types, {"int16_t", "int16"}, PrimitiveKind::Int16, 2, 2);
-    RegisterPrimitiveType(env, types, {"int16_le_t", "int16_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int16), 2, 2);
-    RegisterPrimitiveType(env, types, {"int16_be_t", "int16_be"}, GetBigEndianPrimitive(PrimitiveKind::Int16), 2, 2);
-    RegisterPrimitiveType(env, types, {"uint16_t", "uint16"}, PrimitiveKind::UInt16, 2, 2);
-    RegisterPrimitiveType(env, types, {"uint16_le_t", "uint16_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt16), 2, 2);
-    RegisterPrimitiveType(env, types, {"uint16_be_t", "uint16_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt16), 2, 2);
-    RegisterPrimitiveType(env, types, {"short"}, PrimitiveKind::Int16, 2, 2);
-    RegisterPrimitiveType(env, types, {"unsigned short", "ushort"}, PrimitiveKind::UInt16, 2, 2);
-    RegisterPrimitiveType(env, types, {"int32_t", "int32"}, PrimitiveKind::Int32, 4, 4);
-    RegisterPrimitiveType(env, types, {"int32_le_t", "int32_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int32), 4, 4);
-    RegisterPrimitiveType(env, types, {"int32_be_t", "int32_be"}, GetBigEndianPrimitive(PrimitiveKind::Int32), 4, 4);
-    RegisterPrimitiveType(env, types, {"uint32_t", "uint32"}, PrimitiveKind::UInt32, 4, 4);
-    RegisterPrimitiveType(env, types, {"uint32_le_t", "uint32_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt32), 4, 4);
-    RegisterPrimitiveType(env, types, {"uint32_be_t", "uint32_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt32), 4, 4);
-    RegisterPrimitiveType(env, types, {"int"}, PrimitiveKind::Int32, 4, 4);
-    RegisterPrimitiveType(env, types, {"unsigned int", "uint"}, PrimitiveKind::UInt32, 4, 4);
-    RegisterPrimitiveType(env, types, {"int64_t", "int64"}, PrimitiveKind::Int64, 8, alignof(int64_t));
-    RegisterPrimitiveType(env, types, {"int64_le_t", "int64_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int64), 8, alignof(int64_t));
-    RegisterPrimitiveType(env, types, {"int64_be_t", "int64_be"}, GetBigEndianPrimitive(PrimitiveKind::Int64), 8, alignof(int64_t));
-    RegisterPrimitiveType(env, types, {"uint64_t", "uint64"}, PrimitiveKind::UInt64, 8, alignof(int64_t));
-    RegisterPrimitiveType(env, types, {"uint64_le_t", "uint64_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt64), 8, alignof(int64_t));
-    RegisterPrimitiveType(env, types, {"uint64_be_t", "uint64_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt64), 8, alignof(int64_t));
-    RegisterPrimitiveType(env, types, {"intptr_t", "intptr"}, GetSignPrimitive(RG_SIZE(intptr_t), true), RG_SIZE(intptr_t), alignof(intptr_t));
-    RegisterPrimitiveType(env, types, {"uintptr_t", "uintptr"}, GetSignPrimitive(RG_SIZE(intptr_t), false), RG_SIZE(intptr_t), alignof(intptr_t));
-    RegisterPrimitiveType(env, types, {"size_t"}, GetSignPrimitive(RG_SIZE(size_t), false), RG_SIZE(size_t), alignof(size_t));
-    RegisterPrimitiveType(env, types, {"long"}, GetSignPrimitive(RG_SIZE(long), true), RG_SIZE(long), alignof(long));
-    RegisterPrimitiveType(env, types, {"unsigned long", "ulong"}, GetSignPrimitive(RG_SIZE(long), false), RG_SIZE(long), alignof(long));
-    RegisterPrimitiveType(env, types, {"long long", "longlong"}, PrimitiveKind::Int64, RG_SIZE(int64_t), alignof(int64_t));
-    RegisterPrimitiveType(env, types, {"unsigned long long", "ulonglong"}, PrimitiveKind::UInt64, RG_SIZE(uint64_t), alignof(uint64_t));
-    RegisterPrimitiveType(env, types, {"float", "float32"}, PrimitiveKind::Float32, 4, alignof(float));
-    RegisterPrimitiveType(env, types, {"double", "float64"}, PrimitiveKind::Float64, 8, alignof(double));
-    RegisterPrimitiveType(env, types, {"char *", "str", "string"}, PrimitiveKind::String, RG_SIZE(void *), alignof(void *), "char");
-    RegisterPrimitiveType(env, types, {"char16_t *", "char16 *", "str16", "string16"}, PrimitiveKind::String16, RG_SIZE(void *), alignof(void *), "char16_t");
-
-    instance->void_type = instance->types_map.FindValue("void", nullptr);
-    instance->char_type = instance->types_map.FindValue("char", nullptr);
-    instance->char16_type = instance->types_map.FindValue("char16", nullptr);
-
-    instance->active_symbol = Napi::Symbol::New(env, "active");
-
-    types.Freeze();
-
-    return types;
-}
-
-static Napi::Value ResetKoffi(const Napi::CallbackInfo &info)
-{
-    Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
-    if (instance->broker) {
-        napi_release_threadsafe_function(instance->broker, napi_tsfn_abort);
-        instance->broker = nullptr;
-    }
-
-    instance->types.Clear();
-    instance->types_map.Clear();
-    instance->callbacks.Clear();
-
-    InitBaseTypes(env);
-
-    return env.Undefined();
-}
-
 static InstanceData *CreateInstance()
 {
     InstanceData *instance = new InstanceData();
@@ -2258,52 +2215,52 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
 
     env.SetInstanceData(instance);
 
-    exports.Set("config", Napi::Function::New(env, GetSetConfig));
-    exports.Set("stats", Napi::Function::New(env, GetStats));
-
-    exports.Set("struct", Napi::Function::New(env, CreatePaddedStructType));
-    exports.Set("pack", Napi::Function::New(env, CreatePackedStructType));
-    exports.Set("union", Napi::Function::New(env, CreateUnionType));
-    exports.Set("Union", Napi::Function::New(env, InstantiateUnion));
-    exports.Set("opaque", Napi::Function::New(env, CreateOpaqueType));
-    exports.Set("pointer", Napi::Function::New(env, CreatePointerType));
-    exports.Set("array", Napi::Function::New(env, CreateArrayType));
-    exports.Set("proto", Napi::Function::New(env, CreateFunctionType));
-    exports.Set("alias", Napi::Function::New(env, CreateTypeAlias));
+    exports.Set("config", Napi::Function::New(env, GetSetConfig, "config"));
+    exports.Set("stats", Napi::Function::New(env, GetStats, "stats"));
 
-    exports.Set("sizeof", Napi::Function::New(env, GetTypeSize));
-    exports.Set("alignof", Napi::Function::New(env, GetTypeAlign));
-    exports.Set("offsetof", Napi::Function::New(env, GetMemberOffset));
-    exports.Set("resolve", Napi::Function::New(env, GetResolvedType));
-    exports.Set("introspect", Napi::Function::New(env, GetTypeDefinition));
+    exports.Set("struct", Napi::Function::New(env, CreatePaddedStructType, "struct"));
+    exports.Set("pack", Napi::Function::New(env, CreatePackedStructType, "pack"));
+    exports.Set("union", Napi::Function::New(env, CreateUnionType, "union"));
+    exports.Set("Union", Napi::Function::New(env, InstantiateUnion, "Union"));
+    exports.Set("opaque", Napi::Function::New(env, CreateOpaqueType, "opaque"));
+    exports.Set("pointer", Napi::Function::New(env, CreatePointerType, "pointer"));
+    exports.Set("array", Napi::Function::New(env, CreateArrayType, "array"));
+    exports.Set("proto", Napi::Function::New(env, CreateFunctionType, "proto"));
+    exports.Set("alias", Napi::Function::New(env, CreateTypeAlias, "alias"));
 
-    exports.Set("load", Napi::Function::New(env, LoadSharedLibrary));
+    exports.Set("sizeof", Napi::Function::New(env, GetTypeSize, "sizeof"));
+    exports.Set("alignof", Napi::Function::New(env, GetTypeAlign, "alignof"));
+    exports.Set("offsetof", Napi::Function::New(env, GetMemberOffset, "offsetof"));
+    exports.Set("resolve", Napi::Function::New(env, GetResolvedType, "resolve"));
+    exports.Set("introspect", Napi::Function::New(env, GetTypeDefinition, "introspect"));
 
-    exports.Set("in", Napi::Function::New(env, MarkIn));
-    exports.Set("out", Napi::Function::New(env, MarkOut));
-    exports.Set("inout", Napi::Function::New(env, MarkInOut));
+    exports.Set("load", Napi::Function::New(env, LoadSharedLibrary, "load"));
 
-    exports.Set("disposable", Napi::Function::New(env, CreateDisposableType));
-    exports.Set("free", Napi::Function::New(env, CallFree));
+    exports.Set("in", Napi::Function::New(env, MarkIn, "in"));
+    exports.Set("out", Napi::Function::New(env, MarkOut, "out"));
+    exports.Set("inout", Napi::Function::New(env, MarkInOut, "inout"));
 
-    exports.Set("register", Napi::Function::New(env, RegisterCallback));
-    exports.Set("unregister", Napi::Function::New(env, UnregisterCallback));
+    exports.Set("disposable", Napi::Function::New(env, CreateDisposableType, "disposable"));
+    exports.Set("free", Napi::Function::New(env, CallFree, "free"));
 
-    exports.Set("as", Napi::Function::New(env, CastValue));
-    exports.Set("decode", Napi::Function::New(env, DecodeValue));
-    exports.Set("address", Napi::Function::New(env, GetPointerAddress));
-    exports.Set("call", Napi::Function::New(env, CallPointerSync));
-    exports.Set("encode", Napi::Function::New(env, EncodeValue));
+    exports.Set("register", Napi::Function::New(env, RegisterCallback, "register"));
+    exports.Set("unregister", Napi::Function::New(env, UnregisterCallback, "unregister"));
 
-    exports.Set("reset", Napi::Function::New(env, ResetKoffi));
+    exports.Set("as", Napi::Function::New(env, CastValue, "as"));
+    exports.Set("decode", Napi::Function::New(env, DecodeValue, "decode"));
+    exports.Set("address", Napi::Function::New(env, GetPointerAddress, "address"));
+    exports.Set("call", Napi::Function::New(env, CallPointerSync, "call"));
+    exports.Set("encode", Napi::Function::New(env, EncodeValue, "encode"));
 
-    exports.Set("errno", Napi::Function::New(env, GetOrSetErrNo));
+    exports.Set("reset", Napi::Function::New(env, ResetKoffi, "reset"));
 
-    Napi::Object os = Napi::Object::New(env);
-    exports.Set("os", os);
+    exports.Set("errno", Napi::Function::New(env, GetOrSetErrNo, "errno"));
 
-    // Init constants mapping
+    // Export useful OS info
     {
+        Napi::Object os = Napi::Object::New(env);
+        exports.Set("os", os);
+
         Napi::Object codes = Napi::Object::New(env);
 
         for (const ErrnoCodeInfo &info: ErrnoCodes) {
@@ -2321,8 +2278,71 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     exports.Set("extension", Napi::String::New(env, ".so"));
 #endif
 
-    Napi::Object types = InitBaseTypes(env);
-    exports.Set("types", types);
+    // Init base types
+    {
+        Napi::Object types = Napi::Object::New(env);
+        exports.Set("types", types);
+
+        RegisterPrimitiveType(env, types, {"void"}, PrimitiveKind::Void, 0, 0);
+        RegisterPrimitiveType(env, types, {"bool"}, PrimitiveKind::Bool, RG_SIZE(bool), alignof(bool));
+        RegisterPrimitiveType(env, types, {"int8_t", "int8"}, PrimitiveKind::Int8, 1, 1);
+        RegisterPrimitiveType(env, types, {"uint8_t", "uint8"}, PrimitiveKind::UInt8, 1, 1);
+        RegisterPrimitiveType(env, types, {"char"}, PrimitiveKind::Int8, 1, 1);
+        RegisterPrimitiveType(env, types, {"unsigned char", "uchar"}, PrimitiveKind::UInt8, 1, 1);
+        RegisterPrimitiveType(env, types, {"char16_t", "char16"}, PrimitiveKind::Int16, 2, 2);
+        RegisterPrimitiveType(env, types, {"int16_t", "int16"}, PrimitiveKind::Int16, 2, 2);
+        RegisterPrimitiveType(env, types, {"int16_le_t", "int16_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int16), 2, 2);
+        RegisterPrimitiveType(env, types, {"int16_be_t", "int16_be"}, GetBigEndianPrimitive(PrimitiveKind::Int16), 2, 2);
+        RegisterPrimitiveType(env, types, {"uint16_t", "uint16"}, PrimitiveKind::UInt16, 2, 2);
+        RegisterPrimitiveType(env, types, {"uint16_le_t", "uint16_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt16), 2, 2);
+        RegisterPrimitiveType(env, types, {"uint16_be_t", "uint16_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt16), 2, 2);
+        RegisterPrimitiveType(env, types, {"short"}, PrimitiveKind::Int16, 2, 2);
+        RegisterPrimitiveType(env, types, {"unsigned short", "ushort"}, PrimitiveKind::UInt16, 2, 2);
+        RegisterPrimitiveType(env, types, {"int32_t", "int32"}, PrimitiveKind::Int32, 4, 4);
+        RegisterPrimitiveType(env, types, {"int32_le_t", "int32_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int32), 4, 4);
+        RegisterPrimitiveType(env, types, {"int32_be_t", "int32_be"}, GetBigEndianPrimitive(PrimitiveKind::Int32), 4, 4);
+        RegisterPrimitiveType(env, types, {"uint32_t", "uint32"}, PrimitiveKind::UInt32, 4, 4);
+        RegisterPrimitiveType(env, types, {"uint32_le_t", "uint32_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt32), 4, 4);
+        RegisterPrimitiveType(env, types, {"uint32_be_t", "uint32_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt32), 4, 4);
+        RegisterPrimitiveType(env, types, {"int"}, PrimitiveKind::Int32, 4, 4);
+        RegisterPrimitiveType(env, types, {"unsigned int", "uint"}, PrimitiveKind::UInt32, 4, 4);
+        RegisterPrimitiveType(env, types, {"int64_t", "int64"}, PrimitiveKind::Int64, 8, alignof(int64_t));
+        RegisterPrimitiveType(env, types, {"int64_le_t", "int64_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int64), 8, alignof(int64_t));
+        RegisterPrimitiveType(env, types, {"int64_be_t", "int64_be"}, GetBigEndianPrimitive(PrimitiveKind::Int64), 8, alignof(int64_t));
+        RegisterPrimitiveType(env, types, {"uint64_t", "uint64"}, PrimitiveKind::UInt64, 8, alignof(int64_t));
+        RegisterPrimitiveType(env, types, {"uint64_le_t", "uint64_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt64), 8, alignof(int64_t));
+        RegisterPrimitiveType(env, types, {"uint64_be_t", "uint64_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt64), 8, alignof(int64_t));
+        RegisterPrimitiveType(env, types, {"intptr_t", "intptr"}, GetSignPrimitive(RG_SIZE(intptr_t), true), RG_SIZE(intptr_t), alignof(intptr_t));
+        RegisterPrimitiveType(env, types, {"uintptr_t", "uintptr"}, GetSignPrimitive(RG_SIZE(intptr_t), false), RG_SIZE(intptr_t), alignof(intptr_t));
+        RegisterPrimitiveType(env, types, {"size_t"}, GetSignPrimitive(RG_SIZE(size_t), false), RG_SIZE(size_t), alignof(size_t));
+        RegisterPrimitiveType(env, types, {"long"}, GetSignPrimitive(RG_SIZE(long), true), RG_SIZE(long), alignof(long));
+        RegisterPrimitiveType(env, types, {"unsigned long", "ulong"}, GetSignPrimitive(RG_SIZE(long), false), RG_SIZE(long), alignof(long));
+        RegisterPrimitiveType(env, types, {"long long", "longlong"}, PrimitiveKind::Int64, RG_SIZE(int64_t), alignof(int64_t));
+        RegisterPrimitiveType(env, types, {"unsigned long long", "ulonglong"}, PrimitiveKind::UInt64, RG_SIZE(uint64_t), alignof(uint64_t));
+        RegisterPrimitiveType(env, types, {"float", "float32"}, PrimitiveKind::Float32, 4, alignof(float));
+        RegisterPrimitiveType(env, types, {"double", "float64"}, PrimitiveKind::Float64, 8, alignof(double));
+        RegisterPrimitiveType(env, types, {"char *", "str", "string"}, PrimitiveKind::String, RG_SIZE(void *), alignof(void *), "char");
+        RegisterPrimitiveType(env, types, {"char16_t *", "char16 *", "str16", "string16"}, PrimitiveKind::String16, RG_SIZE(void *), alignof(void *), "char16_t");
+
+        instance->void_type = instance->types_map.FindValue("void", nullptr);
+        instance->char_type = instance->types_map.FindValue("char", nullptr);
+        instance->char16_type = instance->types_map.FindValue("char16", nullptr);
+
+        instance->active_symbol = Napi::Symbol::New(env, "active");
+
+        instance->base_types_len = instance->types.len;
+    }
+
+    // Expose internal Node stuff
+    {
+        Napi::Object node = Napi::Object::New(env);
+        exports.Set("node", node);
+
+        Napi::External<void> external = Napi::External<void>::New(env, (napi_env)env);
+        SetValueTag(instance, external, instance->void_type);
+
+        node.Set("env", external);
+    }
 
     exports.Set("version", Napi::String::New(env, RG_STRINGIFY(VERSION)));
 

package/src/koffi/src/ffi.hh

@@ -269,6 +269,7 @@ struct InstanceData {
     BucketArray<TypeInfo> types;
     HashMap<const char *, const TypeInfo *> types_map;
     BucketArray<FunctionInfo> callbacks;
+    Size base_types_len;
 
     bool debug;
     uint64_t tag_lower;