node-linux-s390x 22.8.0 → 23.0.0

package/include/node/v8-array-buffer.h

@@ -18,11 +18,12 @@ namespace v8 {
 class SharedArrayBuffer;
 
 #ifndef V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT
-// The number of required internal fields can be defined by embedder.
+// Defined using gn arg `v8_array_buffer_internal_field_count`.
 #define V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT 2
 #endif
 
 enum class ArrayBufferCreationMode { kInternalized, kExternalized };
+enum class BackingStoreInitializationMode { kZeroInitialized, kUninitialized };
 
 /**
  * A wrapper around the backing store (i.e. the raw memory) of an array buffer.
@@ -87,6 +88,9 @@ class V8_EXPORT BackingStore : public v8::internal::BackingStoreBase {
    * Assumes that the backing_store was allocated by the ArrayBuffer allocator
    * of the given isolate.
    */
+  V8_DEPRECATED(
+      "Reallocate is unsafe, please do not use. Please allocate a new "
+      "BackingStore and copy instead.")
   static std::unique_ptr<BackingStore> Reallocate(
       v8::Isolate* isolate, std::unique_ptr<BackingStore> backing_store,
       size_t byte_length);
@@ -179,6 +183,9 @@ class V8_EXPORT ArrayBuffer : public Object {
      *
      * The default implementation allocates a new block and copies data.
      */
+    V8_DEPRECATED(
+        "Reallocate is unsafe, please do not use. Please allocate new memory "
+        "and copy instead.")
     virtual void* Reallocate(void* data, size_t old_length, size_t new_length);
 
     /**
@@ -211,12 +218,15 @@ class V8_EXPORT ArrayBuffer : public Object {
   size_t MaxByteLength() const;
 
   /**
-   * Create a new ArrayBuffer. Allocate |byte_length| bytes.
-   * Allocated memory will be owned by a created ArrayBuffer and
-   * will be deallocated when it is garbage-collected,
+   * Create a new ArrayBuffer. Allocate |byte_length| bytes, which are either
+   * zero-initialized or uninitialized. Allocated memory will be owned by a
+   * created ArrayBuffer and will be deallocated when it is garbage-collected,
    * unless the object is externalized.
    */
-  static Local<ArrayBuffer> New(Isolate* isolate, size_t byte_length);
+  static Local<ArrayBuffer> New(
+      Isolate* isolate, size_t byte_length,
+      BackingStoreInitializationMode initialization_mode =
+          BackingStoreInitializationMode::kZeroInitialized);
 
   /**
    * Create a new ArrayBuffer with an existing backing store.
@@ -235,15 +245,18 @@ class V8_EXPORT ArrayBuffer : public Object {
 
   /**
    * Returns a new standalone BackingStore that is allocated using the array
-   * buffer allocator of the isolate. The result can be later passed to
+   * buffer allocator of the isolate. The allocation can either be zero
+   * intialized, or uninitialized. The result can be later passed to
    * ArrayBuffer::New.
    *
    * If the allocator returns nullptr, then the function may cause GCs in the
    * given isolate and re-try the allocation. If GCs do not help, then the
    * function will crash with an out-of-memory error.
    */
-  static std::unique_ptr<BackingStore> NewBackingStore(Isolate* isolate,
-                                                       size_t byte_length);
+  static std::unique_ptr<BackingStore> NewBackingStore(
+      Isolate* isolate, size_t byte_length,
+      BackingStoreInitializationMode initialization_mode =
+          BackingStoreInitializationMode::kZeroInitialized);
   /**
    * Returns a new standalone BackingStore that takes over the ownership of
    * the given buffer. The destructor of the BackingStore invokes the given
@@ -287,7 +300,7 @@ class V8_EXPORT ArrayBuffer : public Object {
    * preventing JavaScript from ever accessing underlying backing store.
    * ArrayBuffer should have been externalized and must be detachable.
    */
-  V8_DEPRECATE_SOON(
+  V8_DEPRECATED(
       "Use the version which takes a key parameter (passing a null handle is "
       "ok).")
   void Detach();
@@ -337,8 +350,9 @@ class V8_EXPORT ArrayBuffer : public Object {
     return static_cast<ArrayBuffer*>(value);
   }
 
-  static const int kInternalFieldCount = V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT;
-  static const int kEmbedderFieldCount = V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT;
+  static constexpr int kInternalFieldCount =
+      V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT;
+  static constexpr int kEmbedderFieldCount = kInternalFieldCount;
 
  private:
   ArrayBuffer();
@@ -346,7 +360,7 @@ class V8_EXPORT ArrayBuffer : public Object {
 };
 
 #ifndef V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT
-// The number of required internal fields can be defined by embedder.
+// Defined using gn arg `v8_array_buffer_view_internal_field_count`.
 #define V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT 2
 #endif
 
@@ -393,10 +407,9 @@ class V8_EXPORT ArrayBufferView : public Object {
     return static_cast<ArrayBufferView*>(value);
   }
 
-  static const int kInternalFieldCount =
-      V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT;
-  static const int kEmbedderFieldCount =
+  static constexpr int kInternalFieldCount =
       V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT;
+  static const int kEmbedderFieldCount = kInternalFieldCount;
 
  private:
   ArrayBufferView();
@@ -440,12 +453,15 @@ class V8_EXPORT SharedArrayBuffer : public Object {
   size_t MaxByteLength() const;
 
   /**
-   * Create a new SharedArrayBuffer. Allocate |byte_length| bytes.
-   * Allocated memory will be owned by a created SharedArrayBuffer and
-   * will be deallocated when it is garbage-collected,
-   * unless the object is externalized.
+   * Create a new SharedArrayBuffer. Allocate |byte_length| bytes, which are
+   * either zero-initialized or uninitialized. Allocated memory will be owned by
+   * a created SharedArrayBuffer and will be deallocated when it is
+   * garbage-collected, unless the object is externalized.
    */
-  static Local<SharedArrayBuffer> New(Isolate* isolate, size_t byte_length);
+  static Local<SharedArrayBuffer> New(
+      Isolate* isolate, size_t byte_length,
+      BackingStoreInitializationMode initialization_mode =
+          BackingStoreInitializationMode::kZeroInitialized);
 
   /**
    * Create a new SharedArrayBuffer with an existing backing store.
@@ -464,15 +480,18 @@ class V8_EXPORT SharedArrayBuffer : public Object {
 
   /**
    * Returns a new standalone BackingStore that is allocated using the array
-   * buffer allocator of the isolate. The result can be later passed to
+   * buffer allocator of the isolate. The allocation can either be zero
+   * intialized, or uninitialized. The result can be later passed to
    * SharedArrayBuffer::New.
    *
    * If the allocator returns nullptr, then the function may cause GCs in the
    * given isolate and re-try the allocation. If GCs do not help, then the
    * function will crash with an out-of-memory error.
    */
-  static std::unique_ptr<BackingStore> NewBackingStore(Isolate* isolate,
-                                                       size_t byte_length);
+  static std::unique_ptr<BackingStore> NewBackingStore(
+      Isolate* isolate, size_t byte_length,
+      BackingStoreInitializationMode initialization_mode =
+          BackingStoreInitializationMode::kZeroInitialized);
   /**
    * Returns a new standalone BackingStore that takes over the ownership of
    * the given buffer. The destructor of the BackingStore invokes the given
@@ -506,7 +525,8 @@ class V8_EXPORT SharedArrayBuffer : public Object {
     return static_cast<SharedArrayBuffer*>(value);
   }
 
-  static const int kInternalFieldCount = V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT;
+  static constexpr int kInternalFieldCount =
+      V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT;
 
  private:
   SharedArrayBuffer();

package/include/node/v8-callbacks.h

@@ -152,9 +152,6 @@ using JitCodeEventHandler = void (*)(const JitCodeEvent* event);
 enum GCType {
   kGCTypeScavenge = 1 << 0,
   kGCTypeMinorMarkSweep = 1 << 1,
-  kGCTypeMinorMarkCompact V8_DEPRECATE_SOON(
-      "Use kGCTypeMinorMarkSweep instead of kGCTypeMinorMarkCompact.") =
-      kGCTypeMinorMarkSweep,
   kGCTypeMarkSweepCompact = 1 << 2,
   kGCTypeIncrementalMarking = 1 << 3,
   kGCTypeProcessWeakCallbacks = 1 << 4,
@@ -234,7 +231,7 @@ using MessageCallback = void (*)(Local<Message> message, Local<Value> data);
 
 // --- Tracing ---
 
-enum LogEventStatus : int { kStart = 0, kEnd = 1, kStamp = 2 };
+enum LogEventStatus : int { kStart = 0, kEnd = 1, kLog = 2 };
 using LogEventCallback = void (*)(const char* name,
                                   int /* LogEventStatus */ status);
 
@@ -341,6 +338,14 @@ using JavaScriptCompileHintsMagicEnabledCallback =
 // --- Callback for checking if WebAssembly JSPI is enabled ---
 using WasmJSPIEnabledCallback = bool (*)(Local<Context> context);
 
+/**
+ * Import phases in import requests.
+ */
+enum class ModuleImportPhase {
+  kSource,
+  kEvaluation,
+};
+
 /**
  * HostImportModuleDynamicallyCallback is called when we
  * require the embedder to load a module. This is used as part of the dynamic
@@ -354,7 +359,7 @@ using WasmJSPIEnabledCallback = bool (*)(Local<Context> context);
  * The import_attributes are import attributes for this request in the form:
  * [key1, value1, key2, value2, ...] where the keys and values are of type
  * v8::String. Note, unlike the FixedArray passed to ResolveModuleCallback and
- * returned from ModuleRequest::GetImportAssertions(), this array does not
+ * returned from ModuleRequest::GetImportAttributes(), this array does not
  * contain the source Locations of the attributes.
  *
  * The embedder must compile, instantiate, evaluate the Module, and

package/include/node/v8-context.h

@@ -107,6 +107,10 @@ class V8_EXPORT Context : public Data {
    * configured if the default context snapshot contains no pointer embedder
    * data, or if no custom startup snapshot is configured in the
    * v8::CreateParams used to create the isolate.
+   *
+   * \param api_wrapper_deserializer An optional callback used to deserialize
+   * API wrapper objects that was initially set with v8::Object::Wrap() and then
+   * serialized using SerializeAPIWrapperCallback.
    */
   static Local<Context> New(
       Isolate* isolate, ExtensionConfiguration* extensions = nullptr,
@@ -116,17 +120,19 @@ class V8_EXPORT Context : public Data {
           DeserializeInternalFieldsCallback(),
       MicrotaskQueue* microtask_queue = nullptr,
       DeserializeContextDataCallback context_data_deserializer =
-          DeserializeContextDataCallback());
+          DeserializeContextDataCallback(),
+      DeserializeAPIWrapperCallback api_wrapper_deserializer =
+          DeserializeAPIWrapperCallback());
 
   /**
    * Create a new context from a (non-default) context snapshot. There
    * is no way to provide a global object template since we do not create
    * a new global object from template, but we can reuse a global object.
    *
-   * \param isolate See v8::Context::New.
+   * \param isolate See v8::Context::New().
    *
    * \param context_snapshot_index The index of the context snapshot to
-   * deserialize from. Use v8::Context::New for the default snapshot.
+   * deserialize from. Use v8::Context::New() for the default snapshot.
    *
    * \param internal_fields_deserializer An optional callback used
    * to deserialize fields set by
@@ -136,19 +142,23 @@ class V8_EXPORT Context : public Data {
    * pointer fields in the default context snapshot or if no startup
    * snapshot is configured when the isolate is created.
    *
-   * \param extensions See v8::Context::New.
+   * \param extensions See v8::Context::New().
    *
-   * \param global_object See v8::Context::New.
+   * \param global_object See v8::Context::New().
    *
    * \param internal_fields_deserializer Similar to
-   * internal_fields_deserializer in v8::Context::New but applies to
+   * internal_fields_deserializer in v8::Context::New() but applies to
    * the context specified by the context_snapshot_index.
    *
-   * \param microtask_queue  See v8::Context::New.
+   * \param microtask_queue  See v8::Context::New().
    *
    * \param context_data_deserializer  Similar to
-   * context_data_deserializer in v8::Context::New but applies to
+   * context_data_deserializer in v8::Context::New() but applies to
    * the context specified by the context_snapshot_index.
+   *
+   *\param api_wrapper_deserializer Similar to api_wrapper_deserializer in
+   * v8::Context::New() but applies to the context specified by the
+   * context_snapshot_index.
    */
   static MaybeLocal<Context> FromSnapshot(
       Isolate* isolate, size_t context_snapshot_index,
@@ -158,7 +168,9 @@ class V8_EXPORT Context : public Data {
       MaybeLocal<Value> global_object = MaybeLocal<Value>(),
       MicrotaskQueue* microtask_queue = nullptr,
       DeserializeContextDataCallback context_data_deserializer =
-          DeserializeContextDataCallback());
+          DeserializeContextDataCallback(),
+      DeserializeAPIWrapperCallback api_wrapper_deserializer =
+          DeserializeAPIWrapperCallback());
 
   /**
    * Returns an global object that isn't backed by an actual context.
@@ -290,6 +302,8 @@ class V8_EXPORT Context : public Data {
    * SetAlignedPointerInEmbedderData with the same index. Note that index 0
    * currently has a special meaning for Chrome's debugger.
    */
+  V8_INLINE void* GetAlignedPointerFromEmbedderData(Isolate* isolate,
+                                                    int index);
   V8_INLINE void* GetAlignedPointerFromEmbedderData(int index);
 
   /**
@@ -444,6 +458,24 @@ Local<Value> Context::GetEmbedderData(int index) {
 #endif
 }
 
+void* Context::GetAlignedPointerFromEmbedderData(Isolate* isolate, int index) {
+#if !defined(V8_ENABLE_CHECKS)
+  using A = internal::Address;
+  using I = internal::Internals;
+  A ctx = internal::ValueHelper::ValueAsAddress(this);
+  A embedder_data =
+      I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);
+  int value_offset = I::kEmbedderDataArrayHeaderSize +
+                     (I::kEmbedderDataSlotSize * index) +
+                     I::kEmbedderDataSlotExternalPointerOffset;
+  return reinterpret_cast<void*>(
+      I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>(
+          isolate, embedder_data, value_offset));
+#else
+  return SlowGetAlignedPointerFromEmbedderData(index);
+#endif
+}
+
 void* Context::GetAlignedPointerFromEmbedderData(int index) {
 #if !defined(V8_ENABLE_CHECKS)
   using A = internal::Address;

package/include/node/v8-cppgc.h

@@ -32,62 +32,15 @@ class CppHeap;
 
 class CustomSpaceStatisticsReceiver;
 
-/**
- * Describes how V8 wrapper objects maintain references to garbage-collected C++
- * objects.
- */
-struct WrapperDescriptor final {
-  /**
-   * The index used on `v8::Ojbect::SetAlignedPointerFromInternalField()` and
-   * related APIs to add additional data to an object which is used to identify
-   * JS->C++ references.
-   */
-  using InternalFieldIndex = int;
-
-  /**
-   * Unknown embedder id. The value is reserved for internal usages and must not
-   * be used with `CppHeap`.
-   */
-  static constexpr uint16_t kUnknownEmbedderId = UINT16_MAX;
-
-  constexpr WrapperDescriptor(InternalFieldIndex wrappable_type_index,
-                              InternalFieldIndex wrappable_instance_index,
-                              uint16_t embedder_id_for_garbage_collected)
-      : wrappable_type_index(wrappable_type_index),
-        wrappable_instance_index(wrappable_instance_index),
-        embedder_id_for_garbage_collected(embedder_id_for_garbage_collected) {}
-
-  /**
-   * Index of the wrappable type.
-   */
-  InternalFieldIndex wrappable_type_index;
-
-  /**
-   * Index of the wrappable instance.
-   */
-  InternalFieldIndex wrappable_instance_index;
-
-  /**
-   * Embedder id identifying instances of garbage-collected objects. It is
-   * expected that the first field of the wrappable type is a uint16_t holding
-   * the id. Only references to instances of wrappables types with an id of
-   * `embedder_id_for_garbage_collected` will be considered by CppHeap.
-   */
-  uint16_t embedder_id_for_garbage_collected;
-};
-
 struct V8_EXPORT CppHeapCreateParams {
-  CppHeapCreateParams(
-      std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces,
-      WrapperDescriptor wrapper_descriptor)
-      : custom_spaces(std::move(custom_spaces)),
-        wrapper_descriptor(wrapper_descriptor) {}
+  explicit CppHeapCreateParams(
+      std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces)
+      : custom_spaces(std::move(custom_spaces)) {}
 
   CppHeapCreateParams(const CppHeapCreateParams&) = delete;
   CppHeapCreateParams& operator=(const CppHeapCreateParams&) = delete;
 
   std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces;
-  WrapperDescriptor wrapper_descriptor;
   /**
    * Specifies which kind of marking are supported by the heap. The type may be
    * further reduced via runtime flags when attaching the heap to an Isolate.
@@ -177,11 +130,6 @@ class V8_EXPORT CppHeap {
   void CollectGarbageInYoungGenerationForTesting(
       cppgc::EmbedderStackState stack_state);
 
-  /**
-   * \returns the wrapper descriptor of this CppHeap.
-   */
-  v8::WrapperDescriptor wrapper_descriptor() const;
-
  private:
   CppHeap() = default;
 

package/include/node/v8-date.h

@@ -21,6 +21,10 @@ class V8_EXPORT Date : public Object {
   static V8_WARN_UNUSED_RESULT MaybeLocal<Value> New(Local<Context> context,
                                                      double time);
 
+  static V8_WARN_UNUSED_RESULT MaybeLocal<Value> Parse(
+      Local<Context> context,
+      Local<String> date_string);
+
   /**
    * A specialization of Value::NumberValue that is more efficient
    * because we know the structure of this object.
@@ -32,6 +36,11 @@ class V8_EXPORT Date : public Object {
    */
   v8::Local<v8::String> ToISOString() const;
 
+  /**
+   * Generates UTC string representation.
+   */
+  v8::Local<v8::String> ToUTCString() const;
+
   V8_INLINE static Date* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS
     CheckCast(value);

package/include/node/v8-embedder-heap.h

@@ -29,6 +29,8 @@ class V8_EXPORT EmbedderRootsHandler {
   virtual ~EmbedderRootsHandler() = default;
 
   EmbedderRootsHandler() = default;
+
+  V8_DEPRECATED("Use the default constructor instead.")
   explicit EmbedderRootsHandler(RootHandling default_traced_reference_handling)
       : default_traced_reference_handling_(default_traced_reference_handling) {}
 
@@ -47,6 +49,7 @@ class V8_EXPORT EmbedderRootsHandler {
    *
    * The concrete implementations must be thread-safe.
    */
+  V8_DEPRECATED("Use TracedReferenceHandling::kDroppable instead.")
   virtual bool IsRoot(const v8::TracedReference<v8::Value>& handle) = 0;
 
   /**
@@ -72,7 +75,7 @@ class V8_EXPORT EmbedderRootsHandler {
 
  private:
   const RootHandling default_traced_reference_handling_ =
-      RootHandling::kQueryEmbedderForNonDroppableReferences;
+      RootHandling::kDontQueryEmbedderForAnyReference;
 
   friend class internal::TracedHandles;
 };

package/include/node/v8-exception.h

@@ -8,6 +8,7 @@
 #include <stddef.h>
 
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-object.h"        // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
 namespace v8 {
@@ -58,8 +59,77 @@ class V8_EXPORT Exception {
    * of a given exception, or an empty handle if not available.
    */
   static Local<StackTrace> GetStackTrace(Local<Value> exception);
+
+  /**
+   * Captures the current stack trace and attaches it to the given object in the
+   * form of `stack` property.
+   */
+  static Maybe<bool> CaptureStackTrace(Local<Context> context,
+                                       Local<Object> object);
 };
 
+/**
+ * This is a part of experimental Api and might be changed without further
+ * notice.
+ * Do not use it.
+ */
+enum class ExceptionContext : uint32_t {
+  kUnknown,
+  kConstructor,
+  kOperation,
+  kAttributeGet,
+  kAttributeSet,
+  kIndexedQuery,
+  kIndexedGetter,
+  kIndexedDescriptor,
+  kIndexedSetter,
+  kIndexedDefiner,
+  kIndexedDeleter,
+  kNamedQuery,
+  kNamedGetter,
+  kNamedDescriptor,
+  kNamedSetter,
+  kNamedDefiner,
+  kNamedDeleter,
+  kNamedEnumerator
+};
+
+/**
+ * This is a part of experimental Api and might be changed without further
+ * notice.
+ * Do not use it.
+ */
+class ExceptionPropagationMessage {
+ public:
+  ExceptionPropagationMessage(v8::Isolate* isolate, Local<Object> exception,
+                              Local<String> interface_name,
+                              Local<String> property_name,
+                              ExceptionContext exception_context)
+      : isolate_(isolate),
+        exception_(exception),
+        interface_name_(interface_name),
+        property_name_(property_name),
+        exception_context_(exception_context) {}
+
+  V8_INLINE Isolate* GetIsolate() const { return isolate_; }
+  V8_INLINE Local<Object> GetException() const { return exception_; }
+  V8_INLINE Local<String> GetInterfaceName() const { return interface_name_; }
+  V8_INLINE Local<String> GetPropertyName() const { return property_name_; }
+  V8_INLINE ExceptionContext GetExceptionContext() const {
+    return exception_context_;
+  }
+
+ private:
+  Isolate* isolate_;
+  Local<Object> exception_;
+  Local<String> interface_name_;
+  Local<String> property_name_;
+  ExceptionContext exception_context_;
+};
+
+using ExceptionPropagationCallback =
+    void (*)(ExceptionPropagationMessage message);
+
 /**
  * An external exception handler.
  */