@encharm/cws 4.4.1 → 4.5.1

package/src/headers/{18 → 22}/histogram.h

@@ -3,13 +3,13 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include "hdr_histogram.h"
+#include <hdr/hdr_histogram.h>
 #include "base_object.h"
 #include "memory_tracker.h"
 #include "node_messaging.h"
 #include "util.h"
-#include "v8.h"
 #include "uv.h"
+#include "v8.h"
 
 #include <functional>
 #include <limits>
@@ -69,6 +69,12 @@ class Histogram : public MemoryRetainer {
 
 class HistogramImpl {
  public:
+  enum InternalFields {
+    kSlot = BaseObject::kSlot,
+    kImplField = BaseObject::kInternalFieldCount,
+    kInternalFieldCount
+  };
+
   explicit HistogramImpl(
       const Histogram::Options& options = Histogram::Options {});
   explicit HistogramImpl(std::shared_ptr<Histogram> histogram);
@@ -77,15 +83,68 @@ class HistogramImpl {
 
   const std::shared_ptr<Histogram>& histogram() const { return histogram_; }
 
+  static void DoReset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetCountBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMinBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMaxBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetExceedsBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetCount(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMin(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMax(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMean(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetExceeds(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetStddev(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentile(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentileBigInt(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentiles(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentilesBigInt(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void FastReset(v8::Local<v8::Value> unused,
+                        v8::Local<v8::Value> receiver);
+  static double FastGetCount(v8::Local<v8::Value> unused,
+                             v8::Local<v8::Value> receiver);
+  static double FastGetMin(v8::Local<v8::Value> unused,
+                           v8::Local<v8::Value> receiver);
+  static double FastGetMax(v8::Local<v8::Value> unused,
+                           v8::Local<v8::Value> receiver);
+  static double FastGetMean(v8::Local<v8::Value> unused,
+                            v8::Local<v8::Value> receiver);
+  static double FastGetExceeds(v8::Local<v8::Value> unused,
+                               v8::Local<v8::Value> receiver);
+  static double FastGetStddev(v8::Local<v8::Value> unused,
+                              v8::Local<v8::Value> receiver);
+  static double FastGetPercentile(v8::Local<v8::Value> unused,
+                                  v8::Local<v8::Value> receiver,
+                                  const double percentile);
+
+  static void AddMethods(v8::Isolate* isolate,
+                         v8::Local<v8::FunctionTemplate> tmpl);
+
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  static HistogramImpl* FromJSObject(v8::Local<v8::Value> value);
+
  private:
   std::shared_ptr<Histogram> histogram_;
+
+  static v8::CFunction fast_reset_;
+  static v8::CFunction fast_get_count_;
+  static v8::CFunction fast_get_min_;
+  static v8::CFunction fast_get_max_;
+  static v8::CFunction fast_get_mean_;
+  static v8::CFunction fast_get_exceeds_;
+  static v8::CFunction fast_get_stddev_;
+  static v8::CFunction fast_get_percentile_;
 };
 
-class HistogramBase : public BaseObject, public HistogramImpl {
+class HistogramBase final : public BaseObject, public HistogramImpl {
  public:
   static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
-    Environment* env);
-  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+      IsolateData* isolate_data);
+  static void Initialize(IsolateData* isolate_data,
+                         v8::Local<v8::ObjectTemplate> target);
   static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
   static BaseObjectPtr<HistogramBase> Create(
@@ -102,30 +161,18 @@ class HistogramBase : public BaseObject, public HistogramImpl {
   SET_MEMORY_INFO_NAME(HistogramBase)
   SET_SELF_SIZE(HistogramBase)
 
-  static void GetCountBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetMinBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetMaxBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetExceedsBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void GetCount(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetMin(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetMax(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetMean(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetExceeds(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetStddev(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetPercentile(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetPercentileBigInt(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetPercentiles(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetPercentilesBigInt(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void DoReset(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Record(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void RecordDelta(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Add(const v8::FunctionCallbackInfo<v8::Value>& args);
 
+  static void FastRecord(
+      v8::Local<v8::Value> unused,
+      v8::Local<v8::Value> receiver,
+      const int64_t value,
+      v8::FastApiCallbackOptions& options);  // NOLINT(runtime/references)
+  static void FastRecordDelta(v8::Local<v8::Value> unused,
+                              v8::Local<v8::Value> receiver);
+
   HistogramBase(
       Environment* env,
       v8::Local<v8::Object> wrap,
@@ -136,7 +183,7 @@ class HistogramBase : public BaseObject, public HistogramImpl {
       v8::Local<v8::Object> wrap,
       std::shared_ptr<Histogram> histogram);
 
-  TransferMode GetTransferMode() const override {
+  BaseObject::TransferMode GetTransferMode() const override {
     return TransferMode::kCloneable;
   }
   std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
@@ -161,9 +208,13 @@ class HistogramBase : public BaseObject, public HistogramImpl {
    private:
     std::shared_ptr<Histogram> histogram_;
   };
+
+ private:
+  static v8::CFunction fast_record_;
+  static v8::CFunction fast_record_delta_;
 };
 
-class IntervalHistogram : public HandleWrap, public HistogramImpl {
+class IntervalHistogram final : public HandleWrap, public HistogramImpl {
  public:
   enum class StartFlags {
     NONE,
@@ -189,30 +240,16 @@ class IntervalHistogram : public HandleWrap, public HistogramImpl {
       std::function<void(Histogram&)> on_interval,
       const Histogram::Options& options = Histogram::Options {});
 
-  static void GetCountBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetMinBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetMaxBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetExceedsBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void GetCount(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetMin(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetMax(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetMean(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetExceeds(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetStddev(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetPercentile(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetPercentileBigInt(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetPercentiles(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetPercentilesBigInt(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void DoReset(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  TransferMode GetTransferMode() const override {
+  static void FastStart(v8::Local<v8::Value> unused,
+                        v8::Local<v8::Value> receiver,
+                        bool reset);
+  static void FastStop(v8::Local<v8::Value> unused,
+                       v8::Local<v8::Value> receiver);
+
+  BaseObject::TransferMode GetTransferMode() const override {
     return TransferMode::kCloneable;
   }
   std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
@@ -230,6 +267,9 @@ class IntervalHistogram : public HandleWrap, public HistogramImpl {
   int32_t interval_ = 0;
   std::function<void(Histogram&)> on_interval_;
   uv_timer_t timer_;
+
+  static v8::CFunction fast_start_;
+  static v8::CFunction fast_stop_;
 };
 
 }  // namespace node

package/src/headers/{16 → 22}/inspector_agent.h

@@ -61,11 +61,22 @@ class Agent {
 
   // Blocks till frontend connects and sends "runIfWaitingForDebugger"
   void WaitForConnect();
+  bool WaitForConnectByOptions();
+  void StopIfWaitingForConnect();
+
   // Blocks till all the sessions with "WaitForDisconnectOnShutdown" disconnect
   void WaitForDisconnect();
   void ReportUncaughtException(v8::Local<v8::Value> error,
                                v8::Local<v8::Message> message);
 
+  void EmitProtocolEvent(const v8_inspector::StringView& event,
+                         const v8_inspector::StringView& params);
+
+  void SetupNetworkTracking(v8::Local<v8::Function> enable_function,
+                            v8::Local<v8::Function> disable_function);
+  void EnableNetworkTracking();
+  void DisableNetworkTracking();
+
   // Async stack traces instrumentation.
   void AsyncTaskScheduled(const v8_inspector::StringView& taskName, void* task,
                           bool recurring);
@@ -82,7 +93,7 @@ class Agent {
 
   void SetParentHandle(std::unique_ptr<ParentInspectorHandle> parent_handle);
   std::unique_ptr<ParentInspectorHandle> GetParentHandle(
-      uint64_t thread_id, const std::string& url);
+      uint64_t thread_id, const std::string& url, const std::string& name);
 
   // Called to create inspector sessions that can be used from the same thread.
   // The inspector responds by using the delegate to send messages back.
@@ -118,6 +129,7 @@ class Agent {
 
  private:
   void ToggleAsyncHook(v8::Isolate* isolate, v8::Local<v8::Function> fn);
+  void ToggleNetworkTracking(v8::Isolate* isolate, v8::Local<v8::Function> fn);
 
   node::Environment* parent_env_;
   // Encapsulates majority of the Inspector functionality
@@ -136,6 +148,10 @@ class Agent {
 
   bool pending_enable_async_hook_ = false;
   bool pending_disable_async_hook_ = false;
+
+  bool network_tracking_enabled_ = false;
+  bool pending_enable_network_tracking = false;
+  bool pending_disable_network_tracking = false;
 };
 
 }  // namespace inspector

package/src/headers/{16 → 22}/inspector_profiler.h

@@ -7,8 +7,10 @@
 #error("This header can only be used when inspector is enabled")
 #endif
 
+#include <optional>
 #include <unordered_set>
 #include "inspector_agent.h"
+#include "simdjson.h"
 
 namespace node {
 // Forward declaration to break recursive dependency chain with src/env.h.
@@ -40,7 +42,7 @@ class V8ProfilerConnection {
   // The optional `params` should be formatted in JSON.
   // The strings should be in one byte characters - which is enough for
   // the commands we use here.
-  uint32_t DispatchMessage(const char* method,
+  uint64_t DispatchMessage(const char* method,
                            const char* params = nullptr,
                            bool is_profile_request = false);
 
@@ -59,23 +61,24 @@ class V8ProfilerConnection {
   virtual std::string GetFilename() const = 0;
   // Return the profile object parsed from `message.result`,
   // which will be then written as a JSON.
-  virtual v8::MaybeLocal<v8::Object> GetProfile(
-      v8::Local<v8::Object> result) = 0;
-  virtual void WriteProfile(v8::Local<v8::Object> result);
+  virtual std::optional<std::string_view> GetProfile(
+      simdjson::ondemand::object* result);
+  virtual void WriteProfile(simdjson::ondemand::object* result);
 
-  bool HasProfileId(uint32_t id) const {
+  bool HasProfileId(uint64_t id) const {
     return profile_ids_.find(id) != profile_ids_.end();
   }
 
-  void RemoveProfileId(uint32_t id) { profile_ids_.erase(id); }
+  void RemoveProfileId(uint64_t id) { profile_ids_.erase(id); }
 
  private:
-  uint32_t next_id() { return id_++; }
+  uint64_t next_id() { return id_++; }
   std::unique_ptr<inspector::InspectorSession> session_;
-  uint32_t id_ = 1;
-  std::unordered_set<uint32_t> profile_ids_;
+  uint64_t id_ = 1;
+  std::unordered_set<uint64_t> profile_ids_;
 
  protected:
+  simdjson::ondemand::parser json_parser_;
   Environment* env_ = nullptr;
 };
 
@@ -91,8 +94,9 @@ class V8CoverageConnection : public V8ProfilerConnection {
 
   std::string GetDirectory() const override;
   std::string GetFilename() const override;
-  v8::MaybeLocal<v8::Object> GetProfile(v8::Local<v8::Object> result) override;
-  void WriteProfile(v8::Local<v8::Object> result) override;
+  std::optional<std::string_view> GetProfile(
+      simdjson::ondemand::object* result) override;
+  void WriteProfile(simdjson::ondemand::object* result) override;
   void WriteSourceMapCache();
   void TakeCoverage();
   void StopCoverage();
@@ -115,7 +119,6 @@ class V8CpuProfilerConnection : public V8ProfilerConnection {
 
   std::string GetDirectory() const override;
   std::string GetFilename() const override;
-  v8::MaybeLocal<v8::Object> GetProfile(v8::Local<v8::Object> result) override;
 
  private:
   std::unique_ptr<inspector::InspectorSession> session_;
@@ -135,7 +138,6 @@ class V8HeapProfilerConnection : public V8ProfilerConnection {
 
   std::string GetDirectory() const override;
   std::string GetFilename() const override;
-  v8::MaybeLocal<v8::Object> GetProfile(v8::Local<v8::Object> result) override;
 
  private:
   std::unique_ptr<inspector::InspectorSession> session_;

package/src/headers/{18 → 22}/js_native_api.h

@@ -28,7 +28,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")))
@@ -49,8 +49,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,
@@ -92,16 +92,46 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_utf16(napi_env env,
                                                             const char16_t* str,
                                                             size_t length,
                                                             napi_value* result);
+#ifdef NAPI_EXPERIMENTAL
+#define NODE_API_EXPERIMENTAL_HAS_EXTERNAL_STRINGS
+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);
+#endif  // NAPI_EXPERIMENTAL
+
+#ifdef NAPI_EXPERIMENTAL
+#define NODE_API_EXPERIMENTAL_HAS_PROPERTY_KEYS
+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_EXPERIMENTAL
+
 NAPI_EXTERN napi_status NAPI_CDECL napi_create_symbol(napi_env env,
                                                       napi_value description,
                                                       napi_value* result);
-#ifdef NAPI_EXPERIMENTAL
+#if NAPI_VERSION >= 9
 NAPI_EXTERN napi_status NAPI_CDECL
 node_api_symbol_for(napi_env env,
                     const char* utf8description,
                     size_t length,
                     napi_value* result);
-#endif  // NAPI_EXPERIMENTAL
+#endif  // NAPI_VERSION >= 9
 NAPI_EXTERN napi_status NAPI_CDECL napi_create_function(napi_env env,
                                                         const char* utf8name,
                                                         size_t length,
@@ -120,10 +150,10 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_create_range_error(napi_env env,
                                                            napi_value code,
                                                            napi_value msg,
                                                            napi_value* result);
-#ifdef NAPI_EXPERIMENTAL
+#if NAPI_VERSION >= 9
 NAPI_EXTERN napi_status NAPI_CDECL node_api_create_syntax_error(
     napi_env env, napi_value code, napi_value msg, napi_value* result);
-#endif  // NAPI_EXPERIMENTAL
+#endif  // NAPI_VERSION >= 9
 
 // Methods to get the native napi_value from Primitive type
 NAPI_EXTERN napi_status NAPI_CDECL napi_typeof(napi_env env,
@@ -271,7 +301,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.
@@ -292,12 +322,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);
@@ -307,7 +338,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,
@@ -378,11 +409,11 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_throw_type_error(napi_env env,
 NAPI_EXTERN napi_status NAPI_CDECL napi_throw_range_error(napi_env env,
                                                           const char* code,
                                                           const char* msg);
-#ifdef NAPI_EXPERIMENTAL
+#if NAPI_VERSION >= 9
 NAPI_EXTERN napi_status NAPI_CDECL node_api_throw_syntax_error(napi_env env,
                                                                const char* code,
                                                                const char* msg);
-#endif  // NAPI_EXPERIMENTAL
+#endif  // NAPI_VERSION >= 9
 NAPI_EXTERN napi_status NAPI_CDECL napi_is_error(napi_env env,
                                                  napi_value value,
                                                  bool* result);
@@ -401,13 +432,15 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_create_arraybuffer(napi_env env,
                                                            size_t byte_length,
                                                            void** data,
                                                            napi_value* result);
+#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
 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
 NAPI_EXTERN napi_status NAPI_CDECL napi_get_arraybuffer_info(
     napi_env env, napi_value arraybuffer, void** data, size_t* byte_length);
 NAPI_EXTERN napi_status NAPI_CDECL napi_is_typedarray(napi_env env,
@@ -446,7 +479,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
@@ -470,7 +503,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
 
@@ -488,15 +521,27 @@ 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* native_object,
-                                                      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
 
+#ifdef NAPI_EXPERIMENTAL
+#define NODE_API_EXPERIMENTAL_HAS_POST_FINALIZER
+
+NAPI_EXTERN napi_status NAPI_CDECL
+node_api_post_finalizer(node_api_basic_env env,
+                        napi_finalize finalize_cb,
+                        void* finalize_data,
+                        void* finalize_hint);
+
+#endif  // NAPI_EXPERIMENTAL
+
 #if NAPI_VERSION >= 6
 
 // BigInt
@@ -534,11 +579,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/src/headers/{18 → 22}/js_native_api_types.h

@@ -22,6 +22,37 @@ 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.
+#if !defined(NAPI_EXPERIMENTAL) ||                                             \
+    (defined(NAPI_EXPERIMENTAL) &&                                             \
+     (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) ||                       \
+      defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT)))
+typedef struct napi_env__* node_api_nogc_env;
+#else
+typedef const struct napi_env__* node_api_nogc_env;
+#endif
+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;
@@ -98,7 +129,9 @@ typedef enum {
   napi_date_expected,
   napi_arraybuffer_expected,
   napi_detachable_arraybuffer_expected,
-  napi_would_deadlock  // unused
+  napi_would_deadlock,  // unused
+  napi_no_external_buffers_allowed,
+  napi_cannot_run_js,
 } napi_status;
 // Note: when adding a new enum value to `napi_status`, please also update
 //   * `const int last_status` in the definition of `napi_get_last_error_info()'
@@ -114,6 +147,18 @@ typedef void(NAPI_CDECL* napi_finalize)(napi_env env,
                                         void* finalize_data,
                                         void* finalize_hint);
 
+#if !defined(NAPI_EXPERIMENTAL) ||                                             \
+    (defined(NAPI_EXPERIMENTAL) &&                                             \
+     (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) ||                       \
+      defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT)))
+typedef napi_finalize node_api_nogc_finalize;
+#else
+typedef void(NAPI_CDECL* node_api_nogc_finalize)(node_api_nogc_env env,
+                                                 void* finalize_data,
+                                                 void* finalize_hint);
+#endif
+typedef node_api_nogc_finalize node_api_basic_finalize;
+
 typedef struct {
   // One of utf8name or name should be NULL.
   const char* utf8name;