node-darwin-x64 25.9.0 → 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.9.0",
+  "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

@@ -746,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.
 .
@@ -1888,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