@encharm/cws 4.4.1 → 4.5.2

package/src/headers/{16 → 24}/node_mem-inl.h

@@ -54,19 +54,19 @@ void* NgLibMemoryManager<Class, T>::ReallocImpl(void* ptr,
   if (mem != nullptr) {
     // Adjust the memory info counter.
     // TODO(addaleax): Avoid the double bookkeeping we do with
-    // current_nghttp2_memory_ + AdjustAmountOfExternalAllocatedMemory
+    // current_nghttp2_memory_ + ExternalMemoryAccounter
     // and provide versions of our memory allocation utilities that take an
     // Environment*/Isolate* parameter and call the V8 method transparently.
     const int64_t new_size = size - previous_size;
     manager->IncreaseAllocatedSize(new_size);
-    manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory(
-        new_size);
+    manager->env()->external_memory_accounter()->Increase(
+        manager->env()->isolate(), new_size);
     *reinterpret_cast<size_t*>(mem) = size;
     mem += sizeof(size_t);
   } else if (size == 0) {
     manager->DecreaseAllocatedSize(previous_size);
-    manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory(
-        -static_cast<int64_t>(previous_size));
+    manager->env()->external_memory_accounter()->Decrease(
+        manager->env()->isolate(), previous_size);
   }
   return mem;
 }
@@ -99,8 +99,8 @@ void NgLibMemoryManager<Class, T>::StopTrackingMemory(void* ptr) {
       static_cast<char*>(ptr) - sizeof(size_t));
   Class* manager = static_cast<Class*>(this);
   manager->DecreaseAllocatedSize(*original_ptr);
-  manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory(
-      -static_cast<int64_t>(*original_ptr));
+  manager->env()->external_memory_accounter()->Decrease(
+      manager->env()->isolate(), *original_ptr);
   *original_ptr = 0;
 }
 

package/src/headers/{16 → 24}/node_messaging.h

