node-darwin-x64 25.8.2 → 26.0.0

package/include/node/v8-wasm.h

@@ -8,6 +8,7 @@
 #include <functional>
 #include <memory>
 #include <string>
+#include <variant>
 
 #include "v8-internal.h"      // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
@@ -20,12 +21,9 @@ namespace v8 {
 class ArrayBuffer;
 class Promise;
 
-namespace internal {
-namespace wasm {
+namespace internal::wasm {
 class NativeModule;
-class StreamingDecoder;
-}  // namespace wasm
-}  // namespace internal
+}  // namespace internal::wasm
 
 /**
  * An owned byte buffer with associated size.
@@ -38,8 +36,10 @@ struct OwnedBuffer {
   OwnedBuffer() = default;
 };
 
-// Wrapper around a compiled WebAssembly module, which is potentially shared by
-// different WasmModuleObjects.
+/**
+ * Wrapper around a compiled WebAssembly module, which is potentially shared by
+ * different WasmModuleObjects.
+ */
 class V8_EXPORT CompiledWasmModule {
  public:
   /**
@@ -56,11 +56,12 @@ class V8_EXPORT CompiledWasmModule {
   const std::string& source_url() const { return source_url_; }
 
  private:
+  friend class WasmModuleCompilation;
   friend class WasmModuleObject;
   friend class WasmStreaming;
 
   explicit CompiledWasmModule(std::shared_ptr<internal::wasm::NativeModule>,
-                              const char* source_url, size_t url_length);
+                              std::string source_url);
 
   const std::shared_ptr<internal::wasm::NativeModule> native_module_;
   const std::string source_url_;
@@ -134,6 +135,22 @@ class V8_EXPORT WasmStreaming final {
       internal::kWasmWasmStreamingTag;
   class WasmStreamingImpl;
 
+  class ModuleCachingInterface {
+   public:
+    // Get the full wire bytes, to check against the cached version.
+    virtual MemorySpan<const uint8_t> GetWireBytes() const = 0;
+    // Pass serialized (cached) compiled module bytes, to be deserialized and
+    // used as the result of this streaming compilation.
+    // The passed bytes will only be accessed inside this callback, i.e.
+    // lifetime can end after the call.
+    // The return value indicates whether V8 could use the passed bytes; {false}
+    // would be returned on e.g. version mismatch.
+    // This method can only be called once.
+    virtual bool SetCachedCompiledModuleBytes(MemorySpan<const uint8_t>) = 0;
+  };
+
+  using ModuleCachingCallback = std::function<void(ModuleCachingInterface&)>;
+
   explicit WasmStreaming(std::unique_ptr<WasmStreamingImpl> impl);
 
   ~WasmStreaming();
@@ -148,12 +165,12 @@ class V8_EXPORT WasmStreaming final {
    * {Finish} should be called after all received bytes where passed to
    * {OnBytesReceived} to tell V8 that there will be no more bytes. {Finish}
    * must not be called after {Abort} has been called already.
-   * If {can_use_compiled_module} is true and {SetCompiledModuleBytes} was
-   * previously called, the compiled module bytes can be used.
-   * If {can_use_compiled_module} is false, the compiled module bytes previously
-   * set by {SetCompiledModuleBytes} should not be used.
+   * If {SetHasCompiledModuleBytes()} was called before, a {caching_callback}
+   * can be passed which can inspect the full received wire bytes and set cached
+   * module bytes which will be deserialized then. This callback will happen
+   * synchronously within this call; the callback is not stored.
    */
-  void Finish(bool can_use_compiled_module = true);
+  void Finish(const ModuleCachingCallback& caching_callback);
 
   /**
    * Abort streaming compilation. If {exception} has a value, then the promise
@@ -164,15 +181,14 @@ class V8_EXPORT WasmStreaming final {
   void Abort(MaybeLocal<Value> exception);
 
   /**
-   * Passes previously compiled module bytes. This must be called before
-   * {OnBytesReceived}, {Finish}, or {Abort}. Returns true if the module bytes
-   * can be used, false otherwise. The buffer passed via {bytes} and {size}
-   * is owned by the caller. If {SetCompiledModuleBytes} returns true, the
-   * buffer must remain valid until either {Finish} or {Abort} completes.
-   * The compiled module bytes should not be used until {Finish(true)} is
-   * called, because they can be invalidated later by {Finish(false)}.
+   * Mark that the embedder has (potentially) cached compiled module bytes (i.e.
+   * a serialized {CompiledWasmModule}) that could match this streaming request.
+   * This will cause V8 to skip streaming compilation.
+   * The embedder should then pass a callback to the {Finish} method to pass the
+   * serialized bytes, after potentially checking their validity against the
+   * full received wire bytes.
    */
-  bool SetCompiledModuleBytes(const uint8_t* bytes, size_t size);
+  void SetHasCompiledModuleBytes();
 
   /**
    * Sets a callback which is called whenever a significant number of new
@@ -199,6 +215,87 @@ class V8_EXPORT WasmStreaming final {
   std::unique_ptr<WasmStreamingImpl> impl_;
 };
 
+/**
+ * An interface for asynchronous WebAssembly module compilation, to be used e.g.
+ * for implementing source phase imports.
+ * Note: This interface is experimental and can change or be removed without
+ * notice.
+ */
+class V8_EXPORT WasmModuleCompilation final {
+ public:
+  using ModuleCachingCallback = WasmStreaming::ModuleCachingCallback;
+
+  /**
+   * Start an asynchronous module compilation. This can be called on any thread.
+   * TODO(clemensb): Add some way to pass enabled features.
+   * TODO(clemensb): Add some way to pass compile time imports.
+   */
+  WasmModuleCompilation();
+
+  ~WasmModuleCompilation();
+
+  WasmModuleCompilation(const WasmModuleCompilation&) = delete;
+  WasmModuleCompilation& operator=(const WasmModuleCompilation&) = delete;
+
+  /**
+   * Pass a new chunk of bytes to WebAssembly compilation.
+   * The buffer passed into {OnBytesReceived} is owned by the caller and will
+   * not be accessed any more after this call returns.
+   */
+  void OnBytesReceived(const uint8_t* bytes, size_t size);
+
+  /**
+   * {Finish} must be called on the main thread after all bytes were passed to
+   * {OnBytesReceived}.
+   * It eventually calls the provided callback to deliver the compiled module or
+   * an error. This callback will also be called in foreground, but not
+   * necessarily within this call.
+   * {Finish} must not be called after {Abort} has been called already.
+   * If {SetHasCompiledModuleBytes()} was called before, a {caching_callback}
+   * can be passed which can inspect the full received wire bytes and set cached
+   * module bytes which will be deserialized then. This callback will happen
+   * synchronously within this call; the callback is not stored.
+   */
+  void Finish(
+      Isolate*, const ModuleCachingCallback& caching_callback,
+      const std::function<void(
+          std::variant<Local<WasmModuleObject>, Local<Value>> module_or_error)>&
+          resolution_callback);
+
+  /**
+   * Abort compilation. This can be called from any thread.
+   * {Abort} must not be called repeatedly, or after {Finish}.
+   */
+  void Abort();
+
+  /**
+   * Mark that the embedder has (potentially) cached compiled module bytes (i.e.
+   * a serialized {CompiledWasmModule}) that could match this streaming request.
+   * This will cause V8 to skip streaming compilation.
+   * The embedder should then pass a callback to the {Finish} method to pass the
+   * serialized bytes, after potentially checking their validity against the
+   * full received wire bytes.
+   */
+  void SetHasCompiledModuleBytes();
+
+  /**
+   * Sets a callback which is called whenever a significant number of new
+   * functions are ready for serialization.
+   */
+  void SetMoreFunctionsCanBeSerializedCallback(
+      std::function<void(CompiledWasmModule)>);
+
+  /*
+   * Sets the UTF-8 encoded source URL for the {Script} object. This must be
+   * called before {Finish}.
+   */
+  void SetUrl(const char* url, size_t length);
+
+ private:
+  class Impl;
+  const std::unique_ptr<Impl> impl_;
+};
+
 /**
  * The V8 interface for a WebAssembly memory map descriptor. This is an
  * experimental feature that may change and be removed without further

package/include/node/v8config.h

@@ -335,7 +335,6 @@ path. Add it with -I<path> to the command line
 //                                      - [[no_unique_address]] supported
 //  V8_HAS_CPP_ATTRIBUTE_LIFETIME_BOUND - [[clang::lifetimebound]] supported
 //  V8_HAS_BUILTIN_ADD_OVERFLOW         - __builtin_add_overflow() supported
-//  V8_HAS_BUILTIN_BIT_CAST             - __builtin_bit_cast() supported
 //  V8_HAS_BUILTIN_BSWAP16              - __builtin_bswap16() supported
 //  V8_HAS_BUILTIN_BSWAP32              - __builtin_bswap32() supported
 //  V8_HAS_BUILTIN_BSWAP64              - __builtin_bswap64() supported
@@ -418,7 +417,6 @@ path. Add it with -I<path> to the command line
 # define V8_HAS_BUILTIN_ADD_OVERFLOW (__has_builtin(__builtin_add_overflow))
 # define V8_HAS_BUILTIN_ASSUME (__has_builtin(__builtin_assume))
 # define V8_HAS_BUILTIN_ASSUME_ALIGNED (__has_builtin(__builtin_assume_aligned))
-# define V8_HAS_BUILTIN_BIT_CAST (__has_builtin(__builtin_bit_cast))
 # define V8_HAS_BUILTIN_BSWAP16 (__has_builtin(__builtin_bswap16))
 # define V8_HAS_BUILTIN_BSWAP32 (__has_builtin(__builtin_bswap32))
 # define V8_HAS_BUILTIN_BSWAP64 (__has_builtin(__builtin_bswap64))
@@ -473,9 +471,6 @@ path. Add it with -I<path> to the command line
 // for V8_HAS_CPP_ATTRIBUTE_NODISCARD. See https://crbug.com/v8/11707.
 
 # define V8_HAS_BUILTIN_ASSUME_ALIGNED 1
-# if __GNUC__ >= 11
-#  define V8_HAS_BUILTIN_BIT_CAST 1
-# endif
 # define V8_HAS_BUILTIN_CLZ 1
 # define V8_HAS_BUILTIN_CTZ 1
 # define V8_HAS_BUILTIN_EXPECT 1
@@ -546,9 +541,8 @@ path. Add it with -I<path> to the command line
 # define V8_ASSUME USE
 #endif
 
-// Prefer c++20 std::assume_aligned. Don't use it on MSVC though, because it's
-// not happy with our large 4GB alignment values.
-#if __cplusplus >= 202002L && defined(__cpp_lib_assume_aligned) && !V8_CC_MSVC
+// Prefer c++20 std::assume_aligned.
+#if __cplusplus >= 202002L && defined(__cpp_lib_assume_aligned)
 # define V8_ASSUME_ALIGNED(ptr, alignment) \
   std::assume_aligned<(alignment)>(ptr)
 #elif V8_HAS_BUILTIN_ASSUME_ALIGNED
@@ -1072,4 +1066,12 @@ arm64 host
 #define V8_TARGET_BIG_ENDIAN_BOOL false
 #endif
 
+// V8_USE_PERFETTO_SDK and V8_USE_PERFETTO_JSON_EXPORT must imply
+// V8_USE_PERFETTO.
+#if (defined(V8_USE_PERFETTO_SDK) || defined(V8_USE_PERFETTO_JSON_EXPORT)) && \
+    !defined(V8_USE_PERFETTO)
+#error Inconsistent build configuration: To build the V8 with Perfetto \
+features, set V8_USE_PERFETTO as well.
+#endif
+
 #endif  // V8CONFIG_H_

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-darwin-x64",
-  "version": "25.8.2",
+  "version": "26.0.0",
   "description": "node",
   "repository": {
     "url": "git+https://github.com/aredridel/node-bin-gen.git"

package/share/doc/node/gdbinit

@@ -182,6 +182,15 @@ Print the current JavaScript stack trace
 Usage: jst
 end
 
+# Print JavaScript stack trace in concise format
+define jstc
+call (void) _v8_internal_Print_StackTraceConcise()
+end
+document jstc
+Print the current JavaScript stack trace in concise format
+Usage: jstc
+end
+
 # Print TurboFan graph node.
 define pn
 call _v8_internal_Node_Print((void*)($arg0))
@@ -733,3 +742,73 @@ def direct_handle_pretty_printers(val):
 gdb.pretty_printers.append(direct_handle_pretty_printers)
 
 end
+
+python
+
+# V8 JIT-compiled frame unwinder for x86-64.
+# See https://sourceware.org/gdb/current/onlinedocs/gdb.html/Unwinding-Frames-in-Python.html
+
+from gdb.unwinder import Unwinder, FrameId
+
+class V8Unwinder(Unwinder):
+  """Unwinder for V8 JIT-compiled frames by following the RBP chain on x86-64."""
+
+  PTR_SIZE = 8  # x86-64
+
+  @staticmethod
+  def read_u64(addr):
+    """Return little-endian uint64 from inferior memory, or raise gdb.MemoryError."""
+    inferior = gdb.selected_inferior()
+    data = inferior.read_memory(addr, V8Unwinder.PTR_SIZE)
+    return int.from_bytes(data.tobytes(), byteorder="little", signed=False)
+
+  def __init__(self):
+    super(V8Unwinder, self).__init__("V8Unwinder")
+    self.enabled = True
+
+  def __call__(self, pending_frame):
+    try:
+      arch = pending_frame.architecture()
+      if arch.name() != "i386:x86-64":
+        return None  # Don't use this unwinder if not on x86-64.
+      if pending_frame.name() is not None:
+        return None  # gdb can already symbolicate this, likely not a JIT frame.
+
+      fp = int(pending_frame.read_register("rbp"))
+
+      if fp == 0 or (fp & 0x7) != 0:  # Chain ends or misaligned.
+        return None
+
+      # Now we know we are likely in a V8 JIT-compiled frame.
+      # Stack layout:
+      # rbp+16  <-- caller's rsp before `call`
+      # rbp+8   [ return address (saved rip) ]
+      # rbp+0   [ saved rbp                  ] <-- current frame pointer
+      prev_rsp = fp + self.PTR_SIZE * 2
+      ret_addr = self.read_u64(fp + self.PTR_SIZE)
+      prev_rbp = self.read_u64(fp)
+
+      if ret_addr == 0 or prev_rbp == 0:
+        return None  # Invalid frame.
+
+      # GDB needs a Frame ID to identify the frame.
+      # 1. A stack address that is stable across the lifetime of a frame.
+      #    We use the previous frame's rsp.
+      # 2. A code address that is stable across the lifetime of a frame.
+      #    Ideally, the function's start address. We don't have symbols here,
+      #    so it's not easy to find out. Use the return address as an
+      #    approximation.
+      # See https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gdb/frame-id.h
+      frame_id = FrameId(prev_rsp, ret_addr)
+      unwind_info = pending_frame.create_unwind_info(frame_id)
+      unwind_info.add_saved_register("rsp", gdb.Value(prev_rsp))
+      unwind_info.add_saved_register("rip", gdb.Value(ret_addr))
+      unwind_info.add_saved_register("rbp", gdb.Value(prev_rbp))
+      return unwind_info
+
+    except Exception:
+      return None  # Give up unwinding on errors.
+
+gdb.unwinder.register_unwinder(None, V8Unwinder(), replace=True)
+
+end

package/share/doc/node/lldb_commands.py

@@ -218,6 +218,12 @@ def jst(debugger, *args):
   no_arg_cmd(debugger, "_v8_internal_Print_StackTrace()")
 
 
+@lldbCommand
+def jstc(debugger, *args):
+  """Print the current JavaScript stack trace in a concise format"""
+  no_arg_cmd(debugger, "_v8_internal_Print_StackTraceConcise()")
+
+
 @lldbCommand
 def pn(debugger, param, *args):
   """Print a v8 TurboFan graph node"""

package/share/man/man1/node.1

@@ -720,6 +720,11 @@ top-level awaits, and print their location to help users find them.
 .It Fl -experimental-quic
 Enable experimental support for the QUIC protocol.
 .
+.It Fl -experimental-stream-iter
+Enable the experimental
+.Sy node:stream/iter
+module.
+.
 .It Fl -experimental-sea-config
 Use this flag to generate a blob that can be injected into the Node.js
 binary to produce a single executable application. See the documentation
@@ -741,10 +746,6 @@ collecting code coverage from tests for more details.
 Enable module mocking in the test runner.
 This feature requires \fB--allow-worker\fR if used with the Permission Model.
 .
-.It Fl -experimental-transform-types
-Enables the transformation of TypeScript-only syntax into JavaScript code.
-Implies \fB--enable-source-maps\fR.
-.
 .It Fl -experimental-vm-modules
 Enable experimental ES Module support in the \fBnode:vm\fR module.
 .
@@ -1883,8 +1884,6 @@ one is included in the list below.
 .It
 \fB--experimental-top-level-await\fR
 .It
-\fB--experimental-transform-types\fR
-.It
 \fB--experimental-vm-modules\fR
 .It
 \fB--experimental-wasi-unstable-preview1\fR
@@ -2293,7 +2292,7 @@ that run in libuv's threadpool will experience degraded performance. In order to
 mitigate this issue, one potential solution is to increase the size of libuv's
 threadpool by setting the \fB'UV_THREADPOOL_SIZE'\fR environment variable to a value
 greater than \fB4\fR (its current default value). However, setting this from inside
-the process using \fBprocess.env.UV_THREADPOOL_SIZE=size\fR is not guranteed to work
+the process using \fBprocess.env.UV_THREADPOOL_SIZE=size\fR is not guaranteed to work
 as the threadpool would have been created as part of the runtime initialisation
 much before user code is run. For more information, see the libuv threadpool documentation.
 .