@encharm/cws 4.4.1 → 4.5.2

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

@@ -1,10 +1,13 @@
 #ifndef SRC_NODE_BLOB_H_
 #define SRC_NODE_BLOB_H_
 
+#include "v8-function-callback.h"
+#include "v8-template.h"
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "async_wrap.h"
 #include "base_object.h"
+#include "dataqueue/queue.h"
 #include "env.h"
 #include "memory_tracker.h"
 #include "node_internals.h"
@@ -18,62 +21,45 @@
 
 namespace node {
 
-struct BlobEntry {
-  std::shared_ptr<v8::BackingStore> store;
-  size_t length;
-  size_t offset;
-};
-
 class Blob : public BaseObject {
  public:
   static void RegisterExternalReferences(
       ExternalReferenceRegistry* registry);
 
-  static void Initialize(
-      v8::Local<v8::Object> target,
-      v8::Local<v8::Value> unused,
-      v8::Local<v8::Context> context,
-      void* priv);
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void ToArrayBuffer(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetReader(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void ToSlice(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void StoreDataObject(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetDataObject(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void RevokeDataObject(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void RevokeObjectURL(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
       Environment* env);
 
-  static BaseObjectPtr<Blob> Create(
-      Environment* env,
-      const std::vector<BlobEntry> store,
-      size_t length);
+  static BaseObjectPtr<Blob> Create(Environment* env,
+                                    std::shared_ptr<DataQueue> data_queue);
 
   static bool HasInstance(Environment* env, v8::Local<v8::Value> object);
 
-  const std::vector<BlobEntry> entries() const {
-    return store_;
-  }
-
   void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(Blob)
   SET_SELF_SIZE(Blob)
 
-  // Copies the contents of the Blob into an ArrayBuffer.
-  v8::MaybeLocal<v8::Value> GetArrayBuffer(Environment* env);
-
   BaseObjectPtr<Blob> Slice(Environment* env, size_t start, size_t end);
 
-  inline size_t length() const { return length_; }
+  inline size_t length() const { return this->data_queue_->size().value(); }
 
   class BlobTransferData : public worker::TransferData {
    public:
-    explicit BlobTransferData(
-        const std::vector<BlobEntry>& store,
-      size_t length)
-        : store_(store),
-          length_(length) {}
+    explicit BlobTransferData(std::shared_ptr<DataQueue> data_queue)
+        : data_queue(data_queue) {}
 
     BaseObjectPtr<BaseObject> Deserialize(
         Environment* env,
@@ -85,72 +71,54 @@ class Blob : public BaseObject {
     SET_NO_MEMORY_INFO()
 
    private:
-    std::vector<BlobEntry> store_;
-    size_t length_ = 0;
+    std::shared_ptr<DataQueue> data_queue;
   };
 
-  BaseObject::TransferMode GetTransferMode() const override;
-  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
+  class Reader final : public AsyncWrap {
+   public:
+    static bool HasInstance(Environment* env, v8::Local<v8::Value> value);
+    static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+        Environment* env);
+    static BaseObjectPtr<Reader> Create(Environment* env,
+                                        BaseObjectPtr<Blob> blob);
+    static void Pull(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  Blob(
-      Environment* env,
-      v8::Local<v8::Object> obj,
-      const std::vector<BlobEntry>& store,
-      size_t length);
+    explicit Reader(Environment* env,
+                    v8::Local<v8::Object> obj,
+                    BaseObjectPtr<Blob> strong_ptr);
 
- private:
-  std::vector<BlobEntry> store_;
-  size_t length_ = 0;
-};
+    SET_NO_MEMORY_INFO()
+    SET_MEMORY_INFO_NAME(Blob::Reader)
+    SET_SELF_SIZE(Reader)
 
-class FixedSizeBlobCopyJob : public AsyncWrap, public ThreadPoolWork {
- public:
-  enum class Mode {
-    SYNC,
-    ASYNC
+   private:
+    std::shared_ptr<DataQueue::Reader> inner_;
+    BaseObjectPtr<Blob> strong_ptr_;
+    bool eos_ = false;
   };
 
-  static void RegisterExternalReferences(
-      ExternalReferenceRegistry* registry);
-  static void Initialize(Environment* env, v8::Local<v8::Object> target);
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Run(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  bool IsNotIndicativeOfMemoryLeakAtExit() const override {
-    return true;
-  }
+  BaseObject::TransferMode GetTransferMode() const override;
+  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
 
-  void DoThreadPoolWork() override;
-  void AfterThreadPoolWork(int status) override;
+  Blob(Environment* env,
+       v8::Local<v8::Object> obj,
+       std::shared_ptr<DataQueue> data_queue);
 
-  Mode mode() const { return mode_; }
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(FixedSizeBlobCopyJob)
-  SET_SELF_SIZE(FixedSizeBlobCopyJob)
+  DataQueue& getDataQueue() const { return *data_queue_; }
 
  private:
-  FixedSizeBlobCopyJob(
-    Environment* env,
-    v8::Local<v8::Object> object,
-    Blob* blob,
-    Mode mode = Mode::ASYNC);
-
-  Mode mode_;
-  std::vector<BlobEntry> source_;
-  std::shared_ptr<v8::BackingStore> destination_;
-  size_t length_ = 0;
+  std::shared_ptr<DataQueue> data_queue_;
 };
 
 class BlobBindingData : public SnapshotableObject {
  public:
-  explicit BlobBindingData(Environment* env, v8::Local<v8::Object> wrap);
+  explicit BlobBindingData(Realm* realm, v8::Local<v8::Object> wrap);
+
+  using InternalFieldInfo = InternalFieldInfoBase;
 
   SERIALIZABLE_OBJECT_METHODS()
 
-  static constexpr FastStringKey type_name{"node::BlobBindingData"};
-  static constexpr EmbedderObjectType type_int =
-      EmbedderObjectType::k_blob_binding_data;
+  SET_BINDING_ID(blob_binding_data)
 
   void MemoryInfo(MemoryTracker* tracker) const override;
   SET_SELF_SIZE(BlobBindingData)

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

@@ -25,8 +25,7 @@ int SourceImpl<T>::Pull(
 
   status = DoPull(std::move(next), options, data, count, max_count_hint);
 
-  if (status == bob::Status::STATUS_END)
-    eos_ = true;
+  if (status == bob::Status::STATUS_EOS) eos_ = true;
 
   return status;
 }

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

@@ -11,12 +11,7 @@ constexpr size_t kMaxCountHint = 16;
 // Negative status codes indicate error conditions.
 enum Status : int {
   // Indicates that an attempt was made to pull after end.
-  STATUS_EOS = -1,
-
-  // Indicates the end of the stream. No additional
-  // data will be available and the consumer should stop
-  // pulling.
-  STATUS_END = 0,
+  STATUS_EOS = 0,
 
   // Indicates that there is additional data available
   // and the consumer may continue to pull.
@@ -72,6 +67,7 @@ using Next = std::function<void(int, const T*, size_t count, Done done)>;
 template <typename T>
 class Source {
  public:
+  virtual ~Source() = default;
   virtual int Pull(
       Next<T> next,
       int options,

package/src/headers/{14 → 24}/node_buffer.h

@@ -29,7 +29,7 @@ namespace node {
 
 namespace Buffer {
 
-static const size_t kMaxLength = v8::TypedArray::kMaxLength;
+static const size_t kMaxLength = v8::Uint8Array::kMaxLength;
 
 typedef void (*FreeCallback)(char* data, void* hint);
 

package/src/headers/24/node_builtins.h

@@ -0,0 +1,223 @@
+#ifndef SRC_NODE_BUILTINS_H_
+#define SRC_NODE_BUILTINS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <list>
+#include <map>
+#include <memory>
+#include <optional>
+#include <ranges>
+#include <string>
+#include <unordered_set>
+#include <vector>
+#include "node_external_reference.h"
+#include "node_mutex.h"
+#include "node_threadsafe_cow.h"
+#include "node_union_bytes.h"
+#include "v8.h"
+
+// Forward declare test fixture for `friend` declaration.
+class PerProcessTest;
+
+namespace node {
+class SnapshotBuilder;
+class ExternalReferenceRegistry;
+class Realm;
+
+namespace builtins {
+
+class BuiltinCodeCacheData {
+ public:
+  BuiltinCodeCacheData() : data(nullptr), length(0), owning_ptr(nullptr) {}
+
+  explicit BuiltinCodeCacheData(
+      std::shared_ptr<v8::ScriptCompiler::CachedData> cached_data)
+      : data(cached_data->data),
+        length(cached_data->length),
+        owning_ptr(cached_data) {}
+
+  explicit BuiltinCodeCacheData(
+      std::shared_ptr<std::vector<uint8_t>> cached_data)
+      : data(cached_data->data()),
+        length(cached_data->size()),
+        owning_ptr(cached_data) {}
+
+  BuiltinCodeCacheData(const uint8_t* data, size_t length)
+      : data(data), length(length), owning_ptr(nullptr) {}
+
+  const uint8_t* data;
+  size_t length;
+
+  // Returns a v8::ScriptCompiler::CachedData corresponding to this
+  // BuiltinCodeCacheData. The lifetime of the returned
+  // v8::ScriptCompiler::CachedData must not outlive that of the data.
+  std::unique_ptr<v8::ScriptCompiler::CachedData> AsCachedData() {
+    return std::make_unique<v8::ScriptCompiler::CachedData>(
+        data, length, v8::ScriptCompiler::CachedData::BufferNotOwned);
+  }
+
+ private:
+  // If not null, represents a pointer which owns data. Otherwise indicates
+  // that data has static lifetime.
+  std::shared_ptr<void> owning_ptr;
+};
+
+struct CodeCacheInfo {
+  std::string id;
+  BuiltinCodeCacheData data;
+};
+
+using BuiltinSourceMap = std::map<std::string, UnionBytes>;
+using BuiltinCodeCacheMap =
+    std::unordered_map<std::string, BuiltinCodeCacheData>;
+
+// Generated by tools/js2c.cc as node_javascript.cc
+void RegisterExternalReferencesForInternalizedBuiltinCode(
+    ExternalReferenceRegistry* registry);
+
+// Handles compilation and caching of built-in JavaScript modules and
+// bootstrap scripts, whose source are bundled into the binary as static data.
+class NODE_EXTERN_PRIVATE BuiltinLoader {
+ public:
+  BuiltinLoader();
+  BuiltinLoader(const BuiltinLoader&) = delete;
+  BuiltinLoader& operator=(const BuiltinLoader&) = delete;
+
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+
+  // The parameters used to compile the scripts are detected based on
+  // the pattern of the id.
+  v8::MaybeLocal<v8::Function> LookupAndCompile(v8::Local<v8::Context> context,
+                                                const char* id,
+                                                Realm* optional_realm);
+
+  v8::MaybeLocal<v8::Function> LookupAndCompile(
+      v8::Local<v8::Context> context,
+      const char* id,
+      v8::LocalVector<v8::String>* parameters,
+      Realm* optional_realm);
+
+  v8::MaybeLocal<v8::Value> CompileAndCall(v8::Local<v8::Context> context,
+                                           const char* id,
+                                           int argc,
+                                           v8::Local<v8::Value> argv[],
+                                           Realm* optional_realm);
+
+  v8::MaybeLocal<v8::Value> CompileAndCall(v8::Local<v8::Context> context,
+                                           const char* id,
+                                           Realm* realm);
+
+  // Returns config.gypi as a JSON string
+  v8::Local<v8::String> GetConfigString(v8::Isolate* isolate);
+  bool Exists(const char* id);
+  bool Add(const char* id, const UnionBytes& source);
+
+  bool CompileAllBuiltinsAndCopyCodeCache(
+      v8::Local<v8::Context> context,
+      const std::vector<std::string>& lazy_builtins,
+      std::vector<CodeCacheInfo>* out);
+  void RefreshCodeCache(const std::vector<CodeCacheInfo>& in);
+
+  void CopySourceAndCodeCacheReferenceFrom(const BuiltinLoader* other);
+
+  [[nodiscard]] std::ranges::keys_view<
+      std::ranges::ref_view<const BuiltinSourceMap>>
+  GetBuiltinIds() const;
+
+  void SetEagerCompile() { should_eager_compile_ = true; }
+
+ private:
+  // Only allow access from friends.
+  friend class CodeCacheBuilder;
+
+  // Generated by tools/js2c.cc as node_javascript.cc
+  void LoadJavaScriptSource();  // Loads data into source_
+  UnionBytes GetConfig();       // Return data for config.gypi
+
+  struct BuiltinCategories {
+    std::set<std::string> can_be_required;
+    std::set<std::string> cannot_be_required;
+  };
+  // This method builds `BuiltinCategories` from scratch every time,
+  // and is therefore somewhat expensive, but also currently only being
+  // used for testing, so that should not be an issue.
+  BuiltinCategories GetBuiltinCategories() const;
+
+  const v8::ScriptCompiler::CachedData* GetCodeCache(const char* id) const;
+  enum class Result { kWithCache, kWithoutCache };
+  v8::MaybeLocal<v8::String> LoadBuiltinSource(v8::Isolate* isolate,
+                                               const char* id) const;
+  // If an exception is encountered (e.g. source code contains
+  // syntax error), the returned value is empty.
+  v8::MaybeLocal<v8::Function> LookupAndCompileInternal(
+      v8::Local<v8::Context> context,
+      const char* id,
+      v8::LocalVector<v8::String>* parameters,
+      Realm* optional_realm);
+  void SaveCodeCache(const char* id, v8::Local<v8::Function> fn);
+
+  static void RecordResult(const char* id,
+                           BuiltinLoader::Result result,
+                           Realm* realm);
+  static void GetBuiltinCategories(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& info);
+  static void GetCacheUsage(const v8::FunctionCallbackInfo<v8::Value>& args);
+  // Passing ids of built-in source code into JS land as
+  // internalBinding('builtins').builtinIds
+  static void BuiltinIdsGetter(v8::Local<v8::Name> property,
+                               const v8::PropertyCallbackInfo<v8::Value>& info);
+  // Passing config.gypi into JS land as internalBinding('builtins').config
+  static void ConfigStringGetter(
+      v8::Local<v8::Name> property,
+      const v8::PropertyCallbackInfo<v8::Value>& info);
+  // Compile a specific built-in as a function
+  static void CompileFunction(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void HasCachedBuiltins(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  // For legacy process.binding('natives')
+  static void GetNatives(v8::Local<v8::Name> property,
+                         const v8::PropertyCallbackInfo<v8::Value>& info);
+
+  void AddExternalizedBuiltin(const char* id, const char* filename);
+
+  ThreadsafeCopyOnWrite<BuiltinSourceMap> source_;
+
+  const UnionBytes config_;
+
+  // If any bulitins should be eagerly compiled i.e. with inner functions
+  // compiled too, either use should_eager_compile_ to compile all builtins
+  // eagerly, or use to_eager_compile_ to compile specific builtins eagerly.
+  // Currently we set should_eager_compile_ to true when compiling primordials,
+  // and use to_eager_compile_ to compile code cache that complements the
+  // snapshot, where builtins already loaded in the snapshot and a few extras
+  // are compiled eagerly (other less-essential built-ins are compiled lazily to
+  // avoid bloating the binary size). At runtime any additional compilation is
+  // done lazily.
+  bool should_eager_compile_ = false;
+  std::unordered_set<std::string> to_eager_compile_;
+
+  struct BuiltinCodeCache {
+    RwLock mutex;
+    BuiltinCodeCacheMap map;
+    bool has_code_cache = false;
+  };
+  std::shared_ptr<BuiltinCodeCache> code_cache_;
+
+  friend class ::PerProcessTest;
+};
+
+}  // namespace builtins
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_BUILTINS_H_

package/src/headers/24/node_config_file.h

@@ -0,0 +1,65 @@
+#ifndef SRC_NODE_CONFIG_FILE_H_
+#define SRC_NODE_CONFIG_FILE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <map>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <variant>
+#include <vector>
+#include "node_internals.h"
+#include "simdjson.h"
+#include "util-inl.h"
+
+namespace node {
+
+// When trying to parse the configuration file, we can have three possible
+// results:
+//  - Valid: The file was successfully parsed and the content is valid.
+//  - FileError: There was an error reading the file.
+//  - InvalidContent: The file was read, but the content is invalid.
+enum ParseResult { Valid, FileError, InvalidContent };
+
+// ConfigReader is the class that parses the configuration JSON file.
+// It reads the file provided by --experimental-config-file and
+// extracts the flags.
+class ConfigReader {
+ public:
+  ParseResult ParseConfig(const std::string_view& config_path);
+
+  std::optional<std::string_view> GetDataFromArgs(
+      const std::vector<std::string>& args);
+
+  std::string GetNodeOptions();
+  const std::vector<std::string>& GetNamespaceFlags() const;
+
+  size_t GetFlagsSize();
+
+ private:
+  // Parse options for a specific namespace (including nodeOptions for backward
+  // compatibility)
+  ParseResult ParseOptions(simdjson::ondemand::object* options_object,
+                           std::unordered_set<std::string>* unique_options,
+                           const std::string& namespace_name);
+
+  // Process a single option value based on its type
+  ParseResult ProcessOptionValue(
+      const std::pair<std::string, options_parser::OptionType>& option_info,
+      simdjson::ondemand::value* option_value,
+      std::vector<std::string>* output);
+
+  std::vector<std::string> node_options_;
+  std::vector<std::string> namespace_options_;
+
+  // Cache for fast lookup of environment options
+  std::unordered_map<std::string, options_parser::OptionType> env_options_map_;
+  bool env_options_initialized_ = false;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_CONFIG_FILE_H_

package/src/headers/{14 → 24}/node_constants.h

@@ -27,6 +27,9 @@
 #include "node.h"
 #include "v8.h"
 
+#define EXTENSIONLESS_FORMAT_JAVASCRIPT (0)
+#define EXTENSIONLESS_FORMAT_WASM (1)
+
 #if HAVE_OPENSSL
 
 #ifndef RSA_PSS_SALTLEN_DIGEST
@@ -74,11 +77,6 @@
 #endif  // NODE_OPENSSL_DEFAULT_CIPHER_LIST
 #endif  // HAVE_OPENSSL
 
-namespace node {
-
-void DefineConstants(v8::Isolate* isolate, v8::Local<v8::Object> target);
-}  // namespace node
-
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #endif  // SRC_NODE_CONSTANTS_H_