@@ -88,6 +88,9 @@ class Message : public MemoryRetainer {
   // Internal method of Message that is called when a new WebAssembly.Module
   // object is encountered in the incoming value's structure.
   uint32_t AddWASMModule(v8::CompiledWasmModule&& mod);
+  // Internal method of Message that is called when a shared value is
+  // encountered for the first time in the incoming value's structure.
+  void AdoptSharedValueConveyor(v8::SharedValueConveyor&& conveyor);
 
   // The host objects that will be transferred, as recorded by Serialize()
   // (e.g. MessagePorts).
@@ -114,6 +117,7 @@ class Message : public MemoryRetainer {
   std::vector<std::shared_ptr<v8::BackingStore>> shared_array_buffers_;
   std::vector<std::unique_ptr<TransferData>> transferables_;
   std::vector<v8::CompiledWasmModule> wasm_modules_;
+  std::optional<v8::SharedValueConveyor> shared_value_conveyor_;
 
   friend class MessagePort;
 };
@@ -257,7 +261,6 @@ class MessagePort : public HandleWrap {
   static void PostMessage(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void CheckType(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Drain(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void ReceiveMessage(const v8::FunctionCallbackInfo<v8::Value>& args);
 
@@ -286,7 +289,7 @@ class MessagePort : public HandleWrap {
   // NULL pointer to the C++ MessagePort object is also detached.
   inline bool IsDetached() const;
 
-  TransferMode GetTransferMode() const override;
+  BaseObject::TransferMode GetTransferMode() const override;
   std::unique_ptr<TransferData> TransferForMessaging() override;
 
   void MemoryInfo(MemoryTracker* tracker) const override;
@@ -315,20 +318,28 @@ class MessagePort : public HandleWrap {
   friend class MessagePortData;
 };
 
-// Provide a base class from which JS classes that should be transferable or
-// cloneable by postMesssage() can inherit.
+// Provide a wrapper class created when a built-in JS classes that being
+// transferable or cloneable by postMessage().
 // See e.g. FileHandle in internal/fs/promises.js for an example.
 class JSTransferable : public BaseObject {
  public:
-  JSTransferable(Environment* env, v8::Local<v8::Object> obj);
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  TransferMode GetTransferMode() const override;
+  static BaseObjectPtr<JSTransferable> Wrap(Environment* env,
+                                            v8::Local<v8::Object> target);
+  static bool IsJSTransferable(Environment* env,
+                               v8::Local<v8::Context> context,
+                               v8::Local<v8::Object> object);
+
+  JSTransferable(Environment* env,
+                 v8::Local<v8::Object> obj,
+                 v8::Local<v8::Object> target);
+  ~JSTransferable();
+
+  BaseObject::TransferMode GetTransferMode() const override;
   std::unique_ptr<TransferData> TransferForMessaging() override;
   std::unique_ptr<TransferData> CloneForMessaging() const override;
   v8::Maybe<std::vector<BaseObjectPtr<BaseObject>>>
       NestedTransferables() const override;
-  v8::Maybe<bool> FinalizeTransferRead(
+  v8::Maybe<void> FinalizeTransferRead(
       v8::Local<v8::Context> context,
       v8::ValueDeserializer* deserializer) override;
 
@@ -336,8 +347,13 @@ class JSTransferable : public BaseObject {
   SET_MEMORY_INFO_NAME(JSTransferable)
   SET_SELF_SIZE(JSTransferable)
 
+  v8::Local<v8::Object> target() const;
+
  private:
-  std::unique_ptr<TransferData> TransferOrClone(TransferMode mode) const;
+  template <TransferMode mode>
+  std::unique_ptr<TransferData> TransferOrClone() const;
+
+  v8::Global<v8::Object> target_;
 
   class Data : public TransferData {
    public:
@@ -362,7 +378,7 @@ class JSTransferable : public BaseObject {
 };
 
 v8::Local<v8::FunctionTemplate> GetMessagePortConstructorTemplate(
-    Environment* env);
+    IsolateData* isolate_data);
 
 }  // namespace worker
 }  // namespace node

package/src/headers/{16 → 24}/node_metadata.h

@@ -3,11 +3,16 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include <array>
 #include <string>
+#include <utility>
 #include "node_version.h"
 
 #if HAVE_OPENSSL
 #include <openssl/crypto.h>
+#if NODE_OPENSSL_HAS_QUIC
+#include <openssl/quic.h>
+#endif
 #endif  // HAVE_OPENSSL
 
 namespace node {
@@ -24,20 +29,42 @@ namespace node {
 #define NODE_HAS_RELEASE_URLS
 #endif
 
+#if HAVE_AMARO && !defined(NODE_SHARED_BUILTIN_AMARO_DIST_INDEX_PATH)
+#define NODE_VERSIONS_KEY_AMARO(V) V(amaro)
+#else
+#define NODE_VERSIONS_KEY_AMARO(V)
+#endif
+
+#ifndef NODE_SHARED_BUILTIN_UNDICI_UNDICI_PATH
+#define NODE_VERSIONS_KEY_UNDICI(V) V(undici)
+#else
+#define NODE_VERSIONS_KEY_UNDICI(V)
+#endif
+
 #define NODE_VERSIONS_KEYS_BASE(V)                                             \
   V(node)                                                                      \
   V(v8)                                                                        \
   V(uv)                                                                        \
   V(zlib)                                                                      \
   V(brotli)                                                                    \
+  V(zstd)                                                                      \
   V(ares)                                                                      \
   V(modules)                                                                   \
   V(nghttp2)                                                                   \
   V(napi)                                                                      \
   V(llhttp)                                                                    \
+  V(uvwasi)                                                                    \
+  V(acorn)                                                                     \
+  V(simdjson)                                                                  \
+  V(simdutf)                                                                   \
+  V(ada)                                                                       \
+  V(nbytes)                                                                    \
+  NODE_VERSIONS_KEY_AMARO(V)                                                   \
+  NODE_VERSIONS_KEY_UNDICI(V)                                                  \
+  V(cjs_module_lexer)
 
 #if HAVE_OPENSSL
-#define NODE_VERSIONS_KEY_CRYPTO(V) V(openssl)
+#define NODE_VERSIONS_KEY_CRYPTO(V) V(openssl) V(ncrypto)
 #else
 #define NODE_VERSIONS_KEY_CRYPTO(V)
 #endif
@@ -60,11 +87,22 @@ namespace node {
 #define NODE_VERSIONS_KEY_QUIC(V)
 #endif
 
+#if HAVE_SQLITE
+#define NODE_VERSIONS_KEY_SQLITE(V) V(sqlite)
+#else
+#define NODE_VERSIONS_KEY_SQLITE(V)
+#endif
+
 #define NODE_VERSIONS_KEYS(V)                                                  \
   NODE_VERSIONS_KEYS_BASE(V)                                                   \
   NODE_VERSIONS_KEY_CRYPTO(V)                                                  \
   NODE_VERSIONS_KEY_INTL(V)                                                    \
-  NODE_VERSIONS_KEY_QUIC(V)
+  NODE_VERSIONS_KEY_QUIC(V)                                                    \
+  NODE_VERSIONS_KEY_SQLITE(V)
+
+#define V(key) +1
+constexpr int NODE_VERSIONS_KEY_COUNT = NODE_VERSIONS_KEYS(V);
+#undef V
 
 class Metadata {
  public:
@@ -86,6 +124,10 @@ class Metadata {
 #define V(key) std::string key;
     NODE_VERSIONS_KEYS(V)
 #undef V
+
+    std::array<std::pair<std::string_view, std::string_view>,
+               NODE_VERSIONS_KEY_COUNT>
+    pairs() const;
   };
 
   struct Release {

package/src/headers/24/node_modules.h

@@ -0,0 +1,93 @@
+#ifndef SRC_NODE_MODULES_H_
+#define SRC_NODE_MODULES_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node.h"
+#include "node_snapshotable.h"
+#include "simdjson.h"
+#include "util.h"
+#include "v8-fast-api-calls.h"
+#include "v8.h"
+
+#include <filesystem>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace modules {
+
+class BindingData : public SnapshotableObject {
+ public:
+  using InternalFieldInfo = InternalFieldInfoBase;
+
+  struct PackageConfig {
+    std::string file_path;
+    std::optional<std::string> name;
+    std::optional<std::string> main;
+    std::string type = "none";
+    std::optional<std::string> exports;
+    std::optional<std::string> imports;
+    std::optional<std::string> scripts;
+    std::string raw_json;
+
+    v8::Local<v8::Array> Serialize(Realm* realm) const;
+  };
+
+  struct ErrorContext {
+    std::optional<std::string> base;
+    std::string specifier;
+    bool is_esm;
+  };
+
+  BindingData(Realm* realm,
+              v8::Local<v8::Object> obj,
+              InternalFieldInfo* info = nullptr);
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(modules_binding_data)
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+  static void ReadPackageJSON(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetNearestParentPackageJSON(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetNearestParentPackageJSONType(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  template <bool return_only_type>
+  static void GetPackageScopeConfig(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPackageJSONScripts(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> ctor);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+ private:
+  std::unordered_map<std::string, PackageConfig> package_configs_;
+  simdjson::ondemand::parser json_parser;
+  // returns null on error
+  static const PackageConfig* GetPackageJSON(
+      Realm* realm,
+      std::string_view path,
+      ErrorContext* error_context = nullptr);
+  static const PackageConfig* TraverseParent(
+      Realm* realm, const std::filesystem::path& check_path);
+};
+
+}  // namespace modules
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_MODULES_H_

package/src/headers/{16 → 24}/node_options-inl.h

@@ -3,7 +3,9 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include <algorithm>
 #include <cstdlib>
+#include <ranges>
 #include "node_options.h"
 #include "util.h"
 
@@ -17,103 +19,140 @@ EnvironmentOptions* PerIsolateOptions::get_per_env_options() {
   return per_env.get();
 }
 
+std::shared_ptr<PerIsolateOptions> PerIsolateOptions::Clone() const {
+  auto options =
+      std::shared_ptr<PerIsolateOptions>(new PerIsolateOptions(*this));
+  options->per_env = std::make_shared<EnvironmentOptions>(*per_env);
+  return options;
+}
+
 namespace options_parser {
 
 template <typename Options>
 void OptionsParser<Options>::AddOption(const char* name,
                                        const char* help_text,
-                                       bool Options::* field,
+                                       bool Options::*field,
                                        OptionEnvvarSettings env_setting,
-                                       bool default_is_true) {
+                                       bool default_is_true,
+                                       OptionNamespaces namespace_id) {
   options_.emplace(name,
                    OptionInfo{kBoolean,
                               std::make_shared<SimpleOptionField<bool>>(field),
                               env_setting,
                               help_text,
-                              default_is_true});
+                              default_is_true,
+                              NamespaceEnumToString(namespace_id)});
 }
 
 template <typename Options>
 void OptionsParser<Options>::AddOption(const char* name,
                                        const char* help_text,
-                                       uint64_t Options::* field,
-                                       OptionEnvvarSettings env_setting) {
+                                       uint64_t Options::*field,
+                                       OptionEnvvarSettings env_setting,
+                                       OptionNamespaces namespace_id) {
   options_.emplace(
       name,
       OptionInfo{kUInteger,
                  std::make_shared<SimpleOptionField<uint64_t>>(field),
                  env_setting,
-                 help_text});
+                 help_text,
+                 false,
+                 NamespaceEnumToString(namespace_id)});
 }
 
 template <typename Options>
 void OptionsParser<Options>::AddOption(const char* name,
                                        const char* help_text,
-                                       int64_t Options::* field,
-                                       OptionEnvvarSettings env_setting) {
+                                       int64_t Options::*field,
+                                       OptionEnvvarSettings env_setting,
+                                       OptionNamespaces namespace_id) {
   options_.emplace(
       name,
       OptionInfo{kInteger,
                  std::make_shared<SimpleOptionField<int64_t>>(field),
                  env_setting,
-                 help_text});
+                 help_text,
+                 false,
+                 NamespaceEnumToString(namespace_id)});
 }
 
 template <typename Options>
 void OptionsParser<Options>::AddOption(const char* name,
                                        const char* help_text,
-                                       std::string Options::* field,
-                                       OptionEnvvarSettings env_setting) {
+                                       std::string Options::*field,
+                                       OptionEnvvarSettings env_setting,
+                                       OptionNamespaces namespace_id) {
   options_.emplace(
       name,
       OptionInfo{kString,
                  std::make_shared<SimpleOptionField<std::string>>(field),
                  env_setting,
-                 help_text});
+                 help_text,
+                 false,
+                 NamespaceEnumToString(namespace_id)});
 }
 
 template <typename Options>
-void OptionsParser<Options>::AddOption(
-    const char* name,
-    const char* help_text,
-    std::vector<std::string> Options::* field,
-    OptionEnvvarSettings env_setting) {
-  options_.emplace(name, OptionInfo {
-    kStringList,
-    std::make_shared<SimpleOptionField<std::vector<std::string>>>(field),
-    env_setting,
-    help_text
-  });
+void OptionsParser<Options>::AddOption(const char* name,
+                                       const char* help_text,
+                                       std::vector<std::string> Options::*field,
+                                       OptionEnvvarSettings env_setting,
+                                       OptionNamespaces namespace_id) {
+  options_.emplace(
+      name,
+      OptionInfo{
+          kStringList,
+          std::make_shared<SimpleOptionField<std::vector<std::string>>>(field),
+          env_setting,
+          help_text,
+          false,
+          NamespaceEnumToString(namespace_id)});
 }
 
 template <typename Options>
 void OptionsParser<Options>::AddOption(const char* name,
                                        const char* help_text,
-                                       HostPort Options::* field,
-                                       OptionEnvvarSettings env_setting) {
+                                       HostPort Options::*field,
+                                       OptionEnvvarSettings env_setting,
+                                       OptionNamespaces namespace_id) {
   options_.emplace(
       name,
       OptionInfo{kHostPort,
                  std::make_shared<SimpleOptionField<HostPort>>(field),
                  env_setting,
-                 help_text});
+                 help_text,
+                 false,
+                 NamespaceEnumToString(namespace_id)});
 }
 
 template <typename Options>
 void OptionsParser<Options>::AddOption(const char* name,
                                        const char* help_text,
                                        NoOp no_op_tag,
-                                       OptionEnvvarSettings env_setting) {
-  options_.emplace(name, OptionInfo{kNoOp, nullptr, env_setting, help_text});
+                                       OptionEnvvarSettings env_setting,
+                                       OptionNamespaces namespace_id) {
+  options_.emplace(name,
+                   OptionInfo{kNoOp,
+                              nullptr,
+                              env_setting,
+                              help_text,
+                              false,
+                              NamespaceEnumToString(namespace_id)});
 }
 
 template <typename Options>
 void OptionsParser<Options>::AddOption(const char* name,
                                        const char* help_text,
                                        V8Option v8_option_tag,
-                                       OptionEnvvarSettings env_setting) {
+                                       OptionEnvvarSettings env_setting,
+                                       OptionNamespaces namespace_id) {
   options_.emplace(name,
-                   OptionInfo{kV8Option, nullptr, env_setting, help_text});
+                   OptionInfo{kV8Option,
+                              nullptr,
+                              env_setting,
+                              help_text,
+                              false,
+                              NamespaceEnumToString(namespace_id)});
 }
 
 template <typename Options>
@@ -189,7 +228,8 @@ auto OptionsParser<Options>::Convert(
                     Convert(original.field, get_child),
                     original.env_setting,
                     original.help_text,
-                    original.default_is_true};
+                    original.default_is_true,
+                    original.namespace_id};
 }
 
 template <typename Options>
@@ -302,7 +342,7 @@ void OptionsParser<Options>::Parse(
     const std::string arg = args.pop_first();
 
     if (arg == "--") {
-      if (required_env_settings == kAllowedInEnvironment)
+      if (required_env_settings == kAllowedInEnvvar)
         errors->push_back(NotAllowedInEnvErr("--"));
       break;
     }
@@ -374,8 +414,8 @@ void OptionsParser<Options>::Parse(
     auto it = options_.find(name);
 
     if ((it == options_.end() ||
-         it->second.env_setting == kDisallowedInEnvironment) &&
-        required_env_settings == kAllowedInEnvironment) {
+         it->second.env_setting == kDisallowedInEnvvar) &&
+        required_env_settings == kAllowedInEnvvar) {
       errors->push_back(NotAllowedInEnvErr(original_name));
       break;
     }
@@ -386,15 +426,16 @@ void OptionsParser<Options>::Parse(
         // Implications for negated options are defined with "--no-".
         implied_name.insert(2, "no-");
       }
-      auto implications = implications_.equal_range(implied_name);
-      for (auto it = implications.first; it != implications.second; ++it) {
-        if (it->second.type == kV8Option) {
-          v8_args->push_back(it->second.name);
-        } else {
-          *it->second.target_field->template Lookup<bool>(options) =
-              it->second.target_value;
-        }
-      }
+      auto [f, l] = implications_.equal_range(implied_name);
+      std::ranges::for_each(std::ranges::subrange(f, l) | std::views::values,
+                            [&](const auto& value) {
+                              if (value.type == kV8Option) {
+                                v8_args->push_back(value.name);
+                              } else {
+                                *value.target_field->template Lookup<bool>(
+                                    options) = value.target_value;
+                              }
+                            });
     }
 
     if (it == options_.end()) {
@@ -440,11 +481,17 @@ void OptionsParser<Options>::Parse(
       case kBoolean:
         *Lookup<bool>(info.field, options) = !is_negation;
         break;
-      case kInteger:
+      case kInteger: {
+        // Special case to pass --stack-trace-limit down to V8.
+        if (name == "--stack-trace-limit") {
+          v8_args->push_back(arg);
+        }
         *Lookup<int64_t>(info.field, options) = std::atoll(value.c_str());
         break;
+      }
       case kUInteger:
-        *Lookup<uint64_t>(info.field, options) = std::stoull(value);
+        *Lookup<uint64_t>(info.field, options) =
+            std::strtoull(value.c_str(), nullptr, 10);
         break;
       case kString:
         *Lookup<std::string>(info.field, options) = value;
@@ -466,7 +513,7 @@ void OptionsParser<Options>::Parse(
         UNREACHABLE();
     }
   }
-  options->CheckOptions(errors);
+  options->CheckOptions(errors, orig_args);
 }
 
 }  // namespace options_parser