@encharm/cws 4.4.1 → 4.5.2

package/src/headers/24/bindingdata.h

@@ -0,0 +1,272 @@
+#pragma once
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+
+#include <base_object.h>
+#include <env.h>
+#include <memory_tracker.h>
+#include <nghttp3/nghttp3.h>
+#include <ngtcp2/ngtcp2.h>
+#include <ngtcp2/ngtcp2_crypto.h>
+#include <node.h>
+#include <node_mem.h>
+#include <v8.h>
+#include <unordered_map>
+#include <vector>
+#include "defs.h"
+
+namespace node::quic {
+
+class Endpoint;
+class Packet;
+
+// ============================================================================
+
+// The FunctionTemplates the BindingData will store for us.
+#define QUIC_CONSTRUCTORS(V)                                                   \
+  V(endpoint)                                                                  \
+  V(logstream)                                                                 \
+  V(packet)                                                                    \
+  V(session)                                                                   \
+  V(stream)                                                                    \
+  V(udp)                                                                       \
+  V(http3application)
+
+// The callbacks are persistent v8::Function references that are set in the
+// quic::BindingState used to communicate data and events back out to the JS
+// environment. They are set once from the JavaScript side when the
+// internalBinding('quic') is first loaded.
+#define QUIC_JS_CALLBACKS(V)                                                   \
+  V(endpoint_close, EndpointClose)                                             \
+  V(session_new, SessionNew)                                                   \
+  V(session_close, SessionClose)                                               \
+  V(session_datagram, SessionDatagram)                                         \
+  V(session_datagram_status, SessionDatagramStatus)                            \
+  V(session_handshake, SessionHandshake)                                       \
+  V(session_ticket, SessionTicket)                                             \
+  V(session_version_negotiation, SessionVersionNegotiation)                    \
+  V(session_path_validation, SessionPathValidation)                            \
+  V(stream_close, StreamClose)                                                 \
+  V(stream_created, StreamCreated)                                             \
+  V(stream_reset, StreamReset)                                                 \
+  V(stream_headers, StreamHeaders)                                             \
+  V(stream_blocked, StreamBlocked)                                             \
+  V(stream_trailers, StreamTrailers)
+
+// The various JS strings the implementation uses.
+#define QUIC_STRINGS(V)                                                        \
+  V(aborted, "aborted")                                                        \
+  V(acknowledged, "acknowledged")                                              \
+  V(ack_delay_exponent, "ackDelayExponent")                                    \
+  V(active_connection_id_limit, "activeConnectionIDLimit")                     \
+  V(address_lru_size, "addressLRUSize")                                        \
+  V(application_provider, "provider")                                          \
+  V(bbr, "bbr")                                                                \
+  V(ca, "ca")                                                                  \
+  V(certs, "certs")                                                            \
+  V(cc_algorithm, "cc")                                                        \
+  V(crl, "crl")                                                                \
+  V(ciphers, "ciphers")                                                        \
+  V(cubic, "cubic")                                                            \
+  V(disable_stateless_reset, "disableStatelessReset")                          \
+  V(enable_connect_protocol, "enableConnectProtocol")                          \
+  V(enable_datagrams, "enableDatagrams")                                       \
+  V(enable_tls_trace, "tlsTrace")                                              \
+  V(endpoint, "Endpoint")                                                      \
+  V(endpoint_udp, "Endpoint::UDP")                                             \
+  V(failure, "failure")                                                        \
+  V(groups, "groups")                                                          \
+  V(handshake_timeout, "handshakeTimeout")                                     \
+  V(http3_alpn, &NGHTTP3_ALPN_H3[1])                                           \
+  V(http3application, "Http3Application")                                      \
+  V(initial_max_data, "initialMaxData")                                        \
+  V(initial_max_stream_data_bidi_local, "initialMaxStreamDataBidiLocal")       \
+  V(initial_max_stream_data_bidi_remote, "initialMaxStreamDataBidiRemote")     \
+  V(initial_max_stream_data_uni, "initialMaxStreamDataUni")                    \
+  V(initial_max_streams_bidi, "initialMaxStreamsBidi")                         \
+  V(initial_max_streams_uni, "initialMaxStreamsUni")                           \
+  V(ipv6_only, "ipv6Only")                                                     \
+  V(keylog, "keylog")                                                          \
+  V(keys, "keys")                                                              \
+  V(logstream, "LogStream")                                                    \
+  V(lost, "lost")                                                              \
+  V(max_ack_delay, "maxAckDelay")                                              \
+  V(max_connections_per_host, "maxConnectionsPerHost")                         \
+  V(max_connections_total, "maxConnectionsTotal")                              \
+  V(max_datagram_frame_size, "maxDatagramFrameSize")                           \
+  V(max_field_section_size, "maxFieldSectionSize")                             \
+  V(max_header_length, "maxHeaderLength")                                      \
+  V(max_header_pairs, "maxHeaderPairs")                                        \
+  V(max_idle_timeout, "maxIdleTimeout")                                        \
+  V(max_payload_size, "maxPayloadSize")                                        \
+  V(max_retries, "maxRetries")                                                 \
+  V(max_stateless_resets, "maxStatelessResetsPerHost")                         \
+  V(max_stream_window, "maxStreamWindow")                                      \
+  V(max_window, "maxWindow")                                                   \
+  V(min_version, "minVersion")                                                 \
+  V(packetwrap, "PacketWrap")                                                  \
+  V(preferred_address_strategy, "preferredAddressPolicy")                      \
+  V(protocol, "protocol")                                                      \
+  V(qlog, "qlog")                                                              \
+  V(qpack_blocked_streams, "qpackBlockedStreams")                              \
+  V(qpack_encoder_max_dtable_capacity, "qpackEncoderMaxDTableCapacity")        \
+  V(qpack_max_dtable_capacity, "qpackMaxDTableCapacity")                       \
+  V(reject_unauthorized, "rejectUnauthorized")                                 \
+  V(reno, "reno")                                                              \
+  V(retry_token_expiration, "retryTokenExpiration")                            \
+  V(reset_token_secret, "resetTokenSecret")                                    \
+  V(rx_loss, "rxDiagnosticLoss")                                               \
+  V(servername, "servername")                                                  \
+  V(session, "Session")                                                        \
+  V(stream, "Stream")                                                          \
+  V(success, "success")                                                        \
+  V(tls_options, "tls")                                                        \
+  V(token_expiration, "tokenExpiration")                                       \
+  V(token_secret, "tokenSecret")                                               \
+  V(transport_params, "transportParams")                                       \
+  V(tx_loss, "txDiagnosticLoss")                                               \
+  V(udp_receive_buffer_size, "udpReceiveBufferSize")                           \
+  V(udp_send_buffer_size, "udpSendBufferSize")                                 \
+  V(udp_ttl, "udpTTL")                                                         \
+  V(unacknowledged_packet_threshold, "unacknowledgedPacketThreshold")          \
+  V(validate_address, "validateAddress")                                       \
+  V(verify_client, "verifyClient")                                             \
+  V(verify_private_key, "verifyPrivateKey")                                    \
+  V(version, "version")
+
+// =============================================================================
+// The BindingState object holds state for the internalBinding('quic') binding
+// instance. It is mostly used to hold the persistent constructors, strings, and
+// callback references used for the rest of the implementation.
+//
+// TODO(@jasnell): Make this snapshotable?
+class BindingData final
+    : public BaseObject,
+      public mem::NgLibMemoryManager<BindingData, ngtcp2_mem> {
+ public:
+  SET_BINDING_ID(quic_binding_data)
+  static void InitPerContext(Realm* realm, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  static BindingData& Get(Environment* env);
+
+  BindingData(Realm* realm, v8::Local<v8::Object> object);
+  DISALLOW_COPY_AND_MOVE(BindingData)
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(BindingData)
+  SET_SELF_SIZE(BindingData)
+
+  // NgLibMemoryManager
+  operator ngtcp2_mem();
+  operator nghttp3_mem();
+  void CheckAllocatedSize(size_t previous_size) const;
+  void IncreaseAllocatedSize(size_t size);
+  void DecreaseAllocatedSize(size_t size);
+
+  // Installs the set of JavaScript callback functions that are used to
+  // bridge out to the JS API.
+  static void SetCallbacks(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  std::vector<BaseObjectPtr<BaseObject>> packet_freelist;
+
+  std::unordered_map<Endpoint*, BaseObjectPtr<BaseObject>> listening_endpoints;
+
+  // Purge the packet free list to free up memory.
+  static void FlushPacketFreelist(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  bool in_ngtcp2_callback_scope = false;
+  bool in_nghttp3_callback_scope = false;
+
+  // The following set up various storage and accessors for common strings,
+  // construction templates, and callbacks stored on the BindingData. These
+  // are all defined in defs.h
+
+#define V(name)                                                                \
+  void set_##name##_constructor_template(                                      \
+      v8::Local<v8::FunctionTemplate> tmpl);                                   \
+  v8::Local<v8::FunctionTemplate> name##_constructor_template() const;
+  QUIC_CONSTRUCTORS(V)
+#undef V
+
+#define V(name, _)                                                             \
+  void set_##name##_callback(v8::Local<v8::Function> fn);                      \
+  v8::Local<v8::Function> name##_callback() const;
+  QUIC_JS_CALLBACKS(V)
+#undef V
+
+#define V(name, _) v8::Local<v8::String> name##_string() const;
+  QUIC_STRINGS(V)
+#undef V
+
+#define V(name, _) v8::Local<v8::String> on_##name##_string() const;
+  QUIC_JS_CALLBACKS(V)
+#undef V
+
+  size_t current_ngtcp2_memory_ = 0;
+
+#define V(name) v8::Global<v8::FunctionTemplate> name##_constructor_template_;
+  QUIC_CONSTRUCTORS(V)
+#undef V
+
+#define V(name, _) v8::Global<v8::Function> name##_callback_;
+  QUIC_JS_CALLBACKS(V)
+#undef V
+
+#define V(name, _) mutable v8::Eternal<v8::String> name##_string_;
+  QUIC_STRINGS(V)
+#undef V
+
+#define V(name, _) mutable v8::Eternal<v8::String> on_##name##_string_;
+  QUIC_JS_CALLBACKS(V)
+#undef V
+};
+
+void IllegalConstructor(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+// The ngtcp2 and nghttp3 callbacks have certain restrictions
+// that forbid re-entry. We provide the following scopes for
+// use in those to help protect against it.
+struct NgTcp2CallbackScope {
+  Environment* env;
+  explicit NgTcp2CallbackScope(Environment* env);
+  DISALLOW_COPY_AND_MOVE(NgTcp2CallbackScope)
+  ~NgTcp2CallbackScope();
+  static bool in_ngtcp2_callback(Environment* env);
+};
+
+struct NgHttp3CallbackScope {
+  Environment* env;
+  explicit NgHttp3CallbackScope(Environment* env);
+  DISALLOW_COPY_AND_MOVE(NgHttp3CallbackScope)
+  ~NgHttp3CallbackScope();
+  static bool in_nghttp3_callback(Environment* env);
+};
+
+struct CallbackScopeBase {
+  Environment* env;
+  v8::Context::Scope context_scope;
+  v8::TryCatch try_catch;
+
+  explicit CallbackScopeBase(Environment* env);
+  DISALLOW_COPY_AND_MOVE(CallbackScopeBase)
+  ~CallbackScopeBase();
+};
+
+// Maintains a strong reference to BaseObject type ptr to keep it alive during
+// a MakeCallback during which it might be destroyed.
+template <typename T>
+struct CallbackScope final : public CallbackScopeBase {
+  BaseObjectPtr<T> ref;
+  explicit CallbackScope(const T* ptr)
+      : CallbackScopeBase(ptr->env()), ref(ptr) {}
+  DISALLOW_COPY_AND_MOVE(CallbackScope)
+  explicit CallbackScope(T* ptr) : CallbackScopeBase(ptr->env()), ref(ptr) {}
+};
+
+}  // namespace node::quic
+
+#endif  // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/24/blob_serializer_deserializer-inl.h

@@ -0,0 +1,385 @@
+#ifndef SRC_BLOB_SERIALIZER_DESERIALIZER_INL_H_
+#define SRC_BLOB_SERIALIZER_DESERIALIZER_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "blob_serializer_deserializer.h"
+
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "debug_utils-inl.h"
+
+// This is related to the blob that is used in snapshots and single executable
+// applications and has nothing to do with `node_blob.h`.
+
+namespace node {
+
+struct EnvSerializeInfo;
+struct PropInfo;
+struct RealmSerializeInfo;
+
+namespace builtins {
+struct CodeCacheInfo;
+}  // namespace builtins
+
+// These operator<< overload declarations are needed because
+// BlobSerializerDeserializer::ToStr() uses these.
+
+std::ostream& operator<<(std::ostream& output,
+                         const builtins::CodeCacheInfo& info);
+
+std::ostream& operator<<(std::ostream& output,
+                         const std::vector<builtins::CodeCacheInfo>& vec);
+
+std::ostream& operator<<(std::ostream& output, const std::vector<uint8_t>& vec);
+
+std::ostream& operator<<(std::ostream& output,
+                         const std::vector<PropInfo>& vec);
+
+std::ostream& operator<<(std::ostream& output, const PropInfo& info);
+
+std::ostream& operator<<(std::ostream& output,
+                         const std::vector<std::string>& vec);
+
+std::ostream& operator<<(std::ostream& output, const RealmSerializeInfo& i);
+
+std::ostream& operator<<(std::ostream& output, const EnvSerializeInfo& i);
+
+template <typename... Args>
+void BlobSerializerDeserializer::Debug(const char* format,
+                                       Args&&... args) const {
+  if (is_debug) {
+    FPrintF(stderr, format, std::forward<Args>(args)...);
+  }
+}
+
+template <typename T>
+std::string BlobSerializerDeserializer::ToStr(const T& arg) const {
+  std::stringstream ss;
+  ss << arg;
+  return ss.str();
+}
+
+template <typename T>
+std::string BlobSerializerDeserializer::GetName() const {
+#define TYPE_LIST(V)                                                           \
+  V(builtins::CodeCacheInfo)                                                   \
+  V(PropInfo)                                                                  \
+  V(std::string)
+
+#define V(TypeName)                                                            \
+  if constexpr (std::is_same_v<T, TypeName>) {                                 \
+    return #TypeName;                                                          \
+  } else  // NOLINT(readability/braces)
+  TYPE_LIST(V)
+#undef V
+
+  if constexpr (std::is_arithmetic_v<T>) {
+    return (std::is_unsigned_v<T>   ? "uint"
+            : std::is_integral_v<T> ? "int"
+                                    : "float") +
+           std::to_string(sizeof(T) * 8) + "_t";
+  }
+  return "";
+}
+
+// Helper for reading numeric types.
+template <typename Impl>
+template <typename T>
+T BlobDeserializer<Impl>::ReadArithmetic() {
+  static_assert(std::is_arithmetic_v<T>, "Not an arithmetic type");
+  T result;
+  ReadArithmetic(&result, 1);
+  return result;
+}
+
+// Layout of vectors:
+// [ 4/8 bytes ] count
+// [   ...     ] contents (count * size of individual elements)
+template <typename Impl>
+template <typename T>
+std::vector<T> BlobDeserializer<Impl>::ReadVector() {
+  if (is_debug) {
+    std::string name = GetName<T>();
+    Debug("\nReadVector<%s>()(%d-byte)\n", name.c_str(), sizeof(T));
+  }
+  size_t count = static_cast<size_t>(ReadArithmetic<size_t>());
+  if (count == 0) {
+    return std::vector<T>();
+  }
+  if (is_debug) {
+    Debug("Reading %d vector elements...\n", count);
+  }
+  std::vector<T> result;
+  if constexpr (std::is_arithmetic_v<T>) {
+    result = ReadArithmeticVector<T>(count);
+  } else {
+    result = ReadNonArithmeticVector<T>(count);
+  }
+  if (is_debug) {
+    std::string str = std::is_arithmetic_v<T> ? "" : ToStr(result);
+    std::string name = GetName<T>();
+    Debug("ReadVector<%s>() read %s\n", name.c_str(), str.c_str());
+  }
+  return result;
+}
+
+template <typename Impl>
+std::string BlobDeserializer<Impl>::ReadString() {
+  std::string_view view = ReadStringView(StringLogMode::kAddressAndContent);
+  return std::string(view);
+}
+
+template <typename Impl>
+std::string_view BlobDeserializer<Impl>::ReadStringView(StringLogMode mode) {
+  size_t length = ReadArithmetic<size_t>();
+  Debug("ReadStringView(), length=%zu: ", length);
+
+  if (length == 0) {
+    Debug("ReadStringView() read an empty view\n");
+    return std::string_view();
+  }
+
+  std::string_view result(sink.data() + read_total, length);
+  Debug("%p, read %zu bytes", result.data(), result.size());
+  if (mode == StringLogMode::kAddressAndContent) {
+    Debug(", content:%s%s", length > 32 ? "\n" : " ", result);
+  }
+  Debug("\n");
+
+  read_total += length;
+  return result;
+}
+
+// Helper for reading an array of numeric types.
+template <typename Impl>
+template <typename T>
+void BlobDeserializer<Impl>::ReadArithmetic(T* out, size_t count) {
+  static_assert(std::is_arithmetic_v<T>, "Not an arithmetic type");
+  DCHECK_GT(count, 0);  // Should not read contents for vectors of size 0.
+  if (is_debug) {
+    std::string name = GetName<T>();
+    Debug("Read<%s>()(%d-byte), count=%d: ", name.c_str(), sizeof(T), count);
+  }
+
+  size_t size = sizeof(T) * count;
+  memcpy(out, sink.data() + read_total, size);
+
+  if (is_debug) {
+    std::string str =
+        "{ " + std::to_string(out[0]) + (count > 1 ? ", ... }" : " }");
+    Debug("%s, read %zu bytes\n", str.c_str(), size);
+  }
+  read_total += size;
+}
+
+// Helper for reading numeric vectors.
+template <typename Impl>
+template <typename Number>
+std::vector<Number> BlobDeserializer<Impl>::ReadArithmeticVector(size_t count) {
+  static_assert(std::is_arithmetic_v<Number>, "Not an arithmetic type");
+  DCHECK_GT(count, 0);  // Should not read contents for vectors of size 0.
+  std::vector<Number> result(count);
+  ReadArithmetic(result.data(), count);
+  return result;
+}
+
+// Helper for reading non-numeric vectors.
+template <typename Impl>
+template <typename T>
+std::vector<T> BlobDeserializer<Impl>::ReadNonArithmeticVector(size_t count) {
+  static_assert(!std::is_arithmetic_v<T>, "Arithmetic type");
+  DCHECK_GT(count, 0);  // Should not read contents for vectors of size 0.
+  std::vector<T> result;
+  result.reserve(count);
+  bool original_is_debug = is_debug;
+  is_debug = original_is_debug && !std::is_same_v<T, std::string>;
+  for (size_t i = 0; i < count; ++i) {
+    if (is_debug) {
+      Debug("\n[%d] ", i);
+    }
+    result.push_back(ReadElement<T>());
+  }
+  is_debug = original_is_debug;
+
+  return result;
+}
+
+template <typename Impl>
+template <typename T>
+T BlobDeserializer<Impl>::ReadElement() {
+  if constexpr (std::is_arithmetic_v<T>) {
+    return ReadArithmetic<T>();
+  } else if constexpr (std::is_same_v<T, std::string>) {
+    return ReadString();
+  } else {
+    return impl()->template Read<T>();
+  }
+}
+
+// Helper for writing numeric types.
+template <typename Impl>
+template <typename T>
+size_t BlobSerializer<Impl>::WriteArithmetic(const T& data) {
+  static_assert(std::is_arithmetic_v<T>, "Not an arithmetic type");
+  return WriteArithmetic(&data, 1);
+}
+
+// Layout of vectors:
+// [ 4/8 bytes ] count
+// [   ...     ] contents (count * size of individual elements)
+template <typename Impl>
+template <typename T>
+size_t BlobSerializer<Impl>::WriteVector(const std::vector<T>& data) {
+  if (is_debug) {
+    std::string str = std::is_arithmetic_v<T> ? "" : ToStr(data);
+    std::string name = GetName<T>();
+    Debug("\nAt 0x%x: WriteVector<%s>() (%d-byte), count=%d: %s\n",
+          sink.size(),
+          name.c_str(),
+          sizeof(T),
+          data.size(),
+          str.c_str());
+  }
+
+  size_t written_total = WriteArithmetic<size_t>(data.size());
+  if (data.empty()) {
+    return written_total;
+  }
+
+  if constexpr (std::is_arithmetic_v<T>) {
+    written_total += WriteArithmeticVector<T>(data);
+  } else {
+    written_total += WriteNonArithmeticVector<T>(data);
+  }
+
+  if (is_debug) {
+    std::string name = GetName<T>();
+    Debug("WriteVector<%s>() wrote %d bytes\n", name.c_str(), written_total);
+  }
+
+  return written_total;
+}
+
+// The layout of a written string:
+// [  4/8 bytes     ] length
+// [ |length| bytes ] contents
+template <typename Impl>
+size_t BlobSerializer<Impl>::WriteStringView(std::string_view data,
+                                             StringLogMode mode) {
+  Debug("At 0x%x: WriteStringView(), length=%zu: %p\n",
+        sink.size(),
+        data.size(),
+        data.data());
+  size_t written_total = WriteArithmetic<size_t>(data.size());
+
+  size_t length = data.size();
+  if (length == 0) {
+    Debug("WriteStringView() wrote an empty view\n");
+    return written_total;
+  }
+  sink.insert(sink.end(), data.data(), data.data() + length);
+  written_total += length;
+
+  Debug("WriteStringView() wrote %zu bytes\n", written_total);
+  if (mode == StringLogMode::kAddressAndContent) {
+    Debug("%s", data);
+  }
+
+  return written_total;
+}
+
+template <typename Impl>
+size_t BlobSerializer<Impl>::WriteString(const std::string& data) {
+  return WriteStringView(data, StringLogMode::kAddressAndContent);
+}
+
+static size_t kPreviewCount = 16;
+
+// Helper for writing an array of numeric types.
+template <typename Impl>
+template <typename T>
+size_t BlobSerializer<Impl>::WriteArithmetic(const T* data, size_t count) {
+  static_assert(std::is_arithmetic_v<T>, "Arithmetic type");
+  DCHECK_GT(count, 0);  // Should not write contents for vectors of size 0.
+  if (is_debug) {
+    size_t preview_count = count < kPreviewCount ? count : kPreviewCount;
+    std::string str = "{ ";
+    for (size_t i = 0; i < preview_count; ++i) {
+      str += (std::to_string(data[i]) + ",");
+    }
+    if (count > preview_count) {
+      str += "...";
+    }
+    str += "}";
+    std::string name = GetName<T>();
+    Debug("At 0x%x: Write<%s>() (%zu-byte), count=%zu: %s",
+          sink.size(),
+          name.c_str(),
+          sizeof(T),
+          count,
+          str.c_str());
+  }
+
+  size_t size = sizeof(T) * count;
+  const char* pos = reinterpret_cast<const char*>(data);
+  sink.insert(sink.end(), pos, pos + size);
+
+  if (is_debug) {
+    Debug(", wrote %zu bytes\n", size);
+  }
+  return size;
+}
+
+// Helper for writing numeric vectors.
+template <typename Impl>
+template <typename Number>
+size_t BlobSerializer<Impl>::WriteArithmeticVector(
+    const std::vector<Number>& data) {
+  static_assert(std::is_arithmetic_v<Number>, "Arithmetic type");
+  return WriteArithmetic(data.data(), data.size());
+}
+
+// Helper for writing non-numeric vectors.
+template <typename Impl>
+template <typename T>
+size_t BlobSerializer<Impl>::WriteNonArithmeticVector(
+    const std::vector<T>& data) {
+  static_assert(!std::is_arithmetic_v<T>, "Arithmetic type");
+  DCHECK_GT(data.size(),
+            0);  // Should not write contents for vectors of size 0.
+  size_t written_total = 0;
+  bool original_is_debug = is_debug;
+  is_debug = original_is_debug && !std::is_same_v<T, std::string>;
+  for (size_t i = 0; i < data.size(); ++i) {
+    if (is_debug) {
+      Debug("\n[%d] ", i);
+    }
+    written_total += WriteElement<T>(data[i]);
+  }
+  is_debug = original_is_debug;
+
+  return written_total;
+}
+
+template <typename Impl>
+template <typename T>
+size_t BlobSerializer<Impl>::WriteElement(const T& data) {
+  if constexpr (std::is_arithmetic_v<T>) {
+    return WriteArithmetic<T>(data);
+  } else if constexpr (std::is_same_v<T, std::string>) {
+    return WriteString(data);
+  } else {
+    return impl()->template Write<T>(data);
+  }
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_BLOB_SERIALIZER_DESERIALIZER_INL_H_