@encharm/cws 4.4.1 → 4.5.2

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

@@ -11,6 +11,10 @@
 #include "node_mutex.h"
 #include "util.h"
 
+#if HAVE_OPENSSL
+#include "openssl/opensslv.h"
+#endif
+
 namespace node {
 
 class HostPort {
@@ -24,29 +28,26 @@ class HostPort {
 
   void set_host(const std::string& host) { host_name_ = host; }
 
-  void set_port(int port) { port_ = port; }
+  void set_port(uint16_t port) { port_ = port; }
 
   const std::string& host() const { return host_name_; }
 
-  int port() const {
-    // TODO(joyeecheung): make port a uint16_t
-    CHECK_GE(port_, 0);
-    return port_;
-  }
+  uint16_t port() const { return port_; }
 
   void Update(const HostPort& other) {
     if (!other.host_name_.empty()) host_name_ = other.host_name_;
-    if (other.port_ >= 0) port_ = other.port_;
+    port_ = other.port_;
   }
 
  private:
   std::string host_name_;
-  int port_;
+  uint16_t port_;
 };
 
 class Options {
  public:
-  virtual void CheckOptions(std::vector<std::string>* errors) {}
+  virtual void CheckOptions(std::vector<std::string>* errors,
+                            std::vector<std::string>* argv) {}
   virtual ~Options() = default;
 };
 
@@ -67,8 +68,11 @@ class DebugOptions : public Options {
   DebugOptions(DebugOptions&&) = default;
   DebugOptions& operator=(DebugOptions&&) = default;
 
+  bool allow_attaching_debugger = true;
   // --inspect
   bool inspector_enabled = false;
+  // --inspect-wait
+  bool inspect_wait = false;
   // --debug
   bool deprecated_debug = false;
   // --inspect-brk
@@ -90,40 +94,72 @@ class DebugOptions : public Options {
     break_first_line = true;
   }
 
+  void DisableWaitOrBreakFirstLine() {
+    inspect_wait = false;
+    break_first_line = false;
+  }
+
   bool wait_for_connect() const {
+    return break_first_line || break_node_first_line || inspect_wait;
+  }
+
+  bool should_break_first_line() const {
     return break_first_line || break_node_first_line;
   }
 
-  void CheckOptions(std::vector<std::string>* errors) override;
+  void CheckOptions(std::vector<std::string>* errors,
+                    std::vector<std::string>* argv) override;
 };
 
 class EnvironmentOptions : public Options {
  public:
   bool abort_on_uncaught_exception = false;
   std::vector<std::string> conditions;
+  bool detect_module = true;
+  bool disable_sigusr1 = false;
+  bool print_required_tla = false;
+  bool require_module = true;
   std::string dns_result_order;
   bool enable_source_maps = false;
-  bool experimental_json_modules = false;
-  bool experimental_modules = false;
-  std::string experimental_specifier_resolution;
-  bool experimental_wasm_modules = false;
+  bool experimental_addon_modules = false;
+  bool experimental_eventsource = false;
+  bool experimental_fetch = true;
+  bool experimental_websocket = true;
+  bool experimental_sqlite = true;
+  bool experimental_webstorage = false;
+#ifdef NODE_OPENSSL_HAS_QUIC
+  bool experimental_quic = false;
+#endif
+  std::string localstorage_file;
+  bool experimental_global_navigator = true;
+  bool experimental_global_web_crypto = true;
   bool experimental_import_meta_resolve = false;
-  std::string module_type;
-  std::string experimental_policy;
-  std::string experimental_policy_integrity;
-  bool has_policy_integrity_string;
+  std::string input_type;  // Value of --input-type
+  bool entry_is_url = false;
+  bool permission = false;
+  std::vector<std::string> allow_fs_read;
+  std::vector<std::string> allow_fs_write;
+  bool allow_addons = false;
+  bool allow_child_process = false;
+  bool allow_wasi = false;
+  bool allow_worker_threads = false;
   bool experimental_repl_await = true;
   bool experimental_vm_modules = false;
+  bool async_context_frame = true;
   bool expose_internals = false;
+  bool force_node_api_uncaught_exceptions_policy = false;
   bool frozen_intrinsics = false;
   int64_t heap_snapshot_near_heap_limit = 0;
   std::string heap_snapshot_signal;
+  bool network_family_autoselection = true;
+  uint64_t network_family_autoselection_attempt_timeout = 250;
   uint64_t max_http_header_size = 16 * 1024;
   bool deprecation = true;
   bool force_async_hooks_checks = true;
   bool allow_native_addons = true;
   bool global_search_paths = true;
   bool warnings = true;
+  std::vector<std::string> disable_warnings;
   bool force_context_aware = false;
   bool pending_deprecation = false;
   bool preserve_symlinks = false;
@@ -135,6 +171,9 @@ class EnvironmentOptions : public Options {
   uint64_t cpu_prof_interval = kDefaultCpuProfInterval;
   std::string cpu_prof_name;
   bool cpu_prof = false;
+  bool experimental_network_inspection = false;
+  bool experimental_worker_inspection = false;
+  bool experimental_inspector_network_resource = false;
   std::string heap_prof_dir;
   std::string heap_prof_name;
   static const uint64_t kDefaultHeapProfInterval = 512 * 1024;
@@ -143,17 +182,46 @@ class EnvironmentOptions : public Options {
 #endif  // HAVE_INSPECTOR
   std::string redirect_warnings;
   std::string diagnostic_dir;
+  std::string env_file;
+  std::string optional_env_file;
+  bool has_env_file_string = false;
+  bool test_runner = false;
+  uint64_t test_runner_concurrency = 0;
+  uint64_t test_runner_timeout = 0;
+  bool test_runner_coverage = false;
+  bool test_runner_force_exit = false;
+  uint64_t test_coverage_branches = 0;
+  uint64_t test_coverage_functions = 0;
+  uint64_t test_coverage_lines = 0;
+  bool test_runner_module_mocks = false;
+  bool test_runner_update_snapshots = false;
+  std::vector<std::string> test_name_pattern;
+  std::vector<std::string> test_reporter;
+  std::string test_rerun_failures_path;
+  std::vector<std::string> test_reporter_destination;
+  std::string test_global_setup_path;
+  bool test_only = false;
   bool test_udp_no_try_send = false;
+  std::string test_isolation = "process";
+  std::string test_shard;
+  std::vector<std::string> test_skip_pattern;
+  std::vector<std::string> coverage_include_pattern;
+  std::vector<std::string> coverage_exclude_pattern;
   bool throw_deprecation = false;
-  bool trace_atomics_wait = false;
   bool trace_deprecation = false;
   bool trace_exit = false;
   bool trace_sync_io = false;
   bool trace_tls = false;
   bool trace_uncaught = false;
   bool trace_warnings = false;
+  bool trace_promises = false;
+  bool trace_env = false;
+  bool trace_env_js_stack = false;
+  bool trace_env_native_stack = false;
+  std::string trace_require_module;
+  bool extra_info_on_fatal_exception = true;
   std::string unhandled_rejections;
-  std::string userland_loader;
+  std::vector<std::string> userland_loaders;
   bool verify_base_objects =
 #ifdef DEBUG
       true;
@@ -161,14 +229,20 @@ class EnvironmentOptions : public Options {
       false;
 #endif  // DEBUG
 
+  bool watch_mode = false;
+  bool watch_mode_report_to_parent = false;
+  bool watch_mode_preserve_output = false;
+  std::string watch_mode_kill_signal = "SIGTERM";
+  std::vector<std::string> watch_mode_paths;
+
   bool syntax_check_only = false;
   bool has_eval_string = false;
-  bool experimental_wasi = false;
   std::string eval_string;
   bool print_eval = false;
   bool force_repl = false;
 
   bool insecure_http_parser = false;
+  bool use_env_proxy = false;
 
   bool tls_min_v1_0 = false;
   bool tls_min_v1_1 = false;
@@ -178,14 +252,25 @@ class EnvironmentOptions : public Options {
   bool tls_max_v1_3 = false;
   std::string tls_keylog;
 
-  std::vector<std::string> preload_modules;
+  std::vector<std::string> preload_cjs_modules;
+
+  std::vector<std::string> preload_esm_modules;
+
+  bool experimental_strip_types = true;
+  bool experimental_transform_types = false;
 
   std::vector<std::string> user_argv;
 
+  bool report_exclude_env = false;
+  bool report_exclude_network = false;
+  std::string experimental_config_file_path;
+  bool experimental_default_config_file = false;
+
   inline DebugOptions* get_debug_options() { return &debug_options_; }
   inline const DebugOptions& debug_options() const { return debug_options_; }
 
-  void CheckOptions(std::vector<std::string>* errors) override;
+  void CheckOptions(std::vector<std::string>* errors,
+                    std::vector<std::string>* argv) override;
 
  private:
   DebugOptions debug_options_;
@@ -193,15 +278,30 @@ class EnvironmentOptions : public Options {
 
 class PerIsolateOptions : public Options {
  public:
+  PerIsolateOptions() = default;
+  PerIsolateOptions(PerIsolateOptions&&) = default;
+
   std::shared_ptr<EnvironmentOptions> per_env { new EnvironmentOptions() };
   bool track_heap_objects = false;
-  bool node_snapshot = true;
   bool report_uncaught_exception = false;
   bool report_on_signal = false;
-  bool experimental_top_level_await = true;
+  bool experimental_shadow_realm = false;
+  std::string max_old_space_size_percentage;
+  std::string max_old_space_size;
+  int64_t stack_trace_limit = 10;
   std::string report_signal = "SIGUSR2";
+  bool build_snapshot = false;
+  std::string build_snapshot_config;
   inline EnvironmentOptions* get_per_env_options();
-  void CheckOptions(std::vector<std::string>* errors) override;
+  void CheckOptions(std::vector<std::string>* errors,
+                    std::vector<std::string>* argv) override;
+  void HandleMaxOldSpaceSizePercentage(std::vector<std::string>* errors,
+                                       std::string* max_old_space_size);
+
+  inline std::shared_ptr<PerIsolateOptions> Clone() const;
+
+ private:
+  PerIsolateOptions(const PerIsolateOptions&) = default;
 };
 
 class PerProcessOptions : public Options {
@@ -223,12 +323,19 @@ class PerProcessOptions : public Options {
   bool zero_fill_all_buffers = false;
   bool debug_arraybuffer_allocations = false;
   std::string disable_proto;
+  // We enable the shared read-only heap which currently requires that the
+  // snapshot used in different isolates in the same process to be the same.
+  // Therefore --node-snapshot is a per-process option.
+  bool node_snapshot = true;
+  std::string snapshot_blob;
 
   std::vector<std::string> security_reverts;
   bool print_bash_completion = false;
   bool print_help = false;
   bool print_v8_help = false;
   bool print_version = false;
+  std::string experimental_sea_config;
+  std::string run;
 
 #ifdef NODE_HAVE_I18N_SUPPORT
   std::string icu_data_dir;
@@ -247,10 +354,17 @@ class PerProcessOptions : public Options {
   bool ssl_openssl_cert_store = false;
 #endif
   bool use_openssl_ca = false;
+  bool use_system_ca = false;
   bool use_bundled_ca = false;
   bool enable_fips_crypto = false;
   bool force_fips_crypto = false;
 #endif
+#if OPENSSL_VERSION_MAJOR >= 3
+  bool openssl_legacy_provider = false;
+  bool openssl_shared_config = false;
+#endif
+
+  bool disable_wasm_trap_handler = false;
 
   // Per-process because reports can be triggered outside a known V8 context.
   bool report_on_fatalerror = false;
@@ -264,7 +378,8 @@ class PerProcessOptions : public Options {
   std::vector<std::string> cmdline;
 
   inline PerIsolateOptions* get_per_isolate_options();
-  void CheckOptions(std::vector<std::string>* errors) override;
+  void CheckOptions(std::vector<std::string>* errors,
+                    std::vector<std::string>* argv) override;
 };
 
 // The actual options parser, as opposed to the structs containing them:
@@ -272,7 +387,7 @@ class PerProcessOptions : public Options {
 namespace options_parser {
 
 HostPort SplitHostPort(const std::string& arg,
-    std::vector<std::string>* errors);
+                       std::vector<std::string>* errors);
 void GetOptions(const v8::FunctionCallbackInfo<v8::Value>& args);
 std::string GetBashCompletion();
 
@@ -286,6 +401,44 @@ enum OptionType {
   kHostPort,
   kStringList,
 };
+std::unordered_map<std::string, OptionType> MapEnvOptionsFlagInputType();
+std::unordered_map<std::string, OptionType> MapOptionsByNamespace(
+    std::string namespace_name);
+std::unordered_map<std::string,
+                   std::unordered_map<std::string, options_parser::OptionType>>
+MapNamespaceOptionsAssociations();
+std::vector<std::string> MapAvailableNamespaces();
+
+// Define all namespace entries
+#define OPTION_NAMESPACE_LIST(V)                                               \
+  V(kNoNamespace, "")                                                          \
+  V(kTestRunnerNamespace, "testRunner")
+
+enum class OptionNamespaces {
+#define V(name, _) name,
+  OPTION_NAMESPACE_LIST(V)
+#undef V
+};
+
+inline const std::string NamespaceEnumToString(OptionNamespaces ns) {
+  switch (ns) {
+#define V(name, string_value)                                                  \
+  case OptionNamespaces::name:                                                 \
+    return string_value;
+    OPTION_NAMESPACE_LIST(V)
+#undef V
+    default:
+      return "";
+  }
+}
+
+inline constexpr auto AllNamespaces() {
+  return std::array{
+#define V(name, _) OptionNamespaces::name,
+      OPTION_NAMESPACE_LIST(V)
+#undef V
+  };
+}
 
 template <typename Options>
 class OptionsParser {
@@ -300,39 +453,59 @@ class OptionsParser {
   // These methods add a single option to the parser. Optionally, it can be
   // specified whether the option should be allowed from environment variable
   // sources (i.e. NODE_OPTIONS).
-  void AddOption(const char* name,
-                 const char* help_text,
-                 bool Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment,
-                 bool default_is_true = false);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 uint64_t Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 int64_t Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 std::string Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 std::vector<std::string> Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 HostPort Options::* field,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 NoOp no_op_tag,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
-  void AddOption(const char* name,
-                 const char* help_text,
-                 V8Option v8_option_tag,
-                 OptionEnvvarSettings env_setting = kDisallowedInEnvironment);
+
+  // default_is_true is only a hint in printing help text, it does not
+  // affect the default value of the option. Set the default value in the
+  // Options struct instead.
+  void AddOption(
+      const char* name,
+      const char* help_text,
+      bool Options::*field,
+      OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
+      bool default_is_true = false,
+      OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace);
+  void AddOption(
+      const char* name,
+      const char* help_text,
+      uint64_t Options::*field,
+      OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
+      OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace);
+  void AddOption(
+      const char* name,
+      const char* help_text,
+      int64_t Options::*field,
+      OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
+      OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace);
+  void AddOption(
+      const char* name,
+      const char* help_text,
+      std::string Options::*field,
+      OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
+      OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace);
+  void AddOption(
+      const char* name,
+      const char* help_text,
+      std::vector<std::string> Options::*field,
+      OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
+      OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace);
+  void AddOption(
+      const char* name,
+      const char* help_text,
+      HostPort Options::*field,
+      OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
+      OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace);
+  void AddOption(
+      const char* name,
+      const char* help_text,
+      NoOp no_op_tag,
+      OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
+      OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace);
+  void AddOption(
+      const char* name,
+      const char* help_text,
+      V8Option v8_option_tag,
+      OptionEnvvarSettings env_setting = kDisallowedInEnvvar,
+      OptionNamespaces namespace_id = OptionNamespaces::kNoNamespace);
 
   // Adds aliases. An alias can be of the form "--option-a" -> "--option-b",
   // or have a more complex group expansion, like
@@ -422,12 +595,15 @@ class OptionsParser {
   // - A type.
   // - A way to store/access the property value.
   // - The information of whether it may occur in an env var or not.
+  // - A default value (if applicable).
+  // - A namespace ID (optional) to allow for namespacing of options.
   struct OptionInfo {
     OptionType type;
     std::shared_ptr<BaseOptionField> field;
     OptionEnvvarSettings env_setting;
     std::string help_text;
     bool default_is_true = false;
+    std::string namespace_id;
   };
 
   // An implied option is composed of the information on where to store a
@@ -461,8 +637,20 @@ class OptionsParser {
   template <typename OtherOptions>
   friend class OptionsParser;
 
-  friend void GetOptions(const v8::FunctionCallbackInfo<v8::Value>& args);
+  friend void GetCLIOptionsValues(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  friend void GetCLIOptionsInfo(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
   friend std::string GetBashCompletion();
+  friend std::unordered_map<std::string, OptionType>
+  MapEnvOptionsFlagInputType();
+  friend std::unordered_map<std::string, OptionType> MapOptionsByNamespace(
+      std::string namespace_name);
+  friend std::vector<std::string> MapAvailableNamespaces();
+  friend void GetEnvOptionsInputType(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  friend void GetOptionsAsFlags(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
 };
 
 using StringVector = std::vector<std::string>;
@@ -477,7 +665,7 @@ void Parse(
 namespace per_process {
 
 extern Mutex cli_options_mutex;
-extern std::shared_ptr<PerProcessOptions> cli_options;
+extern NODE_EXTERN_PRIVATE std::shared_ptr<PerProcessOptions> cli_options;
 
 }  // namespace per_process
 

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

@@ -21,8 +21,6 @@ class ExternalReferenceRegistry;
 
 namespace performance {
 
-extern const uint64_t timeOrigin;
-
 inline const char* GetPerformanceMilestoneName(
     PerformanceMilestone milestone) {
   switch (milestone) {
@@ -126,12 +124,12 @@ struct PerformanceEntry {
     }
 
     v8::Local<v8::Value> argv[] = {
-      OneByteString(env->isolate(), name.c_str()),
-      OneByteString(env->isolate(), GetPerformanceEntryTypeName(Traits::kType)),
-      v8::Number::New(env->isolate(), start_time),
-      v8::Number::New(env->isolate(), duration),
-      detail
-    };
+        OneByteString(env->isolate(), name),
+        OneByteString(env->isolate(),
+                      GetPerformanceEntryTypeName(Traits::kType)),
+        v8::Number::New(env->isolate(), start_time),
+        v8::Number::New(env->isolate(), duration),
+        detail};
 
     node::MakeSyncCallback(
         env->isolate(),
@@ -160,23 +158,6 @@ struct GCPerformanceEntryTraits {
 
 using GCPerformanceEntry = PerformanceEntry<GCPerformanceEntryTraits>;
 
-class ELDHistogram : public IntervalHistogram {
- public:
-  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
-  static void Initialize(Environment* env, v8::Local<v8::Object> target);
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  ELDHistogram(
-      Environment* env,
-      v8::Local<v8::Object> wrap,
-      int64_t interval);
-
-  void OnInterval() override;
-
-  SET_MEMORY_INFO_NAME(ELDHistogram)
-  SET_SELF_SIZE(ELDHistogram)
-};
-
 }  // namespace performance
 }  // namespace node
 

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

@@ -20,21 +20,26 @@ namespace performance {
 
 // These occur before the environment is created. Cache them
 // here and add them to the milestones when the env is init'd.
+extern const uint64_t performance_process_start;
+extern const double performance_process_start_timestamp;
 extern uint64_t performance_v8_start;
 
-#define NODE_PERFORMANCE_MILESTONES(V)                                        \
-  V(ENVIRONMENT, "environment")                                               \
-  V(NODE_START, "nodeStart")                                                  \
-  V(V8_START, "v8Start")                                                      \
-  V(LOOP_START, "loopStart")                                                  \
-  V(LOOP_EXIT, "loopExit")                                                    \
+#define NODE_PERFORMANCE_MILESTONES(V)                                         \
+  V(TIME_ORIGIN_TIMESTAMP, "timeOriginTimestamp")                              \
+  V(TIME_ORIGIN, "timeOrigin")                                                 \
+  V(ENVIRONMENT, "environment")                                                \
+  V(NODE_START, "nodeStart")                                                   \
+  V(V8_START, "v8Start")                                                       \
+  V(LOOP_START, "loopStart")                                                   \
+  V(LOOP_EXIT, "loopExit")                                                     \
   V(BOOTSTRAP_COMPLETE, "bootstrapComplete")
 
-
 #define NODE_PERFORMANCE_ENTRY_TYPES(V)                                       \
   V(GC, "gc")                                                                 \
   V(HTTP, "http")                                                             \
-  V(HTTP2, "http2")
+  V(HTTP2, "http2")                                                           \
+  V(NET, "net")                                                               \
+  V(DNS, "dns")
 
 enum PerformanceMilestone {
 #define V(name, _) NODE_PERFORMANCE_MILESTONE_##name,
@@ -58,10 +63,15 @@ class PerformanceState {
     AliasedBufferIndex observers;
   };
 
-  explicit PerformanceState(v8::Isolate* isolate, const SerializeInfo* info);
+  explicit PerformanceState(v8::Isolate* isolate,
+                            uint64_t time_origin,
+                            double time_origin_timestamp,
+                            const SerializeInfo* info);
   SerializeInfo Serialize(v8::Local<v8::Context> context,
                           v8::SnapshotCreator* creator);
-  void Deserialize(v8::Local<v8::Context> context);
+  void Deserialize(v8::Local<v8::Context> context,
+                   uint64_t time_origin,
+                   double time_origin_timestamp);
   friend std::ostream& operator<<(std::ostream& o, const SerializeInfo& i);
 
   AliasedUint8Array root;
@@ -69,11 +79,14 @@ class PerformanceState {
   AliasedUint32Array observers;
 
   uint64_t performance_last_gc_start_mark = 0;
+  uint16_t current_gc_type = 0;
 
   void Mark(enum PerformanceMilestone milestone,
             uint64_t ts = PERFORMANCE_NOW());
 
  private:
+  void Initialize(uint64_t time_origin, double time_origin_timestamp);
+  void ResetMilestones();
   struct performance_state_internal {
     // doubles first so that they are always sizeof(double)-aligned
     double milestones[NODE_PERFORMANCE_MILESTONE_INVALID];