koffi 3.0.0-alpha.9 → 3.0.0-rc.1

package/CHANGELOG.md

@@ -7,19 +7,35 @@
 
 ### Koffi 3.0
 
-#### Koffi 3.0.0 (WIP)
+#### Koffi 3.0.0
 
-**Main changes:**
+*Released on 2026-05-16*
+
+**Highlights:**
+
+- Rewrite call preparation and execution for **vastly improved performance**
+- Distribute prebuilt binaries in **separate subpackages**
+
+**Breaking changes:**
 
 - Replace use of externals with type objects:
   * Use `koffi.type()` to resolve type specifiers (strings or objects) to type objects
-  * Access type information directly on type variables without `koffi.introspect()`
+  * Access type information directly on type objects without `koffi.introspect()`
 - Replace use of externals with BigInt pointers
-- Rewrite call preparation and execution for vastly improved performance
+- Support ESM and CJS module types
 
 **Other changes:**
 
 - Add `koffi.enumeration()` to create [enum types](input#enum-types)
+- Add fast decode functions for integers, floats and strings
+- Use proper types for various objects and handles:
+  * Use *LibraryHandle* objects for loaded libraries
+  * Use *TypeObject* objects for Koffi types
+  * Use *PollHandle* for socket poll handles
+- Add `Symbol.dispose` on library objects and poll handles
+- Prefer types to interfaces in TypeScript declaration file
+- Fix various bugs and small leaks (such as library handles)
+- The ARM32 backend has been temporarily removed
 
 **Newly deprecated functions:**
 
@@ -37,6 +53,12 @@ Consult the [migration guide](migration) for more information.
 
 ### Koffi 2.16
 
+#### Koffi 2.16.2
+
+*Released on 2026-05-06*
+
+- Fix string truncation bugs when passing some kinds of long V8 strings (see [Koromix/koffi#266](https://github.com/Koromix/koffi/issues/266))
+
 #### Koffi 2.16.1
 
 *Released on 2026-04-17*

package/README.md

@@ -13,13 +13,11 @@ ISA / OS           | Windows     | Linux/glibc | Linux/musl  | macOS       | Fre
 ------------------ | ----------- | ----------- | ----------- | ----------- | ----------- | --------
 x86 (IA32) [^1]    | ✅ Yes      | ✅ Yes      | 🟨 Probably | ⬜️ *N/A*    | ✅ Yes      | ✅ Yes
 x86_64 (AMD64)     | ✅ Yes      | ✅ Yes      | ✅ Yes      | ✅ Yes      | ✅ Yes      | ✅ Yes
-ARM32 LE [^2]      | ⬜️ *N/A*    | ✅ Yes      | 🟨 Probably | ⬜️ *N/A*    | 🟨 Probably | 🟨 Probably
 ARM64 (AArch64) LE | ✅ Yes      | ✅ Yes      | ✅ Yes      | ✅ Yes      | ✅ Yes      | 🟨 Probably
 RISC-V 64 [^3]     | ⬜️ *N/A*    | ✅ Yes      | 🟨 Probably | ⬜️ *N/A*    | 🟨 Probably | 🟨 Probably
 LoongArch64        | ⬜️ *N/A*    | ✅ Yes      | 🟨 Probably | ⬜️ *N/A*    | 🟨 Probably | 🟨 Probably
 
 [^1]: The following call conventions are supported: cdecl, stdcall, MS fastcall, thiscall.
-[^2]: The prebuilt binary uses the hard float ABI and expects a VFP coprocessor. Build from source to use Koffi with a different ABI (softfp, soft).
 [^3]: The prebuilt binary uses the LP64D (double-precision float) ABI. The LP64 ABI is supported in theory if you build Koffi from source but this is untested. The LP64F ABI is not supported.
 
 Go to the web site for more information: https://koffi.dev/

package/cnoke.cjs

@@ -23,16 +23,16 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // ../cnoke/cnoke.js
-var import_fs4 = __toESM(require("fs"), 1);
+var import_node_fs4 = __toESM(require("node:fs"), 1);
 
 // ../cnoke/src/builder.js
-var import_fs3 = __toESM(require("fs"), 1);
-var import_os = __toESM(require("os"), 1);
-var import_path = __toESM(require("path"), 1);
-var import_child_process = require("child_process");
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_child_process = require("node:child_process");
 
 // ../cnoke/src/abi.js
-var import_fs = __toESM(require("fs"), 1);
+var import_node_fs = __toESM(require("node:fs"), 1);
 function determineAbi() {
   let abi = process.arch;
   if (abi == "riscv32" || abi == "riscv64") {
@@ -76,13 +76,13 @@ function determineAbi() {
 function readFileHeader(filename, read) {
   let fd = null;
   try {
-    let fd2 = import_fs.default.openSync(filename);
+    let fd2 = import_node_fs.default.openSync(filename);
     let buf = Buffer.allocUnsafe(read);
-    let len = import_fs.default.readSync(fd2, buf);
+    let len = import_node_fs.default.readSync(fd2, buf);
     return buf.subarray(0, len);
   } finally {
     if (fd != null)
-      import_fs.default.closeSync(fd);
+      import_node_fs.default.closeSync(fd);
   }
 }
 function decodeElfHeader(buf) {
@@ -122,7 +122,7 @@ function decodeElfHeader(buf) {
 }
 
 // ../cnoke/src/util.js
-var import_fs2 = __toESM(require("fs"), 1);
+var import_node_fs2 = __toESM(require("node:fs"), 1);
 function pathIsAbsolute(path2) {
   if (process.platform == "win32" && path2.match(/^[a-zA-Z]:/))
     path2 = path2.substr(2);
@@ -138,28 +138,28 @@ function isPathSeparator(c) {
 function syncFiles(src_dir, dest_dir) {
   let keep = /* @__PURE__ */ new Set();
   {
-    let entries = import_fs2.default.readdirSync(src_dir, { withFileTypes: true });
+    let entries = import_node_fs2.default.readdirSync(src_dir, { withFileTypes: true });
     for (let entry of entries) {
       if (!entry.isFile())
         continue;
       keep.add(entry.name);
-      import_fs2.default.copyFileSync(src_dir + `/${entry.name}`, dest_dir + `/${entry.name}`);
+      import_node_fs2.default.copyFileSync(src_dir + `/${entry.name}`, dest_dir + `/${entry.name}`);
     }
   }
   {
-    let entries = import_fs2.default.readdirSync(dest_dir, { withFileTypes: true });
+    let entries = import_node_fs2.default.readdirSync(dest_dir, { withFileTypes: true });
     for (let entry of entries) {
       if (!entry.isFile())
         continue;
       if (keep.has(entry.name))
         continue;
-      import_fs2.default.unlinkSync(dest_dir + `/${entry.name}`);
+      import_node_fs2.default.unlinkSync(dest_dir + `/${entry.name}`);
     }
   }
 }
 function unlinkRecursive(path2) {
   try {
-    import_fs2.default.rmSync(path2, { recursive: true, maxRetries: process.platform == "win32" ? 3 : 0 });
+    import_node_fs2.default.rmSync(path2, { recursive: true, maxRetries: process.platform == "win32" ? 3 : 0 });
   } catch (err) {
     if (err.code !== "ENOENT")
       throw err;
@@ -413,10 +413,10 @@ function Builder(config = {}) {
     checkCompatibility();
     console.log(`>> Node: ${runtime_version}`);
     console.log(`>> Toolchain: ${toolchain ?? "native"}`);
-    import_fs3.default.mkdirSync(build_dir, { recursive: true, mode: 493 });
-    import_fs3.default.mkdirSync(work_dir, { recursive: true, mode: 493 });
-    import_fs3.default.mkdirSync(output_dir, { recursive: true, mode: 493 });
-    retry &= import_fs3.default.existsSync(work_dir + "/CMakeCache.txt");
+    import_node_fs3.default.mkdirSync(build_dir, { recursive: true, mode: 493 });
+    import_node_fs3.default.mkdirSync(work_dir, { recursive: true, mode: 493 });
+    import_node_fs3.default.mkdirSync(output_dir, { recursive: true, mode: 493 });
+    retry &= import_node_fs3.default.existsSync(work_dir + "/CMakeCache.txt");
     args.push(`-DNODE_JS_EXECPATH=${process.execPath}`);
     if (options2.api == null) {
       let downloaded = false;
@@ -427,7 +427,7 @@ function Builder(config = {}) {
       let api_dir = expandPath(options2.api, project_dir);
       args.push(`-DNODE_JS_INCLUDE_DIRS=${api_dir}/include`);
     }
-    import_fs3.default.writeFileSync(work_dir + "/FindCNoke.cmake", FIND_CNOKE_CMAKE);
+    import_node_fs3.default.writeFileSync(work_dir + "/FindCNoke.cmake", FIND_CNOKE_CMAKE);
     args.push(`-DCMAKE_MODULE_PATH=${work_dir}`);
     let win32 = (toolchain ?? host).startsWith("win32_");
     let mingw = process.platform == "win32" && process.env.MSYSTEM != null;
@@ -444,16 +444,16 @@ function Builder(config = {}) {
           args.push(`-DNODE_JS_LINK_DEF=${api_dir}/def/node_api.def`);
         }
       }
-      import_fs3.default.writeFileSync(work_dir + "/win_delay_hook.c", WIN_DELAY_HOOK_C);
+      import_node_fs3.default.writeFileSync(work_dir + "/win_delay_hook.c", WIN_DELAY_HOOK_C);
       args.push(`-DNODE_JS_SOURCES=${work_dir}/win_delay_hook.c`);
     }
     if (process.platform != "win32" || mingw) {
-      if ((0, import_child_process.spawnSync)("ninja", ["--version"]).status === 0) {
+      if ((0, import_node_child_process.spawnSync)("ninja", ["--version"]).status === 0) {
         args.push("-G", "Ninja");
       } else if (process.platform == "win32") {
         args.push("-G", "MinGW Makefiles");
       }
-      if (config.ccache && (0, import_child_process.spawnSync)("ccache", ["--version"]).status === 0) {
+      if (config.ccache && (0, import_node_child_process.spawnSync)("ccache", ["--version"]).status === 0) {
         args.push("-DCMAKE_C_COMPILER_LAUNCHER=ccache");
         args.push("-DCMAKE_CXX_COMPILER_LAUNCHER=ccache");
       }
@@ -475,7 +475,7 @@ function Builder(config = {}) {
       args.push(`-D${define}`);
     args.push("--no-warn-unused-cli");
     console.log(">> Running configuration");
-    let proc = (0, import_child_process.spawnSync)(cmake_bin, args, { cwd: work_dir, stdio: "inherit" });
+    let proc = (0, import_node_child_process.spawnSync)(cmake_bin, args, { cwd: work_dir, stdio: "inherit" });
     if (proc.status !== 0) {
       unlinkRecursive(work_dir);
       if (retry)
@@ -494,10 +494,10 @@ function Builder(config = {}) {
       }
     }
     checkCMake();
-    if (!import_fs3.default.existsSync(work_dir + "/CMakeCache.txt"))
+    if (!import_node_fs3.default.existsSync(work_dir + "/CMakeCache.txt"))
       await self.configure();
     if (process.env.MAKEFLAGS == null)
-      process.env.MAKEFLAGS = "-j" + (import_os.default.cpus().length || 1);
+      process.env.MAKEFLAGS = "-j" + (import_node_os.default.cpus().length || 1);
     let args = [
       "--build",
       work_dir,
@@ -509,14 +509,14 @@ function Builder(config = {}) {
     for (let target of targets)
       args.push("--target", target);
     console.log(">> Running build");
-    let proc = (0, import_child_process.spawnSync)(cmake_bin, args, { stdio: "inherit" });
+    let proc = (0, import_node_child_process.spawnSync)(cmake_bin, args, { stdio: "inherit" });
     if (proc.status !== 0)
       throw new Error("Failed to run build step");
     console.log(">> Copy target files");
     syncFiles(output_dir, build_dir);
   };
   async function checkPrebuild() {
-    let proc = (0, import_child_process.spawnSync)(process.execPath, ["-e", "require(process.argv[1])", package_dir]);
+    let proc = (0, import_node_child_process.spawnSync)(process.execPath, ["-e", "require(process.argv[1])", package_dir]);
     return proc.status === 0;
   }
   this.clean = function() {
@@ -526,9 +526,9 @@ function Builder(config = {}) {
     if (process.platform == "win32")
       dirname = dirname.replace(/\\/g, "/");
     do {
-      if (import_fs3.default.existsSync(dirname + "/" + basename))
+      if (import_node_fs3.default.existsSync(dirname + "/" + basename))
         return dirname;
-      dirname = import_path.default.dirname(dirname);
+      dirname = import_node_path.default.dirname(dirname);
     } while (!dirname.endsWith("/"));
     return null;
   }
@@ -537,7 +537,7 @@ function Builder(config = {}) {
       let cache_dir2 = process.env["LOCALAPPDATA"] || process.env["APPDATA"];
       if (cache_dir2 == null)
         throw new Error("Missing LOCALAPPDATA and APPDATA environment variable");
-      cache_dir2 = import_path.default.join(cache_dir2, "cnoke");
+      cache_dir2 = import_node_path.default.join(cache_dir2, "cnoke");
       return cache_dir2;
     } else {
       let cache_dir2 = process.env["XDG_CACHE_HOME"];
@@ -545,29 +545,29 @@ function Builder(config = {}) {
         let home = process.env["HOME"];
         if (home == null)
           throw new Error("Missing HOME environment variable");
-        cache_dir2 = import_path.default.join(home, ".cache");
+        cache_dir2 = import_node_path.default.join(home, ".cache");
       }
-      cache_dir2 = import_path.default.join(cache_dir2, "cnoke");
+      cache_dir2 = import_node_path.default.join(cache_dir2, "cnoke");
       return cache_dir2;
     }
   }
   function checkCMake() {
     if (cmake_bin != null)
       return;
-    if (!import_fs3.default.existsSync(project_dir + "/CMakeLists.txt"))
+    if (!import_node_fs3.default.existsSync(project_dir + "/CMakeLists.txt"))
       throw new Error("This directory does not appear to have a CMakeLists.txt file");
     {
-      let proc = (0, import_child_process.spawnSync)("cmake", ["--version"]);
+      let proc = (0, import_node_child_process.spawnSync)("cmake", ["--version"]);
       if (proc.status === 0) {
         cmake_bin = "cmake";
       } else {
         if (process.platform == "win32") {
-          let proc2 = (0, import_child_process.spawnSync)("reg", ["query", "HKEY_LOCAL_MACHINE\\SOFTWARE\\Kitware\\CMake", "/v", "InstallDir"]);
+          let proc2 = (0, import_node_child_process.spawnSync)("reg", ["query", "HKEY_LOCAL_MACHINE\\SOFTWARE\\Kitware\\CMake", "/v", "InstallDir"]);
           if (proc2.status === 0) {
             let matches = proc2.stdout.toString("utf-8").match(/InstallDir[ \t]+REG_[A-Z_]+[ \t]+(.*)+/);
             if (matches != null) {
-              let bin = import_path.default.join(matches[1].trim(), "bin\\cmake.exe");
-              if (import_fs3.default.existsSync(bin))
+              let bin = import_node_path.default.join(matches[1].trim(), "bin\\cmake.exe");
+              if (import_node_fs3.default.existsSync(bin))
                 cmake_bin = bin;
             }
           }
@@ -599,7 +599,7 @@ function Builder(config = {}) {
     let cnoke = null;
     if (package_dir != null) {
       try {
-        let json = import_fs3.default.readFileSync(package_dir + "/package.json", { encoding: "utf-8" });
+        let json = import_node_fs3.default.readFileSync(package_dir + "/package.json", { encoding: "utf-8" });
         pkg = JSON.parse(json);
         directory = package_dir;
       } catch (err) {
@@ -610,7 +610,7 @@ function Builder(config = {}) {
     if (cnoke == null)
       cnoke = pkg?.cnoke ?? {};
     options = {
-      name: pkg?.name ?? import_path.default.basename(project_dir),
+      name: pkg?.name ?? import_node_path.default.basename(project_dir),
       version: pkg?.version ?? null,
       directory,
       ...cnoke
@@ -644,8 +644,8 @@ function Builder(config = {}) {
   function expandPath(str, root) {
     let expanded = expandString(str);
     if (!pathIsAbsolute(expanded))
-      expanded = import_path.default.join(root, expanded);
-    expanded = import_path.default.normalize(expanded);
+      expanded = import_node_path.default.join(root, expanded);
+    expanded = import_node_path.default.normalize(expanded);
     return expanded;
   }
 }
@@ -690,11 +690,11 @@ async function main() {
       } else if (arg == "-D" || arg == "--directory") {
         if (value == null)
           throw new Error(`Missing value for ${arg}`);
-        config.project_dir = import_fs4.default.realpathSync(value);
+        config.project_dir = import_node_fs4.default.realpathSync(value);
       } else if (arg == "-P" || arg == "--package") {
         if (value == null)
           throw new Error(`Missing value for ${arg}`);
-        config.package_dir = import_fs4.default.realpathSync(value);
+        config.package_dir = import_node_fs4.default.realpathSync(value);
       } else if (arg == "-O" || arg == "--output") {
         if (value == null)
           throw new Error(`Missing value for ${arg}`);

package/doc/benchmarks.md

@@ -4,12 +4,10 @@ Here is a quick overview of the execution time of Koffi calls on three benchmark
 
 - The first benchmark is based on `rand()` calls
 - The second benchmark is based on `atoi()` calls
-- The third benchmark is based on [Raylib](https://www.raylib.com/)
+- The third benchmark is based on `memset()` calls
 
-<p style="text-align: center;">
-    <a href="{{ ASSET static/perf_linux.png }}" target="_blank"><img src="{{ ASSET static/perf_linux.png }}" alt="Linux x86_64 performance" style="width: 350px;"/></a>
-    <a href="{{ ASSET static/perf_windows.png }}" target="_blank"><img src="{{ ASSET static/perf_windows.png }}" alt="Windows x86_64 performance" style="width: 350px;"/></a>
-</p>
+<div class="benchmark chart" data-platform="linux_x64"></div>
+<div class="benchmark chart" data-platform="win32_x64"></div>
 
 These results are detailed and explained below, and compared to node-ffi/node-ffi-napi.
 
@@ -19,17 +17,9 @@ The results presented below were measured on my x86_64 Linux machine (Intel® Co
 
 ## rand results
 
-This test is based around repeated calls to a simple standard C function `rand`, and has three implementations:
+This test is based around repeated calls to a simple standard C function `rand`, which takes no parameter and returns a 32-bit integer.
 
-- the first one is the reference, it calls rand through an N-API module, and is close to the theoretical limit of a perfect (no overhead) Node.js > C FFI implementation (pre-compiled static glue code)
-- the second one calls rand through Koffi
-- the third one uses the official Node.js FFI implementation, node-ffi-napi
-
-rand          | Iteration time | Relative performance | Overhead
-------------- | -------------- | -------------------- | --------
-napi          | 256 ns         | x1.00                | +0%
-koffi         | 375 ns         | x0.68                | +46%
-node-ffi-napi | 29783 ns       | x0.009               | +11544%
+<div class="benchmark table" data-platform="linux_x64" data-benchmark="rand"></div>
 
 Because rand is a pretty small function, the FFI overhead is clearly visible.
 
@@ -37,27 +27,13 @@ Because rand is a pretty small function, the FFI overhead is clearly visible.
 
 This test is similar to the rand one, but it is based on `atoi`, which takes a string parameter. Javascript (V8) to C string conversion is relatively slow and heavy.
 
-atoi          | Iteration time | Relative performance | Overhead
-------------- | -------------- | -------------------- | --------
-napi          | 371 ns         | x1.00                | +0%
-koffi         | 557 ns         | x0.67                | +50%
-node-ffi-napi | 104340 ns      | x0.004               | +27988%
-
-Because atoi is a pretty small function, the FFI overhead is clearly visible.
-
-## Raylib results
+<div class="benchmark table" data-platform="linux_x64" data-benchmark="atoi"></div>
 
-This benchmark uses the CPU-based image drawing functions in Raylib. The calls are much heavier than in previous benchmarks, thus the FFI overhead is reduced. In this implementation, Koffi is compared to:
+## memset results
 
-- Baseline: Full C++ version of the code (no JS)
-- [node-raylib](https://github.com/RobLoach/node-raylib): This is a native wrapper implemented with N-API
+This test is based around repeated calls to the standard C function `memset`. All implementations pass a Node.js Buffer for the pointer argument.
 
-raylib        | Iteration time | Relative performance | Overhead
-------------- | -------------- | -------------------- | --------
-C++           | 10.8 µs        | x1.14                | -12%
-node-raylib   | 12.3 µs        | x1.00                | +0%
-koffi         | 13.2 µs        | x0.92                | +8%
-node-ffi-napi | 80.3 µs        | x0.15                | +555%
+<div class="benchmark table" data-platform="linux_x64" data-benchmark="memset"></div>
 
 # Windows x86_64
 
@@ -65,47 +41,21 @@ The results presented below were measured on my x86_64 Windows machine (Intel®
 
 ## rand results
 
-This test is based around repeated calls to a simple standard C function `rand`, and has three implementations:
-
-- the first one is the reference, it calls rand through an N-API module, and is close to the theoretical limit of a perfect (no overhead) Node.js > C FFI implementation (pre-compiled static glue code)
-- the second one calls rand through Koffi
-- the third one uses the official Node.js FFI implementation, node-ffi-napi
-
-rand          | Iteration time | Relative performance | Overhead
-------------- | -------------- | -------------------- | --------
-napi          | 859 ns         | x1.00                | (ref)
-koffi         | 1352 ns        | x0.64                | +57%
-node-ffi-napi | 35640 ns       | x0.02                | +4048%
+This test is based around repeated calls to a simple standard C function `rand`, which takes no parameter and returns a 32-bit integer.
 
-Because rand is a pretty small function, the FFI overhead is clearly visible.
+<div class="benchmark table" data-platform="win32_x64" data-benchmark="rand"></div>
 
 ## atoi results
 
 This test is similar to the rand one, but it is based on `atoi`, which takes a string parameter. Javascript (V8) to C string conversion is relatively slow and heavy.
 
-The results below were measured on my x86_64 Windows machine (Intel® Core™ i5-4460):
-
-atoi          | Iteration time | Relative performance | Overhead
-------------- | -------------- | -------------------- | --------
-napi          | 1336 ns        | x1.00                | (ref)
-koffi         | 2440 ns        | x0.55                | +83%
-node-ffi-napi | 136890 ns      | x0.010               | +10144%
-
-Because atoi is a pretty small function, the FFI overhead is clearly visible.
+<div class="benchmark table" data-platform="win32_x64" data-benchmark="atoi"></div>
 
-## Raylib results
+## memset results
 
-This benchmark uses the CPU-based image drawing functions in Raylib. The calls are much heavier than in the atoi benchmark, thus the FFI overhead is reduced. In this implementation, Koffi is compared to:
+This test is based around repeated calls to the standard C function `memset`. All implementations pass a Node.js Buffer for the pointer argument.
 
-- [node-raylib](https://github.com/RobLoach/node-raylib) (baseline): This is a native wrapper implemented with N-API
-- raylib_cc: C++ implementation of the benchmark, without any Javascript
-
-raylib        | Iteration time | Relative performance | Overhead
-------------- | -------------- | -------------------- | --------
-C++           | 18.2 µs        | x1.50                | -33%
-node-raylib   | 27.3 µs        | x1.00                | (ref)
-koffi         | 29.8 µs        | x0.92                | +9%
-node-ffi-napi | 96.3 µs        | x0.28                | +253%
+<div class="benchmark table" data-platform="win32_x64" data-benchmark="memset"></div>
 
 # Running benchmarks
 
@@ -124,3 +74,5 @@ Once everything is built and ready, run:
 ```sh
 node benchmark.js
 ```
+
+<script src="{{ ASSET static/benchmarks.js }}"></script>

package/doc/index.md

@@ -21,18 +21,16 @@ The following combinations of OS and architectures __are officially supported an
 
 ISA / OS           | Windows | Linux/glibc | Linux/musl | macOS | FreeBSD | OpenBSD
 ------------------ | ------- | ----------- | ---------- | ----- | ------- | -------
-x86 (IA32) [^2]    | ✅      | ✅          | 🟨         | ⬜️    | ✅      | ✅
+x86 (IA32) [^1]    | ✅      | ✅          | 🟨         | ⬜️    | ✅      | ✅
 x86_64 (AMD64)     | ✅      | ✅          | ✅         | ✅    | ✅      | ✅
-ARM32 LE [^3]      | ⬜️      | ✅          | 🟨         | ⬜️    | 🟨      | 🟨
 ARM64 (AArch64) LE | ✅      | ✅          | ✅         | ✅    | ✅      | 🟨
-RISC-V 64 [^4]     | ⬜️      | ✅          | 🟨         | ⬜️    | 🟨      | 🟨
+RISC-V 64 [^2]     | ⬜️      | ✅          | 🟨         | ⬜️    | 🟨      | 🟨
 LoongArch64        | ⬜️      | ✅          | 🟨         | ⬜️    | 🟨      | 🟨
 
 <div class="legend">✅ Yes | 🟨 Probably | ⬜️ Not applicable</div>
 
-[^2]: The following call conventions are supported for forward calls: cdecl, stdcall, MS fastcall, thiscall. Only cdecl and stdcall can be used for C to JS callbacks.
-[^3]: The prebuilt binary uses the hard float ABI and expects a VFP coprocessor. Build from source to use Koffi with a different ABI (softfp, soft).
-[^4]: The prebuilt binary uses the LP64D (double-precision float) ABI. The LP64 ABI is supported in theory if you build Koffi from source (untested), the LP64F ABI is not supported.
+[^1]: The following call conventions are supported for forward calls: cdecl, stdcall, MS fastcall, thiscall. Only cdecl and stdcall can be used for C to JS callbacks.
+[^2]: The prebuilt binary uses the LP64D (double-precision float) ABI. The LP64 ABI is supported in theory if you build Koffi from source (untested), the LP64F ABI is not supported.
 
 For all fully supported platforms (green check marks), a prebuilt binary is included in the NPM package which means you can install Koffi without a C++ compiler.
 

package/index.d.ts

@@ -43,8 +43,6 @@ export type KoffiFunc<T extends (...args: any) => any> = T & {
    info: PrototypeInfo;
 };
 
-export type CallbackHandle = {};
-
 type LoadOptions = {
     lazy?: boolean,
     global?: boolean,
@@ -68,6 +66,8 @@ export type LibraryHandle = {
     symbol(name: string, type: TypeSpec): any;
 
     unload(): void;
+
+    [Symbol.dispose](): void;
 };
 
 export function load(path: string | null, options?: LoadOptions): LibraryHandle;
@@ -116,23 +116,54 @@ export function proto(convention: string, result: TypeSpec, arguments: TypeSpec[
 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): CallbackHandle;
-export function register(thisValue: any, callback: Function, type: TypeSpec): CallbackHandle;
-export function unregister(callback: CallbackHandle): void;
+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 decode(value: any, type: TypeSpec): any;
-export function decode(value: any, type: TypeSpec, len: number): any;
-export function decode(value: any, offset: number, type: TypeSpec): any;
-export function decode(value: any, offset: number, type: TypeSpec, len: number): any;
 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 view(ref: any, len: number): ArrayBuffer;
 
 export function type(type: TypeSpec): TypeObject;
 export function sizeof(type: TypeSpec): number;
@@ -261,13 +292,13 @@ export const types: Record<PrimitiveTypes, TypeObject>;
 export namespace node {
     export const env: { __brand: 'IKoffiNodeEnv' };
 
-    export type PollOptions = {
+    type PollOptions = {
         readable?: boolean;
         writable?: boolean;
         disconnect?: boolean;
     };
 
-    export type PollEvents = {
+    type PollEvents = {
         readable: boolean;
         writable: boolean;
         disconnect: boolean;
@@ -277,9 +308,13 @@ export namespace node {
         start(opts: PollOptions, callback: (ev: PollEvents) => void): void;
         start(callback: (ev: PollEvents) => void): void;
         stop(): void;
+
         close(): void;
+
         unref(): void;
         ref(): void;
+
+        [Symbol.dispose](): void;
     }
 
     export function poll(fd: number, opts: PollOptions, callback: (ev: PollEvents) => void): PollHandle;

package/lib/native/base/base.cc

@@ -2075,12 +2075,15 @@ const char *GetEnv(const char *name)
 
 bool GetDebugFlag(const char *name)
 {
-    const char *debug = GetEnv(name);
+    Span<const char> str = TrimStr(GetEnv(name));
 
-    if (debug) {
+    if (str.len) {
         bool ret = false;
-        if (!ParseBool(debug, &ret, K_DEFAULT_PARSE_FLAGS & ~(int)ParseFlag::Log)) {
-            LogError("Environment variable '%1' is not a boolean", name);
+        if (!ParseBool(str, &ret, K_DEFAULT_PARSE_FLAGS & ~(int)ParseFlag::Log)) {
+            LogError("Environment variable '%1=%2' is not a boolean", name, str);
+        }
+        if (ret) {
+            LogWarning("Debug flag '%1' is in effect", name);
         }
         return ret;
     } else {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "3.0.0-alpha.9",
+    "version": "3.0.0-rc.1",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",
@@ -32,6 +32,22 @@
         "napi": 8
     },
     "funding": "https://liberapay.com/Koromix",
+    "optionalDependencies": {
+        "@koromix/koffi-linux-arm64": "3.0.0-rc.1",
+        "@koromix/koffi-linux-ia32": "3.0.0-rc.1",
+        "@koromix/koffi-linux-x64": "3.0.0-rc.1",
+        "@koromix/koffi-linux-riscv64d": "3.0.0-rc.1",
+        "@koromix/koffi-freebsd-ia32": "3.0.0-rc.1",
+        "@koromix/koffi-freebsd-x64": "3.0.0-rc.1",
+        "@koromix/koffi-freebsd-arm64": "3.0.0-rc.1",
+        "@koromix/koffi-openbsd-ia32": "3.0.0-rc.1",
+        "@koromix/koffi-openbsd-x64": "3.0.0-rc.1",
+        "@koromix/koffi-win32-ia32": "3.0.0-rc.1",
+        "@koromix/koffi-win32-x64": "3.0.0-rc.1",
+        "@koromix/koffi-darwin-x64": "3.0.0-rc.1",
+        "@koromix/koffi-darwin-arm64": "3.0.0-rc.1",
+        "@koromix/koffi-linux-loong64": "3.0.0-rc.1"
+    },
     "type": "module",
     "main": "./index.cjs",
     "module": "./index.js",