koffi 2.12.1 → 2.12.2

package/vendor/node-addon-api/test/require_basic_finalizers/tpl/binding.gyp

@@ -0,0 +1,48 @@
+{
+  'target_defaults': {
+    'include_dirs': [
+        "<!(node -p \"require('node-addon-api').include_dir\")"
+    ],
+    'variables': {
+      'NAPI_VERSION%': "<!(node -p \"process.env.NAPI_VERSION || process.versions.napi\")",
+      'require_basic_finalizers': "<!(node -p \"process.env['npm_config_require_basic_finalizers']\")",
+    },
+    'conditions': [
+      ['NAPI_VERSION!=""', { 'defines': ['NAPI_VERSION=<@(NAPI_VERSION)'] } ],
+      ['NAPI_VERSION==2147483647', { 'defines': ['NAPI_EXPERIMENTAL'] } ],
+      ['require_basic_finalizers=="true"', {
+        'defines': ['NODE_ADDON_API_REQUIRE_BASIC_FINALIZERS'],
+      }],
+      ['OS=="mac"', {
+        'cflags+': ['-fvisibility=hidden'],
+        'xcode_settings': {
+          'OTHER_CFLAGS': ['-fvisibility=hidden']
+        }
+      }]
+    ],
+    'sources': [
+      'addon.cc',
+    ],
+  },
+  'targets': [
+    {
+      'target_name': 'addon',
+      'defines': [
+        'NAPI_CPP_EXCEPTIONS'
+      ],
+      'cflags!': [ '-fno-exceptions' ],
+      'cflags_cc!': [ '-fno-exceptions' ],
+      'msvs_settings': {
+        'VCCLCompilerTool': {
+          'ExceptionHandling': 1,
+          'EnablePREfast': 'true',
+        },
+      },
+      'xcode_settings': {
+        'CLANG_CXX_LIBRARY': 'libc++',
+        'MACOSX_DEPLOYMENT_TARGET': '10.7',
+        'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+      },
+    }
+  ]
+}

package/vendor/node-addon-api/test/require_basic_finalizers/tpl/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('bindings')('addon');

package/vendor/node-addon-api/test/require_basic_finalizers/tpl/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "addon",
+  "version": "0.0.0",
+  "description": "Node.js addon",
+  "private": true,
+  "scripts": {},
+  "dependencies": {
+    "node-addon-api": "file:../../../../"
+  },
+  "gypfile": true
+}

package/vendor/node-addon-api/test/run_script.cc

