koffi 3.0.0 → 3.0.1

package/indirect.d.ts

@@ -0,0 +1,322 @@
+// 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;
+}

package/indirect.js

@@ -1 +1,2 @@
-export { default } from "./src/koffi/indirect.js";
+export { default } from "./src/koffi/indirect.js";
+export * from "./src/koffi/indirect.js";

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "koffi",
-    "version": "3.0.0",
-    "description": "Fast and simple C FFI (foreign function interface) for Node.js",
+    "version": "3.0.1",
+    "description": "Fast and easy-to-use dynamic C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",
         "function",
@@ -33,20 +33,20 @@
     },
     "funding": "https://liberapay.com/Koromix",
     "optionalDependencies": {
-        "@koromix/koffi-linux-arm64": "3.0.0",
-        "@koromix/koffi-linux-ia32": "3.0.0",
-        "@koromix/koffi-linux-x64": "3.0.0",
-        "@koromix/koffi-linux-riscv64": "3.0.0",
-        "@koromix/koffi-freebsd-ia32": "3.0.0",
-        "@koromix/koffi-freebsd-x64": "3.0.0",
-        "@koromix/koffi-freebsd-arm64": "3.0.0",
-        "@koromix/koffi-openbsd-ia32": "3.0.0",
-        "@koromix/koffi-openbsd-x64": "3.0.0",
-        "@koromix/koffi-win32-ia32": "3.0.0",
-        "@koromix/koffi-win32-x64": "3.0.0",
-        "@koromix/koffi-darwin-x64": "3.0.0",
-        "@koromix/koffi-darwin-arm64": "3.0.0",
-        "@koromix/koffi-linux-loong64": "3.0.0"
+        "@koromix/koffi-linux-arm64": "3.0.1",
+        "@koromix/koffi-linux-ia32": "3.0.1",
+        "@koromix/koffi-linux-x64": "3.0.1",
+        "@koromix/koffi-linux-riscv64": "3.0.1",
+        "@koromix/koffi-freebsd-ia32": "3.0.1",
+        "@koromix/koffi-freebsd-x64": "3.0.1",
+        "@koromix/koffi-freebsd-arm64": "3.0.1",
+        "@koromix/koffi-openbsd-ia32": "3.0.1",
+        "@koromix/koffi-openbsd-x64": "3.0.1",
+        "@koromix/koffi-win32-ia32": "3.0.1",
+        "@koromix/koffi-win32-x64": "3.0.1",
+        "@koromix/koffi-darwin-x64": "3.0.1",
+        "@koromix/koffi-darwin-arm64": "3.0.1",
+        "@koromix/koffi-linux-loong64": "3.0.1"
     },
     "type": "module",
     "main": "./index.cjs",
@@ -54,11 +54,13 @@
     "exports": {
         ".": {
             "import": "./index.js",
-            "require": "./index.cjs"
+            "require": "./index.cjs",
+            "types": "./index.d.ts"
         },
         "./indirect": {
             "import": "./indirect.js",
-            "require": "./indirect.cjs"
+            "require": "./indirect.cjs",
+            "types": "./indirect.d.ts"
         }
     },
     "types": "./index.d.ts"

package/src/koffi/CMakeLists.txt

@@ -137,6 +137,7 @@ if(WIN32)
 endif()
 
 target_compile_definitions(koffi PRIVATE FELIX_TARGET=koffi NAPI_DISABLE_CPP_EXCEPTIONS NAPI_VERSION=NAPI_VERSION_EXPERIMENTAL)
+
 if(WIN32)
     target_compile_definitions(koffi PRIVATE _CRT_SECURE_NO_WARNINGS _CRT_NONSTDC_NO_DEPRECATE)
     target_link_libraries(koffi PRIVATE ws2_32)
@@ -152,27 +153,33 @@ endif()
 option(PGO_GENERATE "Build with PGO profile generation" "")
 option(PGO_USE "Optimize with PGO profile" "")
 
