koffi 3.0.0-alpha.8 → 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/LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (C) 2025  Niels Martignène <niels.martignene@protonmail.com>
+Copyright (C) 2026  Niels Martignène <niels.martignene@protonmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the “Software”), to deal in

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/{build.cjs → 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;
@@ -196,7 +196,7 @@ function compareVersions(ver1, ver2) {
 
 // ../cnoke/src/assets.js
 var FIND_CNOKE_CMAKE = `# SPDX-License-Identifier: MIT
-# SPDX-FileCopyrightText: 2025 Niels Martign\xE8ne <niels.martignene@protonmail.com>
+# SPDX-FileCopyrightText: 2026 Niels Martign\xE8ne <niels.martignene@protonmail.com>
 
 if(CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo" OR
    CMAKE_BUILD_TYPE STREQUAL "MinSizeRel")
@@ -324,7 +324,7 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "GNU
 endif()
 `;
 var WIN_DELAY_HOOK_C = `// SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: 2025 Niels Martign\xE8ne <niels.martignene@protonmail.com>
+// SPDX-FileCopyrightText: 2026 Niels Martign\xE8ne <niels.martignene@protonmail.com>
 
 #include <stdlib.h>
 #if !defined(NOMINMAX)
@@ -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/callbacks.md

@@ -5,8 +5,8 @@
 In order to pass a JS function to a C function expecting a callback, you must first create a callback type with the expected return type and parameters. The syntax is similar to the one used to load functions from a shared library.
 
 ```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
+import koffi from 'koffi';
+// CJS: const koffi = require('koffi');
 
 // With the classic syntax, this callback expects an integer and returns nothing
 const ExampleCallback = koffi.proto('ExampleCallback', 'void', ['int']);
@@ -71,8 +71,8 @@ int TransferToJS(const char *name, int age, int (*cb)(const char *str, int age))
 ```
 
 ```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
+import koffi from 'koffi';
+// CJS: const koffi = require('koffi');
 
 const lib = koffi.load('./callbacks.so'); // Fake path
 
@@ -121,8 +121,8 @@ void SayIt(const char *name)
 ```
 
 ```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
+import koffi from 'koffi';
+// CJS: const koffi = require('koffi');
 
 const lib = koffi.load('./callbacks.so'); // Fake path
 
@@ -169,8 +169,8 @@ You can pass this value through to another C function that expects a pointer of
 The following examples uses it to sort an array of strings in-place with the standard C function `qsort()`:
 
 ```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
+import koffi from 'koffi';
+// CJS: const koffi = require('koffi');
 
 const lib = koffi.load('libc.so.6');
 

package/doc/functions.md

@@ -3,8 +3,8 @@
 To declare functions, start by loading the shared library with `koffi.load(filename)`.
 
 ```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
+import koffi from 'koffi';
+// CJS: const koffi = require('koffi');
 
 const lib = koffi.load('/path/to/shared/library'); // File extension depends on platforms: .so, .dll, .dylib, etc.
 ```
@@ -105,8 +105,8 @@ You can safely use these on non-x86 platforms, they are simply ignored.
 Below you can find a small example showing how to use a non-default calling convention, with the two syntaxes:
 
 ```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
+import koffi from 'koffi';
+// CJS: const koffi = require('koffi');
 
 const lib = koffi.load('user32.dll');
 
@@ -142,8 +142,8 @@ printf('Integer %d, double %g, str %s', 'int', 6, 'double', 8.5, 'str', 'THE END
 You can issue asynchronous calls by calling the function through its async member. In this case, you need to provide a callback function as the last argument, with `(err, res)` parameters.
 
 ```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
+import koffi from 'koffi';
+// CJS: const koffi = require('koffi');
 
 const lib = koffi.load('libc.so.6');
 

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/doc/input.md

@@ -278,8 +278,8 @@ const char *ConcatBuild(Concat *c)
 ```
 
 ```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
+import koffi from 'koffi';
+// CJS: const koffi = require('koffi');
 
 const lib = koffi.load('./handles.so');
 
@@ -348,8 +348,8 @@ Koffi applies the following conversion rules when passing arrays to/from C:
 See the example below:
 
 ```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
+import koffi from 'koffi';
+// CJS: const koffi = require('koffi');
 
 // Those two structs are exactly the same, only the array conversion hint is different
 const Foo1 = koffi.struct('Foo1', {
@@ -438,8 +438,8 @@ void AppendValues(struct FlexibleArray *arr, size_t count, int start, int step)
 ```
 
 ```js
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
+import koffi from 'koffi';
+// CJS: const koffi = require('koffi');
 
 const lib = koffi.load('./flexible.so');
 

package/doc/misc.md

@@ -151,8 +151,8 @@ The standard POSIX error codes are available in `koffi.os.errno`, as shown below
 ```js
 const assert = require('assert');
 
-// ES6 syntax: import koffi from 'koffi';
-const koffi = require('koffi');
+import koffi from 'koffi';
+// CJS: const koffi = require('koffi');
 
 const lib = koffi.load('libc.so.6');