@@ -18,7 +18,7 @@ Value RunStdString(const CallbackInfo& info) {
 
 Value RunJsString(const CallbackInfo& info) {
   Env env = info.Env();
-  return MaybeUnwrapOr(env.RunScript(info[0].As<String>()), Value());
+  return MaybeUnwrapOr(env.RunScript(info[0].UnsafeAs<String>()), Value());
 }
 
 Value RunWithContext(const CallbackInfo& info) {

package/vendor/node-addon-api/test/type_taggable.cc

@@ -26,7 +26,7 @@ class TestTypeTaggable {
 
   static Value CheckTypeTag(const CallbackInfo& info) {
     uint32_t type_index = info[0].As<Number>().Int32Value();
-    TypeTaggable instance = info[1].As<NodeApiClass>();
+    TypeTaggable instance = info[1].UnsafeAs<NodeApiClass>();
 
     return Boolean::New(info.Env(),
                         instance.CheckTypeTag(&type_tags[type_index]));

package/vendor/node-addon-api/test/type_taggable.js

@@ -53,8 +53,7 @@ function testTypeTaggable ({ typeTaggedInstance, checkTypeTag }) {
   assert.strictEqual(checkTypeTag(4, obj3), false);
 }
 
-// eslint-disable-next-line camelcase
-function test ({ type_taggable }) {
-  testTypeTaggable(type_taggable.external);
-  testTypeTaggable(type_taggable.object);
+function test (binding) {
+  testTypeTaggable(binding.type_taggable.external);
+  testTypeTaggable(binding.type_taggable.object);
 }

package/vendor/node-addon-api/test/typedarray.cc

@@ -21,7 +21,7 @@ namespace {
 Value CreateTypedArray(const CallbackInfo& info) {
   std::string arrayType = info[0].As<String>();
   size_t length = info[1].As<Number>().Uint32Value();
-  ArrayBuffer buffer = info[2].As<ArrayBuffer>();
+  Value buffer = info[2];
   size_t bufferOffset =
       info[3].IsUndefined() ? 0 : info[3].As<Number>().Uint32Value();
 
@@ -32,7 +32,7 @@ Value CreateTypedArray(const CallbackInfo& info) {
                : NAPI_TYPEDARRAY_NEW_BUFFER(Int8Array,
                                             info.Env(),
                                             length,
-                                            buffer,
+                                            buffer.As<ArrayBuffer>(),
                                             bufferOffset,
                                             napi_int8_array);
   } else if (arrayType == "uint8") {
@@ -42,7 +42,7 @@ Value CreateTypedArray(const CallbackInfo& info) {
                : NAPI_TYPEDARRAY_NEW_BUFFER(Uint8Array,
                                             info.Env(),
                                             length,
-                                            buffer,
+                                            buffer.As<ArrayBuffer>(),
                                             bufferOffset,
                                             napi_uint8_array);
   } else if (arrayType == "uint8_clamped") {
@@ -50,7 +50,7 @@ Value CreateTypedArray(const CallbackInfo& info) {
                ? Uint8Array::New(info.Env(), length, napi_uint8_clamped_array)
                : Uint8Array::New(info.Env(),
                                  length,
-                                 buffer,
+                                 buffer.As<ArrayBuffer>(),
                                  bufferOffset,
                                  napi_uint8_clamped_array);
   } else if (arrayType == "int16") {
@@ -60,7 +60,7 @@ Value CreateTypedArray(const CallbackInfo& info) {
                : NAPI_TYPEDARRAY_NEW_BUFFER(Int16Array,
                                             info.Env(),
                                             length,
-                                            buffer,
+                                            buffer.As<ArrayBuffer>(),
                                             bufferOffset,
                                             napi_int16_array);
   } else if (arrayType == "uint16") {
@@ -70,7 +70,7 @@ Value CreateTypedArray(const CallbackInfo& info) {
                : NAPI_TYPEDARRAY_NEW_BUFFER(Uint16Array,
                                             info.Env(),
                                             length,
-                                            buffer,
+                                            buffer.As<ArrayBuffer>(),
                                             bufferOffset,
                                             napi_uint16_array);
   } else if (arrayType == "int32") {
@@ -80,7 +80,7 @@ Value CreateTypedArray(const CallbackInfo& info) {
                : NAPI_TYPEDARRAY_NEW_BUFFER(Int32Array,
                                             info.Env(),
                                             length,
-                                            buffer,
+                                            buffer.As<ArrayBuffer>(),
                                             bufferOffset,
                                             napi_int32_array);
   } else if (arrayType == "uint32") {
@@ -90,7 +90,7 @@ Value CreateTypedArray(const CallbackInfo& info) {
                : NAPI_TYPEDARRAY_NEW_BUFFER(Uint32Array,
                                             info.Env(),
                                             length,
-                                            buffer,
+                                            buffer.As<ArrayBuffer>(),
                                             bufferOffset,
                                             napi_uint32_array);
   } else if (arrayType == "float32") {
@@ -100,7 +100,7 @@ Value CreateTypedArray(const CallbackInfo& info) {
                : NAPI_TYPEDARRAY_NEW_BUFFER(Float32Array,
                                             info.Env(),
                                             length,
-                                            buffer,
+                                            buffer.As<ArrayBuffer>(),
                                             bufferOffset,
                                             napi_float32_array);
   } else if (arrayType == "float64") {
@@ -110,7 +110,7 @@ Value CreateTypedArray(const CallbackInfo& info) {
                : NAPI_TYPEDARRAY_NEW_BUFFER(Float64Array,
                                             info.Env(),
                                             length,
-                                            buffer,
+                                            buffer.As<ArrayBuffer>(),
                                             bufferOffset,
                                             napi_float64_array);
 #if (NAPI_VERSION > 5)
@@ -121,7 +121,7 @@ Value CreateTypedArray(const CallbackInfo& info) {
                : NAPI_TYPEDARRAY_NEW_BUFFER(BigInt64Array,
                                             info.Env(),
                                             length,
-                                            buffer,
+                                            buffer.As<ArrayBuffer>(),
                                             bufferOffset,
                                             napi_bigint64_array);
   } else if (arrayType == "biguint64") {
@@ -131,7 +131,7 @@ Value CreateTypedArray(const CallbackInfo& info) {
                : NAPI_TYPEDARRAY_NEW_BUFFER(BigUint64Array,
                                             info.Env(),
                                             length,
-                                            buffer,
+                                            buffer.As<ArrayBuffer>(),
                                             bufferOffset,
                                             napi_biguint64_array);
 #endif
@@ -208,8 +208,8 @@ Value CheckBufferContent(const CallbackInfo& info) {
     case napi_uint8_array:
       return Boolean::New(
           info.Env(),
-          TypedArrayDataIsEquivalent<int8_t>(info[0].As<Int8Array>(),
-                                             info[1].As<Int8Array>()));
+          TypedArrayDataIsEquivalent<uint8_t>(info[0].As<Uint8Array>(),
+                                              info[1].As<Uint8Array>()));
 
     case napi_uint8_clamped_array:
       return Boolean::New(
@@ -335,35 +335,39 @@ Value GetTypedArrayElement(const CallbackInfo& info) {
 void SetTypedArrayElement(const CallbackInfo& info) {
   TypedArray array = info[0].As<TypedArray>();
   size_t index = info[1].As<Number>().Uint32Value();
-  Number value = info[2].As<Number>();
+  Value value = info[2];
   switch (array.TypedArrayType()) {
     case napi_int8_array:
-      array.As<Int8Array>()[index] = static_cast<int8_t>(value.Int32Value());
+      array.As<Int8Array>()[index] =
+          static_cast<int8_t>(value.As<Number>().Int32Value());
       break;
     case napi_uint8_array:
-      array.As<Uint8Array>()[index] = static_cast<uint8_t>(value.Uint32Value());
+      array.As<Uint8Array>()[index] =
+          static_cast<uint8_t>(value.As<Number>().Uint32Value());
       break;
     case napi_uint8_clamped_array:
-      array.As<Uint8Array>()[index] = static_cast<uint8_t>(value.Uint32Value());
+      array.As<Uint8Array>()[index] =
+          static_cast<uint8_t>(value.As<Number>().Uint32Value());
       break;
     case napi_int16_array:
-      array.As<Int16Array>()[index] = static_cast<int16_t>(value.Int32Value());
+      array.As<Int16Array>()[index] =
+          static_cast<int16_t>(value.As<Number>().Int32Value());
       break;
     case napi_uint16_array:
       array.As<Uint16Array>()[index] =
-          static_cast<uint16_t>(value.Uint32Value());
+          static_cast<uint16_t>(value.As<Number>().Uint32Value());
       break;
     case napi_int32_array:
-      array.As<Int32Array>()[index] = value.Int32Value();
+      array.As<Int32Array>()[index] = value.As<Number>().Int32Value();
       break;
     case napi_uint32_array:
-      array.As<Uint32Array>()[index] = value.Uint32Value();
+      array.As<Uint32Array>()[index] = value.As<Number>().Uint32Value();
       break;
     case napi_float32_array:
-      array.As<Float32Array>()[index] = value.FloatValue();
+      array.As<Float32Array>()[index] = value.As<Number>().FloatValue();
       break;
     case napi_float64_array:
-      array.As<Float64Array>()[index] = value.DoubleValue();
+      array.As<Float64Array>()[index] = value.As<Number>().DoubleValue();
       break;
 #if (NAPI_VERSION > 5)
     case napi_bigint64_array: {

package/vendor/node-addon-api/tools/conversion.js

@@ -12,7 +12,7 @@ if (!dir) {
   process.exit(1);
 }
 
-const NodeApiVersion = require('../package.json').version;
+const NodeApiVersion = require('../').version;
 
 const disable = args[1];
 let ConfigFileOperations;

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

@@ -1,5 +1,34 @@
 # node-api-headers Changelog
 
+## [1.5.0](https://github.com/nodejs/node-api-headers/compare/v1.4.0...v1.5.0) (2025-01-09)
+
+
+### Features
+
+* update headers from nodejs/node tag v23.6.0 ([#57](https://github.com/nodejs/node-api-headers/issues/57)) ([64747b1](https://github.com/nodejs/node-api-headers/commit/64747b17a73e8356ed606d1b4dccb626804777f2))
+
+## [1.4.0](https://github.com/nodejs/node-api-headers/compare/v1.3.0...v1.4.0) (2024-10-30)
+
+
+### Features
+
+* **no-release:** add conditional support in `#if` ([#52](https://github.com/nodejs/node-api-headers/issues/52)) ([e1b8feb](https://github.com/nodejs/node-api-headers/commit/e1b8feb060cf85522538ec1b8a1d6eb782620022))
+* update headers from nodejs/node tag v23.1.0 ([#56](https://github.com/nodejs/node-api-headers/issues/56)) ([3336912](https://github.com/nodejs/node-api-headers/commit/33369124c7f8a670422a0c5a27ad149da83ed8d6))
+
+## [1.3.0](https://github.com/nodejs/node-api-headers/compare/v1.2.0...v1.3.0) (2024-09-04)
+
+
+### Features
+
+* update headers from nodejs/node tag v22.7.0 ([#48](https://github.com/nodejs/node-api-headers/issues/48)) ([6c73c34](https://github.com/nodejs/node-api-headers/commit/6c73c34b72e836531530f863eac315bd42e4569e))
+
+## [1.2.0](https://github.com/nodejs/node-api-headers/compare/node-api-headers-v1.1.0...node-api-headers-v1.2.0) (2024-07-09)
+
+
+### Features
+
+* update headers from nodejs/node tag v22.1.0 ([d5cfe19](https://github.com/nodejs/node-api-headers/commit/d5cfe19da8b974ca35764dd1c73b91d57cd3c4ce))
+
 ## 2023-08-05 Version 1.1.0, @NickNaso
 
 ### Notable changes

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

@@ -5,7 +5,17 @@ want to be able to do releases ask one of the existing collaborators to add
 you. If necessary you can ask the build Working Group who manages the Node.js
 npm user to add you if there are no other active collaborators.
 
-## Prerequisites
+Generally, the release is handled by the
+[release-please](https://github.com/nodejs/node-api-headers/blob/main/.github/workflows/release-please.yml)
+GitHub action. It will bump the version in `package.json` and publish
+node-api-headers to npm.
+
+In cases that the release-please action is not working, please follow the steps
+below to publish node-api-headers manually.
+
+## Publish new release manually
+
+### Prerequisites
 
 Before to start creating a new release check if you have installed the following
 tools:
@@ -15,7 +25,7 @@ tools:
 If not please follow the instruction reported in the tool's documentation to
 install it.
 
-## Publish new release
+### Steps
 
 These are the steps to follow to create a new release:
 

package/vendor/node-api-headers/def/js_native_api.def

@@ -117,4 +117,9 @@ napi_object_seal
 napi_type_tag_object
 node_api_create_syntax_error
 node_api_symbol_for
-node_api_throw_syntax_error
+node_api_throw_syntax_error
+node_api_create_external_string_latin1
+node_api_create_external_string_utf16
+node_api_create_property_key_latin1
+node_api_create_property_key_utf16
+node_api_create_property_key_utf8

package/vendor/node-api-headers/def/node_api.def

@@ -148,4 +148,10 @@ napi_type_tag_object
 node_api_get_module_file_name
 node_api_create_syntax_error
 node_api_symbol_for
-node_api_throw_syntax_error
+node_api_throw_syntax_error
+node_api_create_buffer_from_arraybuffer
+node_api_create_external_string_latin1
+node_api_create_external_string_utf16
+node_api_create_property_key_latin1
+node_api_create_property_key_utf16
+node_api_create_property_key_utf8

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

@@ -24,7 +24,7 @@
 #ifndef NAPI_EXTERN
 #ifdef _WIN32
 #define NAPI_EXTERN __declspec(dllexport)
-#elif defined(__wasm32__)
+#elif defined(__wasm__)
 #define NAPI_EXTERN                                                            \
   __attribute__((visibility("default")))                                       \
   __attribute__((__import_module__("napi")))
@@ -45,8 +45,8 @@
 
 EXTERN_C_START
 
-NAPI_EXTERN napi_status NAPI_CDECL
-napi_get_last_error_info(napi_env env, const napi_extended_error_info** result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_last_error_info(
+    node_api_basic_env env, const napi_extended_error_info** result);
 
 // Getters for defined singletons
 NAPI_EXTERN napi_status NAPI_CDECL napi_get_undefined(napi_env env,
@@ -88,6 +88,32 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_utf16(napi_env env,
                                                             const char16_t* str,
                                                             size_t length,
                                                             napi_value* result);
+#if NAPI_VERSION >= 10
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_external_string_latin1(
+    napi_env env,
+    char* str,
+    size_t length,
+    node_api_basic_finalize finalize_callback,
+    void* finalize_hint,
+    napi_value* result,
+    bool* copied);
+NAPI_EXTERN napi_status NAPI_CDECL
+node_api_create_external_string_utf16(napi_env env,
+                                      char16_t* str,
+                                      size_t length,
+                                      node_api_basic_finalize finalize_callback,
+                                      void* finalize_hint,
+                                      napi_value* result,
+                                      bool* copied);
+
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_latin1(
+    napi_env env, const char* str, size_t length, napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_utf8(
+    napi_env env, const char* str, size_t length, napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_utf16(
+    napi_env env, const char16_t* str, size_t length, napi_value* result);
+#endif  // NAPI_VERSION >= 10
+
 NAPI_EXTERN napi_status NAPI_CDECL napi_create_symbol(napi_env env,
                                                       napi_value description,
                                                       napi_value* result);
@@ -267,7 +293,7 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_instanceof(napi_env env,
 
 // Gets all callback info in a single call. (Ugly, but faster.)
 NAPI_EXTERN napi_status NAPI_CDECL napi_get_cb_info(
-    napi_env env,               // [in] NAPI environment handle
+    napi_env env,               // [in] Node-API environment handle
     napi_callback_info cbinfo,  // [in] Opaque callback-info handle
     size_t* argc,      // [in-out] Specifies the size of the provided argv array
                        // and receives the actual count of args.
@@ -288,12 +314,13 @@ napi_define_class(napi_env env,
                   napi_value* result);
 
 // Methods to work with external data objects
-NAPI_EXTERN napi_status NAPI_CDECL napi_wrap(napi_env env,
-                                             napi_value js_object,
-                                             void* native_object,
-                                             napi_finalize finalize_cb,
-                                             void* finalize_hint,
-                                             napi_ref* result);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_wrap(napi_env env,
+          napi_value js_object,
+          void* native_object,
+          node_api_basic_finalize finalize_cb,
+          void* finalize_hint,
+          napi_ref* result);
 NAPI_EXTERN napi_status NAPI_CDECL napi_unwrap(napi_env env,
                                                napi_value js_object,
                                                void** result);
@@ -303,7 +330,7 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_remove_wrap(napi_env env,
 NAPI_EXTERN napi_status NAPI_CDECL
 napi_create_external(napi_env env,
                      void* data,
-                     napi_finalize finalize_cb,
+                     node_api_basic_finalize finalize_cb,
                      void* finalize_hint,
                      napi_value* result);
 NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_external(napi_env env,
@@ -402,7 +429,7 @@ NAPI_EXTERN napi_status NAPI_CDECL
 napi_create_external_arraybuffer(napi_env env,
                                  void* external_data,
                                  size_t byte_length,
-                                 napi_finalize finalize_cb,
+                                 node_api_basic_finalize finalize_cb,
                                  void* finalize_hint,
                                  napi_value* result);
 #endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
@@ -444,7 +471,7 @@ napi_get_dataview_info(napi_env env,
                        size_t* byte_offset);
 
 // version management
-NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(napi_env env,
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(node_api_basic_env env,
                                                     uint32_t* result);
 
 // Promises
@@ -468,7 +495,7 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_run_script(napi_env env,
 
 // Memory management
 NAPI_EXTERN napi_status NAPI_CDECL napi_adjust_external_memory(
-    napi_env env, int64_t change_in_bytes, int64_t* adjusted_value);
+    node_api_basic_env env, int64_t change_in_bytes, int64_t* adjusted_value);
 
 #if NAPI_VERSION >= 5
 
@@ -486,15 +513,17 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_get_date_value(napi_env env,
                                                        double* result);
 
 // Add finalizer for pointer
-NAPI_EXTERN napi_status NAPI_CDECL napi_add_finalizer(napi_env env,
-                                                      napi_value js_object,
-                                                      void* finalize_data,
-                                                      napi_finalize finalize_cb,
-                                                      void* finalize_hint,
-                                                      napi_ref* result);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_add_finalizer(napi_env env,
+                   napi_value js_object,
+                   void* finalize_data,
+                   node_api_basic_finalize finalize_cb,
+                   void* finalize_hint,
+                   napi_ref* result);
 
 #endif  // NAPI_VERSION >= 5
 
+
 #if NAPI_VERSION >= 6
 
 // BigInt
@@ -532,11 +561,14 @@ napi_get_all_property_names(napi_env env,
                             napi_value* result);
 
 // Instance data
-NAPI_EXTERN napi_status NAPI_CDECL napi_set_instance_data(
-    napi_env env, void* data, napi_finalize finalize_cb, void* finalize_hint);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_set_instance_data(node_api_basic_env env,
+                       void* data,
+                       napi_finalize finalize_cb,
+                       void* finalize_hint);
 
-NAPI_EXTERN napi_status NAPI_CDECL napi_get_instance_data(napi_env env,
-                                                          void** data);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_get_instance_data(node_api_basic_env env, void** data);
 #endif  // NAPI_VERSION >= 6
 
 #if NAPI_VERSION >= 7

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

@@ -22,6 +22,30 @@ typedef uint16_t char16_t;
 // JSVM API types are all opaque pointers for ABI stability
 // typedef undefined structs instead of void* for compile time type safety
 typedef struct napi_env__* napi_env;
+
+// We need to mark APIs which can be called during garbage collection (GC),
+// meaning that they do not affect the state of the JS engine, and can
+// therefore be called synchronously from a finalizer that itself runs
+// synchronously during GC. Such APIs can receive either a `napi_env` or a
+// `node_api_basic_env` as their first parameter, because we should be able to
+// also call them during normal, non-garbage-collecting operations, whereas
+// APIs that affect the state of the JS engine can only receive a `napi_env` as
+// their first parameter, because we must not call them during GC. In lieu of
+// inheritance, we use the properties of the const qualifier to accomplish
+// this, because both a const and a non-const value can be passed to an API
+// expecting a const value, but only a non-const value can be passed to an API
+// expecting a non-const value.
+//
+// In conjunction with appropriate CFLAGS to warn us if we're passing a const
+// (basic) environment into an API that expects a non-const environment, and
+// the definition of basic finalizer function pointer types below, which
+// receive a basic environment as their first parameter, and can thus only call
+// basic APIs (unless the user explicitly casts the environment), we achieve
+// the ability to ensure at compile time that we do not call APIs that affect
+// the state of the JS engine from a synchronous (basic) finalizer.
+typedef struct napi_env__* node_api_nogc_env;
+typedef node_api_nogc_env node_api_basic_env;
+
 typedef struct napi_value__* napi_value;
 typedef struct napi_ref__* napi_ref;
 typedef struct napi_handle_scope__* napi_handle_scope;
@@ -116,6 +140,9 @@ typedef void(NAPI_CDECL* napi_finalize)(napi_env env,
                                         void* finalize_data,
                                         void* finalize_hint);
 
+typedef napi_finalize node_api_nogc_finalize;
+typedef node_api_nogc_finalize node_api_basic_finalize;
+
 typedef struct {
   // One of utf8name or name should be NULL.
   const char* utf8name;