-if(MSVC AND (CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo"))
-    target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:/GS- /Ob2>)
-
-    if(CMAKE_C_COMPILER_ID MATCHES "[Cc]lang")
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /clang:-O3")
+if(MSVC)
+    if (NOT CMAKE_C_COMPILER_ID MATCHES "[Cc]lang")
+        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:/EHsc>)
     endif()
 
-    if(CMAKE_BUILD_TYPE STREQUAL "Release")
-        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:/Oy->)
+    if(CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
+        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:/GS- /Ob2>)
+
+        if(CMAKE_C_COMPILER_ID MATCHES "[Cc]lang")
+            set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /clang:-O3")
+        endif()
+
+        if(CMAKE_BUILD_TYPE STREQUAL "Release")
+            target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:/Oy->)
+        endif()
     endif()
 endif()
 
 if(NOT MSVC OR CMAKE_C_COMPILER_ID MATCHES "[Cc]lang")
     # Restore C/C++ compiler sanity
 
-    if(NOT MSVC)
-        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-strict-aliasing -fwrapv
-                                                                       -fno-delete-null-pointer-checks>)
+    target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-exceptions -fno-rtti -fno-strict-aliasing
+                                                                   -fno-delete-null-pointer-checks>)
+    if(MSVC)
+        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:/clang:-fwrapv>)
     else()
-        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-strict-aliasing /clang:-fwrapv
-                                                                       -fno-delete-null-pointer-checks>)
+        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fwrapv>)
     endif()
 
     check_cxx_compiler_flag(-fno-finite-loops use_no_finite_loops)

package/src/koffi/index.cjs

