koffi 2.15.0 → 2.16.0-beta.1

package/src/koffi/src/util.hh

@@ -17,7 +17,7 @@ extern const napi_type_tag MagicUnionMarker;
 class MagicUnion: public Napi::ObjectWrap<MagicUnion> {
     const TypeInfo *type;
 
-    napi_value active_symbol;
+    Napi::Reference<Napi::Symbol> active_symbol;
     Size active_idx = -1;
 
     HeapArray<uint8_t> raw;
@@ -98,63 +98,97 @@ static inline bool IsObject(Napi::Value value)
     return value.IsObject() && !IsNullOrUndefined(value) && !value.IsArray();
 }
 
-static inline bool IsRawBuffer(Napi::Value value)
-{
-    return value.IsTypedArray() || value.IsArrayBuffer();
-}
-
-static inline Span<uint8_t> GetRawBuffer(Napi::Value value)
+template <typename T>
+bool TryNumber(Napi::Value value, T *out_value)
 {
-    if (value.IsTypedArray()) {
-        napi_typedarray_type type = napi_int8_array;
-        size_t length = 0;
-        void *ptr = nullptr;
+    // Assume number first
+    {
+        T v;
+        napi_status status;
+
+        if constexpr (std::is_same_v<T, double>) {
+            status = napi_get_value_double(value.Env(), value, &v);
+        } else if constexpr (std::is_same_v<T, float>) {
+            double d;
+            status = napi_get_value_double(value.Env(), value, &d);
+            v = (float)d;
+        } else {
+            int64_t i64;
+            status = napi_get_value_int64(value.Env(), value, &i64);
+            v = (T)i64;
+        }
 
-        napi_get_typedarray_info(value.Env(), value, &type, &length, &ptr, nullptr, nullptr);
-
-        switch (type) {
-            case napi_int8_array: { length *= 1; } break;
-            case napi_uint8_array: { length *= 1; } break;
-            case napi_uint8_clamped_array: { length *= 1; } break;
-            case napi_int16_array: { length *= 2; } break;
-            case napi_uint16_array: { length *= 2; } break;
-            case napi_int32_array: { length *= 4; } break;
-            case napi_uint32_array: { length *= 4; } break;
-            case napi_float32_array: { length *= 4; } break;
-            case napi_float64_array: { length *= 8; } break;
-            case napi_bigint64_array: { length *= 8; } break;
-            case napi_biguint64_array: { length *= 8; } break;
+        if (status == napi_ok) [[likely]] {
+            *out_value = v;
+            return true;
         }
+    }
+
+    if (value.IsBigInt()) {
+        Napi::BigInt bigint = value.As<Napi::BigInt>();
+
+        bool lossless;
+        *out_value = (T)bigint.Uint64Value(&lossless);
+
+        return true;
+    }
+
+    return false;
+}
 
-        return MakeSpan((uint8_t *)ptr, (Size)length);
+static inline bool TryPointer(Napi::Value value, void **out_ptr)
+{
+    if (IsNullOrUndefined(value)) {
+        *out_ptr = nullptr;
+        return true;
+    } else if (uintptr_t ptr = 0; TryNumber(value, &ptr)) {
+        *out_ptr = (void *)ptr;
+        return true;
+    } else if (value.IsTypedArray()) {
+        napi_get_typedarray_info(value.Env(), value, nullptr, nullptr, out_ptr, nullptr, nullptr);
+        return true;
+    } else if (value.IsExternal()) {
+        Napi::External<void> external = value.As<Napi::External<void>>();
+
+        *out_ptr = (void *)external.Data();
+        return true;
     } else if (value.IsArrayBuffer()) {
         Napi::ArrayBuffer buffer = value.As<Napi::ArrayBuffer>();
 
-        return MakeSpan((uint8_t *)buffer.Data(), (Size)buffer.ByteLength());
+        *out_ptr = (void *)buffer.Data();
+        return true;
     }
 
-    K_UNREACHABLE();
+    return false;
 }
 
-int GetTypedArrayType(const TypeInfo *type);
-
-template <typename T>
-T GetNumber(Napi::Value value)
+static inline bool TryBuffer(Napi::Value value, Span<uint8_t> *out_buffer)
 {
-    K_ASSERT(value.IsNumber() || value.IsBigInt());
+    // Before somewhere around Node 20.12, napi_get_buffer_info() would assert/crash
+    // when used with something it did not support, instead of returning napi_invalid_arg.
+    // So we need to call napi_is_buffer(), at least for now.
 
-    if (value.IsNumber()) [[likely]] {
-        return (T)value.As<Napi::Number>().DoubleValue();
-    } else if (value.IsBigInt()) {
-        Napi::BigInt bigint = value.As<Napi::BigInt>();
+    if (value.IsBuffer()) {
+        void *ptr = nullptr;
+        size_t length = 0;
 
-        bool lossless;
-        return (T)bigint.Uint64Value(&lossless);
+        // Assume it works
+        napi_get_buffer_info(value.Env(), value, &ptr, &length);
+
+        *out_buffer = MakeSpan((uint8_t *)ptr, (Size)length);
+        return true;
+    } else if (value.IsArrayBuffer()) {
+        Napi::ArrayBuffer buffer = value.As<Napi::ArrayBuffer>();
+
+        *out_buffer = MakeSpan((uint8_t *)buffer.Data(), (Size)buffer.ByteLength());
+        return true;
     }
 
-    K_UNREACHABLE();
+    return false;
 }
 
+int GetTypedArrayType(const TypeInfo *type);
+
 template <typename T>
 Size NullTerminatedLength(const T *ptr)
 {
@@ -226,6 +260,9 @@ static inline Napi::Array GetOwnPropertyNames(Napi::Object obj)
 
 Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func);
 
+Napi::Value WrapPointer(Napi::Env env, const TypeInfo *ref, void *ptr);
+Napi::Value WrapCallback(Napi::Env env, const TypeInfo *ref, void *ptr);
+
 bool DetectCallConvention(Span<const char> name, CallConvention *out_convention);
 
 int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func);

package/vendor/node-api-headers/CHANGELOG.md

@@ -1,5 +1,27 @@
 # node-api-headers Changelog
 
+## [1.8.0](https://github.com/nodejs/node-api-headers/compare/v1.7.0...v1.8.0) (2026-01-23)
+
+
+### Features
+
+* update headers from nodejs/node tag v25.4.0 ([#70](https://github.com/nodejs/node-api-headers/issues/70)) ([ebc02e1](https://github.com/nodejs/node-api-headers/commit/ebc02e18357a4d49f127f094c144371948b60c84))
+
+## [1.7.0](https://github.com/nodejs/node-api-headers/compare/v1.6.0...v1.7.0) (2025-11-28)
+
+
+### Features
+
+* update headers from nodejs/node tag v25.1.0 ([#65](https://github.com/nodejs/node-api-headers/issues/65)) ([f90f754](https://github.com/nodejs/node-api-headers/commit/f90f75459375cb4725914895aa418efefdde7af2))
+* update headers from nodejs/node tag v25.2.1 ([#68](https://github.com/nodejs/node-api-headers/issues/68)) ([769031b](https://github.com/nodejs/node-api-headers/commit/769031b208acd820bf3f2c3b2cf9f8b4b2e2bd83))
+
+## [1.6.0](https://github.com/nodejs/node-api-headers/compare/v1.5.0...v1.6.0) (2025-09-26)
+
+
+### Features
+
+* update headers from nodejs/node tag v24.9.0 ([#60](https://github.com/nodejs/node-api-headers/issues/60)) ([5963ef9](https://github.com/nodejs/node-api-headers/commit/5963ef9937c8f6bd8f33cb45c50f70bd9cbc0ffd))
+
 ## [1.5.0](https://github.com/nodejs/node-api-headers/compare/v1.4.0...v1.5.0) (2025-01-09)
 
 

package/vendor/node-api-headers/README.md

@@ -9,10 +9,6 @@
 - **[Team](#team)**
 - **[License](#license)**
 
-## Current Node-API version: 9
-
-(See [CHANGELOG.md](CHANGELOG.md) for complete Changelog)
-
 <a name="introduction"></a>
 
 ## Introduction
@@ -45,8 +41,8 @@ npm i node-api-headers
 
 ## Versions
 
-Node-API C headers are backward-compatible. Its version (e.g. `8`) is released 
-separately from the Node.js version stream (e.g. `19.8.1`) and changes are 
+Node-API C headers are backward-compatible. Its version (e.g. `8`) is released
+separately from the Node.js version stream (e.g. `19.8.1`) and changes are
 backported to active Node.js LTS lines (e.g. `16.x` and `18.x`).
 
 This package publishes semver-minor versions with new Node-API C headers changes.
@@ -57,6 +53,7 @@ JS API breaking changes are published with new semver-major versions.
 ## API
 
 The module exports two properties `include_dir` and `symbols`.
+
 ### `include_dir`
 
 This property is a string that represents the include path for the Node-API
@@ -89,18 +86,10 @@ grouped by version and api types.
 
 ## Team members
 
-### Active
-| Name                | GitHub Link                                           |
-| ------------------- | ----------------------------------------------------- |
-| Anna Henningsen     | [addaleax](https://github.com/addaleax)               |
-| Chengzhong Wu       | [legendecas](https://github.com/legendecas)           |
-| Gabriel Schulhof    | [gabrielschulhof](https://github.com/gabrielschulhof) |
-| Hitesh Kanwathirtha | [digitalinfinity](https://github.com/digitalinfinity) |
-| Jim Schlight        | [jschlight](https://github.com/jschlight)             |
-| Michael Dawson      | [mhdawson](https://github.com/mhdawson)               |
-| Kevin Eady          | [KevinEady](https://github.com/KevinEady)
-| Nicola Del Gobbo    | [NickNaso](https://github.com/NickNaso)               |
+The project is maintained by the [Node-API team members](https://github.com/nodejs/abi-stable-node/?tab=readme-ov-file#project-participants).
 
 <a name="license"></a>
 
+## License
+
 Licensed under [MIT](./LICENSE.md)

package/vendor/node-api-headers/include/js_native_api.h

@@ -5,18 +5,6 @@
 #include <stdbool.h>  // NOLINT(modernize-deprecated-headers)
 #include <stddef.h>   // NOLINT(modernize-deprecated-headers)
 
-// Use INT_MAX, this should only be consumed by the pre-processor anyway.
-#define NAPI_VERSION_EXPERIMENTAL 2147483647
-#ifndef NAPI_VERSION
-// The baseline version for N-API.
-// The NAPI_VERSION controls which version will be used by default when
-// compilling a native addon. If the addon developer specifically wants to use
-// functions available in a new version of N-API that is not yet ported in all
-// LTS versions, they can set NAPI_VERSION knowing that they have specifically
-// depended on that version.
-#define NAPI_VERSION 8
-#endif
-
 #include "js_native_api_types.h"
 
 // If you need __declspec(dllimport), either include <node_api.h> instead, or
@@ -62,6 +50,7 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_get_boolean(napi_env env,
 // Methods to create Primitive types/Objects
 NAPI_EXTERN napi_status NAPI_CDECL napi_create_object(napi_env env,
                                                       napi_value* result);
+
 NAPI_EXTERN napi_status NAPI_CDECL napi_create_array(napi_env env,
                                                      napi_value* result);
 NAPI_EXTERN napi_status NAPI_CDECL
@@ -348,7 +337,7 @@ napi_create_reference(napi_env env,
 
 // Deletes a reference. The referenced value is released, and may
 // be GC'd unless there are other references to it.
-NAPI_EXTERN napi_status NAPI_CDECL napi_delete_reference(napi_env env,
+NAPI_EXTERN napi_status NAPI_CDECL napi_delete_reference(node_api_basic_env env,
                                                          napi_ref ref);
 
 // Increments the reference count, optionally returning the resulting count.
@@ -470,6 +459,7 @@ napi_get_dataview_info(napi_env env,
                        napi_value* arraybuffer,
                        size_t* byte_offset);
 
+
 // version management
 NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(node_api_basic_env env,
                                                     uint32_t* result);

package/vendor/node-api-headers/include/js_native_api_types.h

@@ -1,6 +1,19 @@
 #ifndef SRC_JS_NATIVE_API_TYPES_H_
 #define SRC_JS_NATIVE_API_TYPES_H_
 
+// Use INT_MAX, this should only be consumed by the pre-processor anyway.
+#define NAPI_VERSION_EXPERIMENTAL 2147483647
+#ifndef NAPI_VERSION
+// The baseline version for N-API.
+// The NAPI_VERSION controls which version will be used by default when
+// compilling a native addon. If the addon developer specifically wants to use
+// functions available in a new version of N-API that is not yet ported in all
+// LTS versions, they can set NAPI_VERSION knowing that they have specifically
+// depended on that version.
+#define NAPI_VERSION 8
+#endif
+
+
 // This file needs to be compatible with C compilers.
 // This is a public include file, and these includes have essentially
 // became part of it's API.
@@ -98,6 +111,8 @@ typedef enum {
   napi_float64_array,
   napi_bigint64_array,
   napi_biguint64_array,
+#define NODE_API_HAS_FLOAT16_ARRAY
+  napi_float16_array,
 } napi_typedarray_type;
 
 typedef enum {

package/vendor/node-api-headers/include/node_api.h

@@ -33,10 +33,6 @@ struct uv_loop_s;  // Forward declaration.
 #define NAPI_NO_RETURN
 #endif
 
-typedef napi_value(NAPI_CDECL* napi_addon_register_func)(napi_env env,
-                                                         napi_value exports);
-typedef int32_t(NAPI_CDECL* node_api_addon_get_api_version_func)(void);
-
 // Used by deprecated registration method napi_module_register.
 typedef struct napi_module {
   int nm_version;

package/vendor/node-api-headers/include/node_api_types.h

@@ -3,6 +3,12 @@
 
 #include "js_native_api_types.h"
 
+typedef napi_value(NAPI_CDECL* napi_addon_register_func)(napi_env env,
+                                                         napi_value exports);
+// False positive: https://github.com/cpplint/cpplint/issues/409
+// NOLINTNEXTLINE (readability/casting)
+typedef int32_t(NAPI_CDECL* node_api_addon_get_api_version_func)(void);
+
 typedef struct napi_callback_scope__* napi_callback_scope;
 typedef struct napi_async_context__* napi_async_context;
 typedef struct napi_async_work__* napi_async_work;

package/vendor/node-api-headers/package.json

@@ -54,6 +54,6 @@
     "write-win32-def": "node --no-warnings scripts/write-win32-def.js",
     "test": "node test/parse-utils.js "
   },
-  "version": "1.5.0",
+  "version": "1.8.0",
   "support": true
 }

package/vendor/node-api-headers/scripts/update-headers.js

@@ -71,6 +71,12 @@ function removeExperimentals(stream, destination, verbose = false) {
                 const identifier = matches[2];
                 macroStack.push(identifier);
 
+                if (mode.length && mode[mode.length - 1] === 'ignore') {
+                    debug(`Line ${lineNumber} Continued-Ignored ${identifier}`);
+                    mode.push('ignore');
+                    return;
+                }
+
                 debug(`Line ${lineNumber} Pushed ${identifier}`);
 
                 if (identifier === 'NAPI_EXPERIMENTAL') {