koffi 2.12.0 → 2.12.2

package/vendor/node-addon-api/doc/README.md

@@ -0,0 +1,145 @@
+# node-addon-api Documents
+
+* [Setup](#setup)
+* [API Documentation](#api)
+* [Examples](#examples)
+* [ABI Stability Guideline](#abi-stability-guideline)
+* [More resource and info about native Addons](#resources)
+
+Node-API is an ABI stable C interface provided by Node.js for building native
+addons. It is independent of the underlying JavaScript runtime (e.g. V8 or ChakraCore)
+and is maintained as part of Node.js itself. It is intended to insulate
+native addons from changes in the underlying JavaScript engine and allow
+modules compiled for one version to run on later versions of Node.js without
+recompilation.
+
+The `node-addon-api` module, which is not part of Node.js, preserves the benefits
+of the Node-API as it consists only of inline code that depends only on the stable API
+provided by Node-API. As such, modules built against one version of Node.js
+using node-addon-api should run without having to be rebuilt with newer versions
+of Node.js.
+
+## Setup
+  - [Installation and usage](setup.md)
+  - [node-gyp](node-gyp.md)
+  - [cmake-js](cmake-js.md)
+  - [Conversion tool](conversion-tool.md)
+  - [Checker tool](checker-tool.md)
+  - [Generator](generator.md)
+  - [Prebuild tools](prebuild_tools.md)
+
+<a name="api"></a>
+
+## API Documentation
+
+The following is the documentation for node-addon-api.
+
+ - [Full Class Hierarchy](hierarchy.md)
+ - [Addon Structure](addon.md)
+ - Data Types:
+    - [BasicEnv](basic_env.md)
+    - [Env](env.md)
+    - [CallbackInfo](callbackinfo.md)
+    - [Reference](reference.md)
+    - [Value](value.md)
+        - [Name](name.md)
+            - [Symbol](symbol.md)
+            - [String](string.md)
+        - [Number](number.md)
+        - [Date](date.md)
+        - [BigInt](bigint.md)
+        - [Boolean](boolean.md)
+        - [External](external.md)
+        - [Object](object.md)
+            - [Array](array.md)
+            - [ObjectReference](object_reference.md)
+    - [PropertyDescriptor](property_descriptor.md)
+    - [Function](function.md)
+        - [FunctionReference](function_reference.md)
+    - [ObjectWrap](object_wrap.md)
+        - [ClassPropertyDescriptor](class_property_descriptor.md)
+    - [Buffer](buffer.md)
+    - [ArrayBuffer](array_buffer.md)
+    - [TypedArray](typed_array.md)
+      - [TypedArrayOf](typed_array_of.md)
+    - [DataView](dataview.md)
+ - [Error Handling](error_handling.md)
+    - [Error](error.md)
+      - [TypeError](type_error.md)
+      - [RangeError](range_error.md)
+      - [SyntaxError](syntax_error.md)
+ - [Object Lifetime Management](object_lifetime_management.md)
+    - [HandleScope](handle_scope.md)
+    - [EscapableHandleScope](escapable_handle_scope.md)
+    - [Finalization](finalization.md)
+ - [Memory Management](memory_management.md)
+ - [Async Operations](async_operations.md)
+    - [AsyncWorker](async_worker.md)
+    - [AsyncContext](async_context.md)
+    - [AsyncWorker Variants](async_worker_variants.md)
+ - [Thread-safe Functions](threadsafe.md)
+    - [ThreadSafeFunction](threadsafe_function.md)
+    - [TypedThreadSafeFunction](typed_threadsafe_function.md)
+ - [Promises](promises.md)
+ - [Version management](version_management.md)
+
+<a name="examples"></a>
+
+## Examples
+
+Are you new to **node-addon-api**? Take a look at our **[examples](https://github.com/nodejs/node-addon-examples)**
+
+- [Hello World](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/1_hello_world)
+- [Pass arguments to a function](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/2_function_arguments/node-addon-api)
+- [Callbacks](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/3_callbacks/node-addon-api)
+- [Object factory](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/4_object_factory/node-addon-api)
+- [Function factory](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/5_function_factory/node-addon-api)
+- [Wrapping C++ Object](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/6_object_wrap/node-addon-api)
+- [Factory of wrapped object](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/7_factory_wrap/node-addon-api)
+- [Passing wrapped object around](https://github.com/nodejs/node-addon-examples/tree/main/src/2-js-to-native-conversion/8_passing_wrapped/node-addon-api)
+
+<a name="abi-stability-guideline"></a>
+
+## ABI Stability Guideline
+
+It is important to remember that *other* Node.js interfaces such as
+`libuv` (included in a project via `#include <uv.h>`) are not ABI-stable across
+Node.js major versions. Thus, an addon must use Node-API and/or `node-addon-api`
+exclusively and build against a version of Node.js that includes an
+implementation of Node-API (meaning an active LTS version of Node.js) in
+order to benefit from ABI stability across Node.js major versions. Node.js
+provides an [ABI stability guide][] containing a detailed explanation of ABI
+stability in general, and the Node-API ABI stability guarantee in particular.
+
+<a name="resources"></a>
+
+## More resource and info about native Addons
+
+There are three options for implementing addons: Node-API, nan, or direct
+use of internal V8, libuv, and Node.js libraries. Unless there is a need for
+direct access to functionality that is not exposed by Node-API as outlined
+in [C/C++ addons](https://nodejs.org/dist/latest/docs/api/addons.html)
+in Node.js core, use Node-API. Refer to
+[C/C++ addons with Node-API](https://nodejs.org/dist/latest/docs/api/n-api.html)
+for more information on Node-API.
+
+- [C++ Addons](https://nodejs.org/dist/latest/docs/api/addons.html)
+- [Node-API](https://nodejs.org/dist/latest/docs/api/n-api.html)
+- [Node-API - Next Generation Node API for Native Modules](https://youtu.be/-Oniup60Afs)
+- [How We Migrated Realm JavaScript From NAN to Node-API](https://developer.mongodb.com/article/realm-javascript-nan-to-n-api)
+
+As node-addon-api's core mission is to expose the plain C Node-API as C++
+wrappers, tools that facilitate n-api/node-addon-api providing more
+convenient patterns for developing a Node.js add-on with n-api/node-addon-api
+can be published to NPM as standalone packages. It is also recommended to tag
+such packages with `node-addon-api` to provide more visibility to the community.
+
+Quick links to NPM searches: [keywords:node-addon-api](https://www.npmjs.com/search?q=keywords%3Anode-addon-api).
+
+<a name="other-bindings"></a>
+
+## Other bindings
+
+- [napi-rs](https://napi.rs) - (`Rust`)
+
+[ABI stability guide]: https://nodejs.org/en/docs/guides/abi-stability/

package/vendor/node-addon-api/doc/array_buffer.md

@@ -31,13 +31,13 @@ Wraps the provided external data into a new `Napi::ArrayBuffer` instance.
 The `Napi::ArrayBuffer` instance does not assume ownership for the data and
 expects it to be valid for the lifetime of the instance. Since the
 `Napi::ArrayBuffer` is subject to garbage collection this overload is only
-suitable for data which is static and never needs to be freed.
-This factory method will not provide the caller with an opportunity to free the
-data when the `Napi::ArrayBuffer` gets garbage-collected. If you need to free
-the data retained by the `Napi::ArrayBuffer` object please use other
-variants of the `Napi::ArrayBuffer::New` factory method that accept
-`Napi::Finalizer`, which is a function that will be invoked when the
-`Napi::ArrayBuffer` object has been destroyed.
+suitable for data which is static and never needs to be freed. This factory
+method will not provide the caller with an opportunity to free the data when the
+`Napi::ArrayBuffer` gets garbage-collected. If you need to free the data
+retained by the `Napi::ArrayBuffer` object please use other variants of the
+`Napi::ArrayBuffer::New` factory method that accept `Napi::Finalizer`, which is
+a function that will be invoked when the `Napi::ArrayBuffer` object has been
+destroyed. See [Finalization][] for more details.
 
 ```cpp
 static Napi::ArrayBuffer Napi::ArrayBuffer::New(napi_env env, void* externalData, size_t byteLength);
@@ -72,9 +72,9 @@ static Napi::ArrayBuffer Napi::ArrayBuffer::New(napi_env env,
 - `[in] env`: The environment in which to create the `Napi::ArrayBuffer` instance.
 - `[in] externalData`: The pointer to the external data to wrap.
 - `[in] byteLength`: The length of the `externalData`, in bytes.
-- `[in] finalizeCallback`: A function to be called when the `Napi::ArrayBuffer` is
-  destroyed. It must implement `operator()`, accept an Napi::Env, a `void*` (which is the
-  `externalData` pointer), and return `void`.
+- `[in] finalizeCallback`: A function called when the engine destroys the
+  `Napi::ArrayBuffer` object, implementing `operator()(Napi::BasicEnv, void*)`.
+  See [Finalization][] for more details.
 
 Returns a new `Napi::ArrayBuffer` instance.
 
@@ -102,11 +102,10 @@ static Napi::ArrayBuffer Napi::ArrayBuffer::New(napi_env env,
 - `[in] env`: The environment in which to create the `Napi::ArrayBuffer` instance.
 - `[in] externalData`: The pointer to the external data to wrap.
 - `[in] byteLength`: The length of the `externalData`, in bytes.
-- `[in] finalizeCallback`: The function to be called when the `Napi::ArrayBuffer` is
-  destroyed. It must implement `operator()`, accept an Napi::Env, a `void*` (which is the
-  `externalData` pointer) and `Hint*`, and return `void`.
-- `[in] finalizeHint`: The hint to be passed as the second parameter of the
-  finalize callback.
+- `[in] finalizeCallback`: A function called when the engine destroys the
+  `Napi::ArrayBuffer` object, implementing `operator()(Napi::BasicEnv, void*,
+  Hint*)`. See [Finalization][] for more details.
+- `[in] finalizeHint`: The hint value passed to the `finalizeCallback` function.
 
 Returns a new `Napi::ArrayBuffer` instance.
 
@@ -163,3 +162,4 @@ Returns `true` if this `ArrayBuffer` has been detached.
 
 [`Napi::Object`]: ./object.md
 [External Buffer]: ./external_buffer.md
+[Finalization]: ./finalization.md

package/vendor/node-addon-api/doc/basic_env.md

@@ -0,0 +1,200 @@
+# BasicEnv
+
+The data structure containing the environment in which the request is being run.
+
+The `Napi::BasicEnv` object is usually created and passed by the Node.js runtime
+or node-addon-api infrastructure.
+
+The `Napi::BasicEnv` object represents an environment that has a limited subset
+of APIs when compared to `Napi::Env` and can be used in basic finalizers. See
+[Finalization][] for more details.
+
+## Methods
+
+### Constructor
+
+```cpp
+Napi::BasicEnv::BasicEnv(node_api_nogc_env env);
+```
+
+- `[in] env`: The `node_api_nogc_env` environment from which to construct the
+  `Napi::BasicEnv` object.
+
+### node_api_nogc_env
+
+```cpp
+operator node_api_nogc_env() const;
+```
+
+Returns the `node_api_nogc_env` opaque data structure representing the
+environment.
+
+### GetInstanceData
+```cpp
+template <typename T> T* GetInstanceData() const;
+```
+
+Returns the instance data that was previously associated with the environment,
+or `nullptr` if none was associated.
+
+### SetInstanceData
+
+
+```cpp
+template <typename T> using Finalizer = void (*)(Env, T*);
+template <typename T, Finalizer<T> fini = Env::DefaultFini<T>>
+void SetInstanceData(T* data) const;
+```
+
+- `[template] fini`: A function to call when the instance data is to be deleted.
+Accepts a function of the form `void CleanupData(Napi::Env env, T* data)`. If
+not given, the default finalizer will be used, which simply uses the `delete`
+operator to destroy `T*` when the add-on instance is unloaded.
+- `[in] data`: A pointer to data that will be associated with the instance of
+the add-on for the duration of its lifecycle.
+
+Associates a data item stored at `T* data` with the current instance of the
+add-on. The item will be passed to the function `fini` which gets called when an
+instance of the add-on is unloaded.
+
+### SetInstanceData
+
+```cpp
+template <typename DataType, typename HintType>
+using FinalizerWithHint = void (*)(Env, DataType*, HintType*);
+template <typename DataType,
+          typename HintType,
+          FinalizerWithHint<DataType, HintType> fini =
+            Env::DefaultFiniWithHint<DataType, HintType>>
+void SetInstanceData(DataType* data, HintType* hint) const;
+```
+
+- `[template] fini`: A function to call when the instance data is to be deleted.
+Accepts a function of the form `void CleanupData(Napi::Env env, DataType* data,
+HintType* hint)`. If not given, the default finalizer will be used, which simply
+uses the `delete` operator to destroy `T*` when the add-on instance is unloaded.
+- `[in] data`: A pointer to data that will be associated with the instance of
+the add-on for the duration of its lifecycle.
+- `[in] hint`: A pointer to data that will be associated with the instance of
+the add-on for the duration of its lifecycle and will be passed as a hint to
+`fini` when the add-on instance is unloaded.
+
+Associates a data item stored at `T* data` with the current instance of the
+add-on. The item will be passed to the function `fini` which gets called when an
+instance of the add-on is unloaded. This overload accepts an additional hint to
+be passed to `fini`.
+
+### GetModuleFileName
+
+```cpp
+const char* Napi::Env::GetModuleFileName() const;
+```
+
+Returns a URL containing the absolute path of the location from which the add-on
+was loaded. For a file on the local file system it will start with `file://`.
+The string is null-terminated and owned by env and must thus not be modified or
+freed. It is only valid while the add-on is loaded.
+
+### AddCleanupHook
+
+```cpp
+template <typename Hook>
+CleanupHook<Hook> AddCleanupHook(Hook hook);
+```
+
+- `[in] hook`: A function to call when the environment exits. Accepts a function
+  of the form `void ()`.
+
+Registers `hook` as a function to be run once the current Node.js environment
+exits. Unlike the underlying C-based Node-API, providing the same `hook`
+multiple times **is** allowed. The hooks will be called in reverse order, i.e.
+the most recently added one will be called first.
+
+Returns an `Env::CleanupHook` object, which can be used to remove the hook via
+its `Remove()` method.
+
+### PostFinalizer
+
+```cpp
+template <typename FinalizerType>
+inline void PostFinalizer(FinalizerType finalizeCallback) const;
+```
+
+- `[in] finalizeCallback`: The function to queue for execution outside of the GC
+  finalization, implementing `operator()(Napi::Env)`. See [Finalization][] for
+  more details.
+
+### PostFinalizer
+
+```cpp
+template <typename FinalizerType, typename T>
+inline void PostFinalizer(FinalizerType finalizeCallback, T* data) const;
+```
+
+- `[in] finalizeCallback`: The function to queue for execution outside of the GC
+  finalization, implementing `operator()(Napi::Env, T*)`. See [Finalization][]
+  for more details.
+- `[in] data`: The data to associate with the object.
+
+### PostFinalizer
+
+```cpp
+template <typename FinalizerType, typename T, typename Hint>
+inline void PostFinalizer(FinalizerType finalizeCallback,
+                          T* data,
+                          Hint* finalizeHint) const;
+```
+
+- `[in] finalizeCallback`: The function to queue for execution outside of the GC
+  finalization, implementing `operator()(Napi::Env, T*, Hint*)`. See
+  [Finalization][] for more details.
+- `[in] data`: The data to associate with the object.
+- `[in] finalizeHint`: The hint value passed to the `finalizeCallback` function.
+
+### AddCleanupHook
+
+```cpp
+template <typename Hook, typename Arg>
+CleanupHook<Hook, Arg> AddCleanupHook(Hook hook, Arg* arg);
+```
+
+- `[in] hook`: A function to call when the environment exits. Accepts a function
+  of the form `void (Arg* arg)`.
+- `[in] arg`: A pointer to data that will be passed as the argument to `hook`.
+
+Registers `hook` as a function to be run with the `arg` parameter once the
+current Node.js environment exits. Unlike the underlying C-based Node-API,
+providing the same `hook` and `arg` pair multiple times **is** allowed. The
+hooks will be called in reverse order, i.e. the most recently added one will be
+called first.
+
+Returns an `Env::CleanupHook` object, which can be used to remove the hook via
+its `Remove()` method.
+
+# Env::CleanupHook
+
+The `Env::CleanupHook` object allows removal of the hook added via
+`Env::AddCleanupHook()`
+
+## Methods
+
+### IsEmpty
+
+```cpp
+bool IsEmpty();
+```
+
+Returns `true` if the cleanup hook was **not** successfully registered.
+
+### Remove
+
+```cpp
+bool Remove(Env env);
+```
+
+Unregisters the hook from running once the current Node.js environment exits.
+
+Returns `true` if the hook was successfully removed from the Node.js
+environment.
+
+[Finalization]: ./finalization.md

package/vendor/node-addon-api/doc/buffer.md

@@ -27,16 +27,15 @@ Returns a new `Napi::Buffer` object.
 
 Wraps the provided external data into a new `Napi::Buffer` object.
 
-The `Napi::Buffer` object does not assume ownership for the data and expects it to be
-valid for the lifetime of the object. Since the `Napi::Buffer` is subject to garbage
-collection this overload is only suitable for data which is static and never
-needs to be freed.
-This factory method will not provide the caller with an opportunity to free the
-data when the `Napi::Buffer` gets garbage-collected. If you need to free the
-data retained by the `Napi::Buffer` object please use other variants of the
-`Napi::Buffer::New` factory method that accept `Napi::Finalizer`, which is a
-function that will be invoked when the `Napi::Buffer` object has been
-destroyed.
+The `Napi::Buffer` object does not assume ownership for the data and expects it
+to be valid for the lifetime of the object. Since the `Napi::Buffer` is subject
+to garbage collection this overload is only suitable for data which is static
+and never needs to be freed. This factory method will not provide the caller
+with an opportunity to free the data when the `Napi::Buffer` gets
+garbage-collected. If you need to free the data retained by the `Napi::Buffer`
+object please use other variants of the `Napi::Buffer::New` factory method that
+accept `Finalizer`, which is a function that will be invoked when the
+`Napi::Buffer` object has been destroyed. See [Finalization][] for more details.
 
 ```cpp
 static Napi::Buffer<T> Napi::Buffer::New(napi_env env, T* data, size_t length);
@@ -70,9 +69,9 @@ static Napi::Buffer<T> Napi::Buffer::New(napi_env env,
 - `[in] env`: The environment in which to create the `Napi::Buffer` object.
 - `[in] data`: The pointer to the external data to expose.
 - `[in] length`: The number of `T` elements in the external data.
-- `[in] finalizeCallback`: The function to be called when the `Napi::Buffer` is
-  destroyed. It must implement `operator()`, accept an Napi::Env, a `T*` (which is the
-  external data pointer), and return `void`.
+- `[in] finalizeCallback`: The function called when the engine destroys the
+  `Napi::Buffer` object, implementing `operator()(Napi::BasicEnv, T*)`. See
+  [Finalization][] for more details.
 
 Returns a new `Napi::Buffer` object.
 
@@ -99,11 +98,10 @@ static Napi::Buffer<T> Napi::Buffer::New(napi_env env,
 - `[in] env`: The environment in which to create the `Napi::Buffer` object.
 - `[in] data`: The pointer to the external data to expose.
 - `[in] length`: The number of `T` elements in the external data.
-- `[in] finalizeCallback`: The function to be called when the `Napi::Buffer` is
-  destroyed. It must implement `operator()`, accept an Napi::Env, a `T*` (which is the
-  external data pointer) and `Hint*`, and return `void`.
-- `[in] finalizeHint`: The hint to be passed as the second parameter of the
-  finalize callback.
+- `[in] finalizeCallback`: The function called when the engine destroys the
+  `Napi::Buffer` object, implementing `operator()(Napi::BasicEnv, T*, Hint*)`.
+  See [Finalization][] for more details.
+- `[in] finalizeHint`: The hint value passed to the `finalizeCallback` function.
 
 Returns a new `Napi::Buffer` object.
 
@@ -157,9 +155,9 @@ static Napi::Buffer<T> Napi::Buffer::NewOrCopy(napi_env env,
 - `[in] env`: The environment in which to create the `Napi::Buffer` object.
 - `[in] data`: The pointer to the external data to expose.
 - `[in] length`: The number of `T` elements in the external data.
-- `[in] finalizeCallback`: The function to be called when the `Napi::Buffer` is
-  destroyed. It must implement `operator()`, accept an Napi::Env, a `T*` (which is the
-  external data pointer), and return `void`.
+- `[in] finalizeCallback`: The function called when the engine destroys the
+  `Napi::Buffer` object, implementing `operator()(Napi::BasicEnv, T*)`. See
+  [Finalization][] for more details.
 
 Returns a new `Napi::Buffer` object.
 
@@ -186,11 +184,10 @@ static Napi::Buffer<T> Napi::Buffer::NewOrCopy(napi_env env,
 - `[in] env`: The environment in which to create the `Napi::Buffer` object.
 - `[in] data`: The pointer to the external data to expose.
 - `[in] length`: The number of `T` elements in the external data.
-- `[in] finalizeCallback`: The function to be called when the `Napi::Buffer` is
-  destroyed. It must implement `operator()`, accept an Napi::Env, a `T*` (which is the
-  external data pointer) and `Hint*`, and return `void`.
-- `[in] finalizeHint`: The hint to be passed as the second parameter of the
-  finalize callback.
+- `[in] finalizeCallback`: The function called when the engine destroys the
+  `Napi::Buffer` object, implementing `operator()(Napi::BasicEnv, T*, Hint*)`.
+  See [Finalization][] for more details.
+- `[in] finalizeHint`: The hint value passed to the `finalizeCallback` function.
 
 Returns a new `Napi::Buffer` object.
 
@@ -245,3 +242,4 @@ Returns the number of `T` elements in the external data.
 
 [`Napi::Uint8Array`]: ./typed_array_of.md
 [External Buffer]: ./external_buffer.md
+[Finalization]: ./finalization.md

package/vendor/node-addon-api/doc/cmake-js.md

@@ -45,6 +45,25 @@ The following line in the `CMakeLists.txt` file will enable Node-API experimenta
 add_definitions(-DNAPI_EXPERIMENTAL)
 ```
 
+### Exception Handling
+
+To enable C++ exception handling (for more info see: [Setup](setup.md)), define
+the corresponding preprocessor directives depending on which exception handling
+behavior is desired.
+
+To enable C++ exception handling with `Napi::Error` objects only:
+
+```
+add_definitions(-DNODE_ADDON_API_CPP_EXCEPTIONS)
+```
+
+To enable C++ exception handling for all exceptions thrown:
+
+```
+add_definitions(-DNODE_ADDON_API_CPP_EXCEPTIONS)
+add_definitions(-DNODE_ADDON_API_CPP_EXCEPTIONS_ALL)
+```
+
 ### node-addon-api
 
 If your Node-API native add-on uses the optional [**node-addon-api**](https://github.com/nodejs/node-addon-api#node-addon-api-module) C++ wrapper, the `CMakeLists.txt` file requires additional configuration information as described on the [CMake.js README file](https://github.com/cmake-js/cmake-js#node-api-and-node-addon-api).

package/vendor/node-addon-api/doc/{creating_a_release.md → contributing/creating_a_release.md}

@@ -6,7 +6,17 @@ 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-addon-api/blob/main/.github/workflows/release-please.yml)
+GitHub action. It will bump the version in `package.json` and publish
+node-addon-api to npm.
+
+In cases that the release-please action is not working, please follow the steps
+below to publish node-addon-api manually.
+
+## Publish new release manually
+
+### Prerequisites
 
 Before to start creating a new release check if you have installed the following
 tools:
@@ -16,7 +26,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:
 
@@ -34,14 +44,16 @@ to show the new version as the latest.
 the route folder of the repo launch the following command:
 
     ```bash
-    > changelog-maker
+    > changelog-maker --md --group --filter-release
     ```
 * Use the output generated by **changelog maker** to update the [CHANGELOG.md](https://github.com/nodejs/node-addon-api/blob/main/CHANGELOG.md)
 following the style used in publishing the previous release.
 
 * Add any new contributors to the "contributors" section in the package.json
 
-* Validate all tests pass by running `npm test` on the `main` branch.
+* Commit with a message containing _only_ an x.y.z semver designator. "x.y.z" (so that the commit can be filtered by changelog-maker)
+
+* Create a release proposal pull request.
 
 * Use **[CI](https://ci.nodejs.org/view/x%20-%20Abi%20stable%20module%20API/job/node-test-node-addon-api-new/)**
 to validate tests pass (note there are still some issues on SmartOS and