koffi 3.1.0 → 3.1.1

package/CHANGELOG.md

@@ -7,12 +7,19 @@
 
 ### Koffi 3.1
 
+#### Koffi 3.1.1
+
+*Released on 2026-07-10*
+
+- Restore missing Windows ARM64 build
+- Slightly optimize memory allocation routines
+
 #### Koffi 3.1.0
 
 *Released on 2026-06-29*
 
 - Add endian-sensitive integer decoding functions
-- Drop required but useless type specifier from `lib.symbol()`
+- Drop useless but required type specifier from `lib.symbol()`
 - Add `wstring` type alias for wide strings
 - Add platform-dependent `koffi.decode.wstring()` function
 - Improve performance of various functions and value conversions
@@ -20,7 +27,7 @@
 - Fix static native loading from the koffi ESM entry point ([@yibe](https://codeberg.org/yibe))
 - Fix minor memory and reference leaks on exit
 - Fix length argument types in TypeScript definition
-- Reorganize documentation pages
+- Reorganize documentation
 
 ### Koffi 3.0
 

package/cnoke.cjs

@@ -22,16 +22,16 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../cnoke/cnoke.js
+// src/cnoke/cnoke.js
 var import_node_fs4 = __toESM(require("node:fs"), 1);
 
-// ../cnoke/src/builder.js
+// src/cnoke/src/builder.js
 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
+// src/cnoke/src/abi.js
 var import_node_fs = __toESM(require("node:fs"), 1);
 function determineAbi() {
   let abi = process.arch.toString();
@@ -121,7 +121,7 @@ function decodeElfHeader(buf) {
   return header;
 }
 
-// ../cnoke/src/util.js
+// src/cnoke/src/util.js
 var import_node_fs2 = __toESM(require("node:fs"), 1);
 function pathIsAbsolute(path2) {
   if (process.platform == "win32" && path2.match(/^[a-zA-Z]:/))
@@ -194,7 +194,7 @@ function compareVersions(ver1, ver2) {
   return cmp;
 }
 
-// ../cnoke/src/assets.js
+// src/cnoke/src/assets.js
 var FIND_CNOKE_CMAKE = `# SPDX-License-Identifier: MIT
 # SPDX-FileCopyrightText: 2026 Niels Martign\xE8ne <niels.martignene@protonmail.com>
 
@@ -361,7 +361,7 @@ const PfnDliHook __pfnDliNotifyHook2 = self_exe_hook;
 #endif
 `;
 
-// ../cnoke/src/builder.js
+// src/cnoke/src/builder.js
 var DefaultOptions = {
   mode: "RelWithDebInfo"
 };
@@ -650,7 +650,7 @@ function Builder(config = {}) {
   }
 }
 
-// ../cnoke/cnoke.js
+// src/cnoke/cnoke.js
 var VALID_COMMANDS = ["build", "configure", "clean"];
 main();
 async function main() {

package/doc/callbacks.md

@@ -9,7 +9,7 @@ import koffi from 'koffi';
 // With the classic syntax, this callback expects an integer and returns nothing
 const ExampleCallback = koffi.proto('ExampleCallback', 'void', ['int']);
 
-// With the prototype parser, this callback expects a double and float, and returns the sum as a double
+// With the prototype parser, this callback expects a double and float, and returns a double
 const AddDoubleFloat = koffi.proto('double AddDoubleFloat(double d, float f)');
 ```
 

package/lib/native/base/base.cc

@@ -186,15 +186,12 @@ void *MallocAllocator::Resize(void *ptr, Size old_size, Size new_size)
 {
     if (!new_size) {
         Release(ptr, old_size);
-        ptr = nullptr;
-    } else {
-        void *new_ptr = realloc(ptr, (size_t)new_size);
-        K_CRITICAL(new_ptr || !new_size, "Failed to resize %1 memory block to %2",
-                                          FmtMemSize(old_size), FmtMemSize(new_size));
-
-        ptr = new_ptr;
+        return nullptr;
     }
 
+    ptr = realloc(ptr, (size_t)new_size);
+    K_CRITICAL(ptr || !new_size, "Failed to resize %1 memory block to %2", FmtMemSize(old_size), FmtMemSize(new_size));
+
     return ptr;
 }
 
@@ -216,6 +213,8 @@ Allocator *GetNullAllocator()
 LinkedAllocator& LinkedAllocator::operator=(LinkedAllocator &&other)
 {
     ReleaseAll();
+
+    allocator = other.allocator;
     list = other.list;
     other.list = nullptr;
 
@@ -363,10 +362,13 @@ BlockAllocator& BlockAllocator::operator=(BlockAllocator &&other)
     allocator.operator=(std::move(other.allocator));
 
     block_size = other.block_size;
-    current_bucket = other.current_bucket;
+
+    bucket_ptr = other.bucket_ptr;
+    bucket_end = other.bucket_end;
     last_alloc = other.last_alloc;
 
-    other.current_bucket = nullptr;
+    other.bucket_ptr = nullptr;
+    other.bucket_end = nullptr;
     other.last_alloc = nullptr;
 
     return *this;
@@ -374,19 +376,23 @@ BlockAllocator& BlockAllocator::operator=(BlockAllocator &&other)
 
 void BlockAllocator::Reset()
 {
-    last_alloc = nullptr;
+    if (bucket_ptr) {
+        bucket_ptr = bucket_end - block_size;
 
-    if (current_bucket) {
-        current_bucket->used = 0;
-        allocator.ReleaseAllExcept(current_bucket);
+        // Not true but Resize code assumes that last_alloc is not null when a bucket exists.
+        // I could also let it as-is, but for some reason I find that less clean.
+        last_alloc = bucket_ptr;
+
+        allocator.ReleaseAllExcept(bucket_ptr);
     } else {
-        allocator.ReleaseAll();
+        ReleaseAll();
     }
 }
 
 void BlockAllocator::ReleaseAll()
 {
-    current_bucket = nullptr;
+    bucket_ptr = nullptr;
+    bucket_end = nullptr;
     last_alloc = nullptr;
 
     allocator.ReleaseAll();
@@ -396,88 +402,78 @@ void *BlockAllocator::Allocate(Size size)
 {
     K_ASSERT(size >= 0);
 
-    // Keep alignement requirements
-    Size aligned_size = AlignLen(size, 8);
+    uint8_t *ptr = bucket_ptr;
+
+    // Fast path
+    if (uint8_t *new_ptr = AlignUp(ptr + size, 8); new_ptr <= bucket_end) [[likely]] {
+        bucket_ptr = new_ptr;
 
-    if (AllocateSeparately(aligned_size)) {
-        uint8_t *ptr = (uint8_t *)allocator.Allocate(size);
+        last_alloc = ptr;
         return ptr;
-    } else {
-        if (!current_bucket || (current_bucket->used + aligned_size) > block_size) {
-            current_bucket = (Bucket *)allocator.Allocate(K_SIZE(Bucket) + block_size);
-            current_bucket->used = 0;
-        }
+    }
 
-        uint8_t *ptr = current_bucket->data + current_bucket->used;
-        current_bucket->used += aligned_size;
+    if (size <= block_size) {
+        bucket_ptr = (uint8_t *)allocator.Allocate(block_size);
+        bucket_end = bucket_ptr + block_size;
+
+        ptr = bucket_ptr;
+        bucket_ptr = AlignUp(ptr + size, 8);
 
         last_alloc = ptr;
         return ptr;
     }
+
+    // Fallback for big allocations
+    return allocator.Allocate(size);
 }
 
 void *BlockAllocator::Resize(void *ptr, Size old_size, Size new_size)
 {
     K_ASSERT(old_size >= 0);
     K_ASSERT(new_size >= 0);
+    K_ASSERT(ptr || !old_size);
 
     if (!new_size) {
         Release(ptr, old_size);
-        ptr = nullptr;
-    } else {
-        if (!ptr) {
-            old_size = 0;
-        }
+        return nullptr;
+    }
 
-        Size aligned_old_size = AlignLen(old_size, 8);
-        Size aligned_new_size = AlignLen(new_size, 8);
-        Size aligned_delta = aligned_new_size - aligned_old_size;
+    // Fast path
+    if (uint8_t *new_ptr = AlignUp((uint8_t *)ptr + new_size, 8); ptr == last_alloc && new_ptr <= bucket_end) {
+        K_ASSERT(ptr);
 
-        // Try fast path
-        if (ptr && ptr == last_alloc &&
-                (current_bucket->used + aligned_delta) <= block_size &&
-                !AllocateSeparately(aligned_new_size)) {
-            current_bucket->used += aligned_delta;
-        } else if (AllocateSeparately(aligned_old_size)) {
-            ptr = allocator.Resize(ptr, old_size, new_size);
-        } else {
-            void *new_ptr = Allocate(new_size);
+        bucket_ptr = new_ptr;
+        return ptr;
+    }
 
-            Size copy = std::min(old_size, new_size);
-            MemCpy(new_ptr, ptr, copy);
+    if (old_size <= block_size) {
+        uint8_t *copy_ptr = (uint8_t *)Allocate(new_size);
+        Size copy_len = std::min(old_size, new_size);
 
-            ptr = new_ptr;
-        }
+        MemCpy(copy_ptr, ptr, copy_len);
+
+        return copy_ptr;
     }
 
-    return ptr;
+    // Old allocation fell back to separate allocation, we can resize at will now!
+    return allocator.Resize(ptr, old_size, new_size);
 }
 
 void BlockAllocator::Release(const void *ptr, Size size)
 {
     K_ASSERT(size >= 0);
 
-    if (ptr) {
-        Size aligned_size = AlignLen(size, 8);
-
-        if (ptr == last_alloc) {
-            current_bucket->used -= aligned_size;
-
-            if (!current_bucket->used) {
-                allocator.Release(current_bucket, K_SIZE(Bucket) + block_size);
-                current_bucket = nullptr;
-            }
-
-            last_alloc = nullptr;
-        } else if (AllocateSeparately(aligned_size)) {
-            allocator.Release(ptr, size);
-        }
+    if (ptr == last_alloc) {
+        bucket_ptr = last_alloc;
+    } else if (size > block_size) {
+        allocator.Release(ptr, size);
     }
 }
 
 void BlockAllocator::GiveTo(LinkedAllocator *alloc)
 {
-    current_bucket = nullptr;
+    bucket_ptr = nullptr;
+    bucket_end = nullptr;
     last_alloc = nullptr;
 
     allocator.GiveTo(alloc);
@@ -5689,8 +5685,13 @@ Size ReadCommandOutput(const char *cmd_line, Span<uint8_t> out_output)
     };
 
     int exit_code;
-    if (!ExecuteCommandLine(cmd_line, info, MakeSpan((const uint8_t *)nullptr, 0), write, &exit_code))
+    if (!ExecuteCommandLine(cmd_line, info, MakeSpan((const uint8_t *)nullptr, 0), write, &exit_code)) {
+        if (out_output.len) {
+            Span<const char> output = out_output.As<const char>();
+            LogError("Command '%1' failed: %2", cmd_line, output);
+        }
         return -1;
+    }
     if (exit_code) {
         LogDebug("Command '%1' failed (exit code: %2)", cmd_line, exit_code);
         return -1;
@@ -5706,17 +5707,26 @@ bool ReadCommandOutput(const char *cmd_line, HeapArray<uint8_t> *out_output)
         { "LC_ALL", "C" }
     };
 
+    Size start_len = out_output->len;
+    K_DEFER_N(err_guard) { out_output->RemoveFrom(start_len); };
+
     ExecuteInfo info = {};
     info.env_variables = variables;
 
     int exit_code;
-    if (!ExecuteCommandLine(cmd_line, info, {}, Mebibytes(1), out_output, &exit_code))
+    if (!ExecuteCommandLine(cmd_line, info, {}, Mebibytes(1), out_output, &exit_code)) {
+        if (out_output->len > start_len) {
+            Span<const char> output = out_output->Take(start_len, out_output->len - start_len).As<const char>();
+            LogError("Command '%1' failed: %2", cmd_line, output);
+        }
         return false;
+    }
     if (exit_code) {
         LogDebug("Command '%1' failed (exit code: %2)", cmd_line, exit_code);
         return false;
     }
 
+    err_guard.Disable();
     return true;
 }
 

package/lib/native/base/base.hh

@@ -467,21 +467,30 @@ constexpr T BigEndian(T v) { return ReverseBytes(v); }
 
 static inline Size AlignLen(Size len, Size align)
 {
-    Size aligned = (len + align - 1) / align * align;
+    K_ASSERT(align >= 1 && !((align - 1) & align));
+
+    // Compilers can optimize x / align * align... for unsigned types.
+    // It's pessimized for signed types, to handle len < 0.
+
+    Size aligned = (len + align - 1) & ~(align - 1);
     return aligned;
 }
 
 template <typename T>
 static inline T *AlignUp(T *ptr, Size align)
 {
-    uint8_t *aligned = (uint8_t *)(((uintptr_t)ptr + align - 1) / align * align);
+    K_ASSERT(align >= 1 && !((align - 1) & align));
+
+    uint8_t *aligned = (uint8_t *)(((uintptr_t)ptr + align - 1) & ~(align - 1));
     return (T *)aligned;
 }
 
 template <typename T>
 static inline T *AlignDown(T *ptr, Size align)
 {
-    uint8_t *aligned = (uint8_t *)((uintptr_t)ptr / align * align);
+    K_ASSERT(align >= 1 && !((align - 1) & align));
+
+    uint8_t *aligned = (uint8_t *)((uintptr_t)ptr & ~(align - 1));
     return (T *)aligned;
 }
 
@@ -1157,15 +1166,11 @@ private:
 };
 
 class BlockAllocator final: public Allocator {
-    struct Bucket {
-        Size used;
-        uint8_t data[];
-    };
-
     LinkedAllocator allocator;
     Size block_size;
 
-    Bucket *current_bucket = nullptr;
+    uint8_t *bucket_ptr = nullptr;
+    uint8_t *bucket_end = nullptr;
     uint8_t *last_alloc = nullptr;
 
 public:
@@ -1191,9 +1196,6 @@ public:
 
     void GiveTo(LinkedAllocator *alloc);
     void GiveTo(BlockAllocator *alloc) { GiveTo(&alloc->allocator); }
-
-private:
-    bool AllocateSeparately(Size aligned_size) const { return aligned_size > block_size / 2; }
 };
 
 static inline void *AllocateRaw(Allocator *alloc, Size size)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "3.1.0",
+    "version": "3.1.1",
     "description": "Fast and easy-to-use dynamic C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",
@@ -33,20 +33,21 @@
     },
     "funding": "https://liberapay.com/Koromix",
     "optionalDependencies": {
-        "@koromix/koffi-linux-arm64": "3.1.0",
-        "@koromix/koffi-linux-ia32": "3.1.0",
-        "@koromix/koffi-linux-x64": "3.1.0",
-        "@koromix/koffi-linux-riscv64": "3.1.0",
-        "@koromix/koffi-freebsd-ia32": "3.1.0",
-        "@koromix/koffi-freebsd-x64": "3.1.0",
-        "@koromix/koffi-freebsd-arm64": "3.1.0",
-        "@koromix/koffi-openbsd-ia32": "3.1.0",
-        "@koromix/koffi-openbsd-x64": "3.1.0",
-        "@koromix/koffi-win32-ia32": "3.1.0",
-        "@koromix/koffi-win32-x64": "3.1.0",
-        "@koromix/koffi-darwin-x64": "3.1.0",
-        "@koromix/koffi-darwin-arm64": "3.1.0",
-        "@koromix/koffi-linux-loong64": "3.1.0"
+        "@koromix/koffi-linux-arm64": "3.1.1",
+        "@koromix/koffi-linux-ia32": "3.1.1",
+        "@koromix/koffi-linux-x64": "3.1.1",
+        "@koromix/koffi-linux-riscv64": "3.1.1",
+        "@koromix/koffi-freebsd-ia32": "3.1.1",
+        "@koromix/koffi-freebsd-x64": "3.1.1",
+        "@koromix/koffi-freebsd-arm64": "3.1.1",
+        "@koromix/koffi-openbsd-ia32": "3.1.1",
+        "@koromix/koffi-openbsd-x64": "3.1.1",
+        "@koromix/koffi-win32-ia32": "3.1.1",
+        "@koromix/koffi-win32-x64": "3.1.1",
+        "@koromix/koffi-win32-arm64": "3.1.1",
+        "@koromix/koffi-darwin-x64": "3.1.1",
+        "@koromix/koffi-darwin-arm64": "3.1.1",
+        "@koromix/koffi-linux-loong64": "3.1.1"
     },
     "type": "module",
     "main": "./index.cjs",

package/src/koffi/index.cjs

@@ -34,7 +34,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../cnoke/src/abi.js
+// src/cnoke/src/abi.js
 function determineAbi() {
   let abi = process.arch.toString();
   if (abi == "riscv32" || abi == "riscv64") {
@@ -124,20 +124,20 @@ function decodeElfHeader(buf) {
 }
 var import_node_fs;
 var init_abi = __esm({
-  "../cnoke/src/abi.js"() {
+  "src/cnoke/src/abi.js"() {
     import_node_fs = __toESM(require("node:fs"), 1);
   }
 });
 
-// package.json
+// src/koffi/package.json
 var package_default;
 var init_package = __esm({
-  "package.json"() {
-    package_default = { name: "koffi", version: "3.1.0", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
+  "src/koffi/package.json"() {
+    package_default = { name: "koffi", version: "3.1.1", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
   }
 });
 
-// src/init.js
+// src/koffi/src/init.js
 var init_exports = {};
 __export(init_exports, {
   detectPlatform: () => detectPlatform,
@@ -233,7 +233,7 @@ function wrapNative(native2, version2) {
 }
 var import_node_util, import_node_fs2, import_node_module, require2;
 var init_init = __esm({
-  "src/init.js"() {
+  "src/koffi/src/init.js"() {
     import_node_util = __toESM(require("node:util"));
     import_node_fs2 = __toESM(require("node:fs"));
     import_node_module = require("node:module");
@@ -243,7 +243,7 @@ var init_init = __esm({
   }
 });
 
-// index.cjs
+// src/koffi/index.cjs
 var { detectPlatform: detectPlatform2, loadDynamic: loadDynamic2, wrapNative: wrapNative2 } = (init_init(), __toCommonJS(init_exports));
 var { loadStatic } = require("./src/static.cjs");
 var [version, pkg, triplets] = detectPlatform2();

package/src/koffi/index.js

@@ -1,9 +1,9 @@
-// src/init.js
+// src/koffi/src/init.js
 import util from "node:util";
 import fs2 from "node:fs";
 import { createRequire } from "node:module";
 
-// ../cnoke/src/abi.js
+// src/cnoke/src/abi.js
 import fs from "node:fs";
 function determineAbi() {
   let abi = process.arch.toString();
@@ -93,10 +93,10 @@ function decodeElfHeader(buf) {
   return header;
 }
 
-// package.json
-var package_default = { name: "koffi", version: "3.1.0", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
+// src/koffi/package.json
+var package_default = { name: "koffi", version: "3.1.1", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
 
-// src/init.js
+// src/koffi/src/init.js
 var require2 = createRequire(import.meta.url);
 function detectPlatform() {
   if (process.versions.napi == null || process.versions.napi < package_default.cnoke.napi) {
@@ -186,7 +186,7 @@ function wrapNative(native2, version2) {
   }
 }
 
-// index.js
+// src/koffi/index.js
 import { loadStatic } from "./src/static.js";
 var [version, pkg, triplets] = detectPlatform();
 var native = loadStatic(pkg) ?? loadDynamic(import.meta.dirname, pkg, triplets);

package/src/koffi/indirect.cjs

@@ -34,7 +34,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../cnoke/src/abi.js
+// src/cnoke/src/abi.js
 function determineAbi() {
   let abi = process.arch.toString();
   if (abi == "riscv32" || abi == "riscv64") {
@@ -124,20 +124,20 @@ function decodeElfHeader(buf) {
 }
 var import_node_fs;
 var init_abi = __esm({
-  "../cnoke/src/abi.js"() {
+  "src/cnoke/src/abi.js"() {
     import_node_fs = __toESM(require("node:fs"), 1);
   }
 });
 
-// package.json
+// src/koffi/package.json
 var package_default;
 var init_package = __esm({
-  "package.json"() {
-    package_default = { name: "koffi", version: "3.1.0", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
+  "src/koffi/package.json"() {
+    package_default = { name: "koffi", version: "3.1.1", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
   }
 });
 
-// src/init.js
+// src/koffi/src/init.js
 var init_exports = {};
 __export(init_exports, {
   detectPlatform: () => detectPlatform,
@@ -233,7 +233,7 @@ function wrapNative(native2, version2) {
 }
 var import_node_util, import_node_fs2, import_node_module, require2;
 var init_init = __esm({
-  "src/init.js"() {
+  "src/koffi/src/init.js"() {
     import_node_util = __toESM(require("node:util"));
     import_node_fs2 = __toESM(require("node:fs"));
     import_node_module = require("node:module");
@@ -243,7 +243,7 @@ var init_init = __esm({
   }
 });
 
-// indirect.cjs
+// src/koffi/indirect.cjs
 var { detectPlatform: detectPlatform2, loadDynamic: loadDynamic2, wrapNative: wrapNative2 } = (init_init(), __toCommonJS(init_exports));
 var [version, pkg, triplets] = detectPlatform2();
 var native = loadDynamic2(__dirname, pkg, triplets);

package/src/koffi/indirect.js

@@ -1,9 +1,9 @@
-// src/init.js
+// src/koffi/src/init.js
 import util from "node:util";
 import fs2 from "node:fs";
 import { createRequire } from "node:module";
 
-// ../cnoke/src/abi.js
+// src/cnoke/src/abi.js
 import fs from "node:fs";
 function determineAbi() {
   let abi = process.arch.toString();
@@ -93,10 +93,10 @@ function decodeElfHeader(buf) {
   return header;
 }
 
-// package.json
-var package_default = { name: "koffi", version: "3.1.0", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
+// src/koffi/package.json
+var package_default = { name: "koffi", version: "3.1.1", cnoke: { api: "../../vendor/node-api-headers", output: "../../bin/Koffi/{{ toolchain }}", node: 16, napi: 8 } };
 
-// src/init.js
+// src/koffi/src/init.js
 var require2 = createRequire(import.meta.url);
 function detectPlatform() {
   if (process.versions.napi == null || process.versions.napi < package_default.cnoke.napi) {
@@ -186,7 +186,7 @@ function wrapNative(native2, version2) {
   }
 }
 
-// indirect.js
+// src/koffi/indirect.js
 var [version, pkg, triplets] = detectPlatform();
 var native = loadDynamic(import.meta.dirname, pkg, triplets);
 wrapNative(native, version);

package/src/koffi/src/static.cjs

@@ -92,6 +92,14 @@ function loadStatic(pkg) {
         }
     }
 
+    if (pkg == 'win32-arm64') {
+        try {
+            native = require('@koromix/koffi-win32-arm64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
     if (pkg == 'darwin-x64') {
         try {
             native = require('@koromix/koffi-darwin-x64');

package/src/koffi/src/static.js

@@ -95,6 +95,14 @@ function loadStatic(pkg) {
         }
     }
 
+    if (pkg == 'win32-arm64') {
+        try {
+            native = require('@koromix/koffi-win32-arm64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
     if (pkg == 'darwin-x64') {
         try {
             native = require('@koromix/koffi-darwin-x64');