@@ -34,7 +34,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 
 // ../cnoke/src/abi.js
 function determineAbi() {
-  let abi = process.arch;
+  let abi = process.arch.toString();
   if (abi == "riscv32" || abi == "riscv64") {
     let buf = readFileHeader(process.execPath, 512);
     let header = decodeElfHeader(buf);
@@ -131,7 +131,7 @@ var init_abi = __esm({
 var package_default;
 var init_package = __esm({
   "package.json"() {
-    package_default = { name: "koffi", version: "3.0.0", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
+    package_default = { name: "koffi", version: "3.0.1", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
   }
 });
 
@@ -145,7 +145,7 @@ __export(init_exports, {
 function detectPlatform() {
   if (process.versions.napi == null || process.versions.napi < package_default.cnoke.napi) {
     let major = parseInt(process.versions.node, 10);
-    throw new Error(`This engine is based on Node ${process.versions.node}, but ${package_default.name} does not support the Node ${major}.x branch (N-API < ${package_default.cnoke.napi})`);
+    throw new Error(`This engine is based on Node ${process.versions.node}, but ${package_default.name} does not support the Node ${major}.x branch (Node-API < ${package_default.cnoke.napi})`);
   }
   let abi = determineAbi();
   let pkg2 = `${process.platform}-${process.arch}`;
@@ -158,9 +158,9 @@ function loadDynamic(root, pkg2, triplets2) {
   let roots = [root];
   let native2 = null;
   let err = null;
-  if (process.resourcesPath != null) {
-    roots.push(process.resourcesPath);
-    roots.push(process.resourcesPath + "/node_modules/koffi");
+  if (process["resourcesPath"] != null) {
+    roots.push(process["resourcesPath"]);
+    roots.push(process["resourcesPath"] + "/node_modules/koffi");
   }
   let names = [
     `${__dirname}/../../../@koromix/koffi-${pkg2}`,
@@ -185,27 +185,26 @@ function loadDynamic(root, pkg2, triplets2) {
 function wrapNative(native2) {
   let load = native2.load;
   let register = native2.register;
-  native2.sizeof = (spec) => native2.type(spec).size;
-  native2.alignof = (spec) => native2.type(spec).alignment;
+  let introspect = native2.introspect ?? native2.type;
+  native2.sizeof = (spec) => introspect(spec).size;
+  native2.alignof = (spec) => introspect(spec).alignment;
   native2.offsetof = (spec, name) => {
-    let type = native2.type(spec);
-    if (type.primitive != "Record")
+    let info = introspect(spec);
+    if (info.primitive != "Record")
       throw new TypeError("The offsetof() function can only be used with record types");
-    let member = type.members[name];
+    let member = info.members[name];
     if (member == null)
-      throw new Error(`Record type ${type.name} does not have member '${name}'`);
+      throw new Error(`Record type ${info.name} does not have member '${name}'`);
     return member.offset;
   };
   native2.register = (...args) => {
     if (args.length >= 3 && typeof args[1] == "function") {
-      process.emitWarning("Using koffi.register() with a custom this value was deprecated in Koffi 3.0, use function.bind() instead", "DeprecationWarning", "KOFFI009");
+      process.emitWarning("Using koffi.register() with a custom this value was deprecated in Koffi 2.17, use function.bind() instead", "DeprecationWarning", "KOFFI009");
       args[1] = args[1].bind(args[0]);
       args = args.slice(1);
     }
     return register(...args);
   };
-  native2.resolve = import_node_util.default.deprecate(native2.type, "The koffi.resolve() function was deprecated in Koffi 3.0, use koffi.type() instead", "KOFFI007");
-  native2.introspect = import_node_util.default.deprecate(native2.type, "The koffi.introspect() function was deprecated in Koffi 3.0, use koffi.type() instead", "KOFFI008");
   native2.load = (...args) => {
     let lib = load(...args);
     lib.cdecl = import_node_util.default.deprecate((...args2) => lib.func("__cdecl", ...args2), "The koffi.cdecl() function was deprecated in Koffi 2.7, use koffi.func(...) instead", "KOFFI003");
@@ -214,6 +213,12 @@ function wrapNative(native2) {
     lib.thiscall = import_node_util.default.deprecate((...args2) => lib.func("__thiscall", ...args2), 'The koffi.thiscall() function was deprecated in Koffi 2.7, use koffi.func("__thiscall", ...) instead', "KOFFI006");
     return lib;
   };
+  if (native2.introspect == null) {
+    native2.resolve = import_node_util.default.deprecate(native2.type, "The koffi.resolve() function was deprecated in Koffi 3.0, use koffi.type() instead", "KOFFI007");
+    native2.introspect = import_node_util.default.deprecate(native2.type, "The koffi.introspect() function was deprecated in Koffi 3.0, use koffi.type() instead", "KOFFI008");
+  } else {
+    native2.resolve = native2.type;
+  }
 }
 var import_node_util, import_node_fs2, import_node_module, requireNative;
 var init_init = __esm({
@@ -325,4 +330,48 @@ if (native == null)
 if (native.version != version)
   throw new Error("Mismatched native Koffi modules");
 wrapNative2(native);
-module.exports = native;
+module.exports = {
+  default: native,
+  "LibraryHandle": native["LibraryHandle"],
+  "TypeObject": native["TypeObject"],
+  "Union": native["Union"],
+  "address": native["address"],
+  "alias": native["alias"],
+  "alignof": native["alignof"],
+  "alloc": native["alloc"],
+  "array": native["array"],
+  "as": native["as"],
+  "call": native["call"],
+  "config": native["config"],
+  "decode": native["decode"],
+  "disposable": native["disposable"],
+  "encode": native["encode"],
+  "enumeration": native["enumeration"],
+  "errno": native["errno"],
+  "extension": native["extension"],
+  "free": native["free"],
+  "in": native["in"],
+  "inout": native["inout"],
+  "introspect": native["introspect"],
+  "load": native["load"],
+  "node": native["node"],
+  "offsetof": native["offsetof"],
+  "opaque": native["opaque"],
+  "os": native["os"],
+  "out": native["out"],
+  "pack": native["pack"],
+  "pointer": native["pointer"],
+  "proto": native["proto"],
+  "register": native["register"],
+  "reset": native["reset"],
+  "resolve": native["resolve"],
+  "sizeof": native["sizeof"],
+  "stats": native["stats"],
+  "struct": native["struct"],
+  "type": native["type"],
+  "types": native["types"],
+  "union": native["union"],
+  "unregister": native["unregister"],
+  "version": native["version"],
+  "view": native["view"]
+};