From 9ea644c03aa061eaa87d9043da1f77130d206001 Mon Sep 17 00:00:00 2001
From: SudhansuBandha <bandhasudhansu@gmail.com>
Date: Thu, 27 Aug 2026 11:32:58 +0530
Subject: [PATCH 1/3] worker: emit worker exit notifications on
 BroadcastChannel

Expose worker termination notifications through BroadcastChannel
so consumers can observe when a worker exits andinspect
its thread ID and exit code.

Fixes: https://github.com/nodejs/node/issues/59053
Signed-off-by: SudhansuBandha <bandhasudhansu@gmail.com>
---
 doc/api/worker_threads.md                     | 19 ++++
 lib/internal/worker/io.js                     |  6 ++
 src/node_messaging.cc                         | 89 ++++++++++++++++++-
 src/node_messaging.h                          | 16 ++++
 test/parallel/test-worker-broadcastchannel.js | 27 ++++++
 5 files changed, 156 insertions(+), 1 deletion(-)

diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index e7b6b19b355..9e96840b13b 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -987,6 +987,25 @@ added: v15.4.0
 * Type: {Function} Invoked with a received message cannot be
   deserialized.
 
+### `broadcastChannel.onworkerexited`
+
+* Type: {Function} Invoked when worker associated with the
+  `BroadcastChannel` terminates.
+
+The callback receives an object with the following properties:
+
+* `threadId` {number} The ID of the worker thread that terminated.
+* `exitCode` {number} The exit code with which the worker terminated.
+
+The `exitCode` is the value passed to `process.exit()` when the worker
+explicitly exits. If the worker terminates without explicitly specifying
+an exit code, the corresponding exit code is reported.
+
+The `workerexited` event is emitted only when the worker's execution
+environment is stopping. Closing a `BroadcastChannel` or its underlying
+`MessagePort` does not by itself indicate that a worker has exited and
+does not emit this event.
+
 ### `broadcastChannel.postMessage(message)`
 
 <!-- YAML
diff --git a/lib/internal/worker/io.js b/lib/internal/worker/io.js
index 011c00b0149..e213e9d3f9c 100644
--- a/lib/internal/worker/io.js
+++ b/lib/internal/worker/io.js
@@ -74,6 +74,7 @@ const kIncrementsPortRef = Symbol('kIncrementsPortRef');
 const kName = Symbol('kName');
 const kOnMessage = Symbol('kOnMessage');
 const kOnMessageError = Symbol('kOnMessageError');
+const kOnWorkerExited = Symbol('kOnWorkerExited');
 const kPort = Symbol('kPort');
 const kWaitingStreams = Symbol('kWaitingStreams');
 const kWritableCallback = Symbol('kWritableCallback');
@@ -367,8 +368,10 @@ class BroadcastChannel extends EventTarget {
     this[kOnMessage] = FunctionPrototypeBind(onMessageEvent, this, 'message');
     this[kOnMessageError] =
       FunctionPrototypeBind(onMessageEvent, this, 'messageerror');
+    this[kOnWorkerExited] = FunctionPrototypeBind(onMessageEvent, this, 'workerexited');
     this[kHandle].on('message', this[kOnMessage]);
     this[kHandle].on('messageerror', this[kOnMessageError]);
+    this[kHandle].on('workerexited', this[kOnWorkerExited]);
   }
 
   [inspect.custom](depth, options) {
@@ -407,8 +410,10 @@ class BroadcastChannel extends EventTarget {
       return;
     this[kHandle].off('message', this[kOnMessage]);
     this[kHandle].off('messageerror', this[kOnMessageError]);
+    this[kHandle].off('workerexited', this[kOnWorkerExited]);
     this[kOnMessage] = undefined;
     this[kOnMessageError] = undefined;
+    this[kOnWorkerExited] = undefined;
     this[kHandle].close();
     this[kHandle] = undefined;
   }
@@ -468,6 +473,7 @@ ObjectDefineProperties(BroadcastChannel.prototype, {
 
 defineEventHandler(BroadcastChannel.prototype, 'message');
 defineEventHandler(BroadcastChannel.prototype, 'messageerror');
+defineEventHandler(BroadcastChannel.prototype, 'workerexited');
 
 function markAsUncloneable(obj) {
   if ((typeof obj !== 'object' && typeof obj !== 'function') || obj === null) {
diff --git a/src/node_messaging.cc b/src/node_messaging.cc
index 5a0c4962d3f..dd6ed8b07c1 100644
--- a/src/node_messaging.cc
+++ b/src/node_messaging.cc
@@ -648,6 +648,32 @@ void MessagePortData::AddToIncomingQueue(std::shared_ptr<Message> message) {
   }
 }
 
+void MessagePortData::AddWorkerExitNotification(uint64_t thread_id,
+                                                ExitCode exit_code) {
+  Mutex::ScopedLock lock(mutex_);
+  worker_exit_notifications_.emplace_back(WorkerExitNotification{
+      thread_id,
+      exit_code,
+  });
+
+  if (owner_ != nullptr) {
+    Debug(owner_, "Adding worker-exit notification");
+    owner_->TriggerAsync();
+  }
+}
+
+bool MessagePortData::GetWorkerExitNotification(
+    WorkerExitNotification* notification) {
+  Mutex::ScopedLock lock(mutex_);
+
+  if (worker_exit_notifications_.empty()) return false;
+
+  *notification = worker_exit_notifications_.front();
+  worker_exit_notifications_.pop_front();
+
+  return true;
+}
+
 void MessagePortData::Entangle(MessagePortData* a, MessagePortData* b) {
   auto group = std::make_shared<SiblingGroup>();
   group->Entangle({a, b});
@@ -823,6 +849,7 @@ void MessagePort::OnMessage(MessageProcessingMode mode) {
   HandleScope handle_scope(env()->isolate());
   Local<Context> context =
       object(env()->isolate())->GetCreationContextChecked();
+  Local<Function> emit_message = PersistentToLocal::Strong(emit_message_fn_);
 
   size_t processing_limit;
   if (mode == MessageProcessingMode::kNormalOperation) {
@@ -850,9 +877,43 @@ void MessagePort::OnMessage(MessageProcessingMode mode) {
       return;
     }
 
+    MessagePortData::WorkerExitNotification worker_exit;
+
+    if (data_->GetWorkerExitNotification(&worker_exit)) {
+      Debug(this,
+            "Worker exited: thread_id=%" PRIu64 ", exit_code=%d",
+            worker_exit.thread_id,
+            static_cast<int>(worker_exit.exit_code));
+
+      Local<Object> exit_info = Object::New(env()->isolate());
+
+      exit_info
+          ->Set(context,
+                FIXED_ONE_BYTE_STRING(env()->isolate(), "threadId"),
+                v8::Number::New(env()->isolate(), worker_exit.thread_id))
+          .Check();
+
+      exit_info
+          ->Set(context,
+                FIXED_ONE_BYTE_STRING(env()->isolate(), "exitCode"),
+                v8::Integer::New(env()->isolate(),
+                                 static_cast<int>(worker_exit.exit_code)))
+          .Check();
+
+      Local<Value> argv[3];
+      argv[0] = exit_info;
+      argv[1] = Undefined(env()->isolate());
+      argv[2] = FIXED_ONE_BYTE_STRING(env()->isolate(), "workerexited");
+
+      if (MakeCallback(emit_message, arraysize(argv), argv).IsEmpty()) {
+        if (data_) TriggerAsync();
+        return;
+      }
+      continue;
+    }
+
     HandleScope handle_scope(env()->isolate());
     Context::Scope context_scope(context);
-    Local<Function> emit_message = PersistentToLocal::Strong(emit_message_fn_);
 
     Local<Value> payload;
     Local<Value> port_list = Undefined(env()->isolate());
@@ -901,6 +962,20 @@ void MessagePort::OnMessage(MessageProcessingMode mode) {
 void MessagePort::OnClose() {
   Debug(this, "MessagePort::OnClose()");
   if (data_) {
+    Environment* environment = env();
+    if (environment->is_stopping()) {
+      const uint64_t thread_id = environment->thread_id();
+      const ExitCode exit_code = environment->exit_code(ExitCode::kNoFailure);
+
+      Debug(this,
+            "Worker exiting: thread_id=%" PRIu64 ", exit_code=%d",
+            thread_id,
+            static_cast<int>(exit_code));
+
+      if (data_->group_) {
+        data_->group_->NotifyWorkerExit(data_.get(), thread_id, exit_code);
+      }
+    }
     // Detach() returns move(data_).
     Detach()->Disentangle();
   }
@@ -1587,6 +1662,18 @@ void SiblingGroup::Disentangle(MessagePortData* data) {
     (*(ports_.begin()))->AddToIncomingQueue(std::make_shared<Message>());
 }
 
+void SiblingGroup::NotifyWorkerExit(MessagePortData* exiting_port,
+                                    uint64_t thread_id,
+                                    ExitCode exit_code) {
+  RwLock::ScopedReadLock lock(group_mutex_);
+
+  for (MessagePortData* port : ports_) {
+    if (port == exiting_port) continue;
+
+    port->AddWorkerExitNotification(thread_id, exit_code);
+  }
+}
+
 SiblingGroup::Map SiblingGroup::groups_;
 Mutex SiblingGroup::groups_mutex_;
 
diff --git a/src/node_messaging.h b/src/node_messaging.h
index 0abd7da3bf0..0555ba77f36 100644
--- a/src/node_messaging.h
+++ b/src/node_messaging.h
@@ -149,6 +149,10 @@ class SiblingGroup final : public std::enable_shared_from_this<SiblingGroup> {
   void Entangle(std::initializer_list<MessagePortData*> data);
   void Disentangle(MessagePortData* data);
 
+  void NotifyWorkerExit(MessagePortData* exiting_port,
+                      uint64_t thread_id,
+                      ExitCode exit_code);
+
   const std::string& name() const { return name_; }
 
   size_t size() const { return ports_.size(); }
@@ -185,6 +189,9 @@ class MessagePortData : public TransferData {
   v8::Maybe<bool> Dispatch(
       std::shared_ptr<Message> message,
       std::string* error = nullptr);
+  
+  // Internal worker-exit notification.
+  void AddWorkerExitNotification(uint64_t thread_id, ExitCode exit_code);
 
   // Turns `a` and `b` into siblings, i.e. connects the sending side of one
   // to the receiving side of the other. This is not thread-safe.
@@ -213,6 +220,15 @@ class MessagePortData : public TransferData {
   // once that is available with C++17, because std::shared_ptr comes with
   // overhead that is only necessary for BroadcastChannel.
   std::deque<std::shared_ptr<Message>> incoming_messages_;
+  struct WorkerExitNotification {
+    uint64_t thread_id;
+    ExitCode exit_code;
+  };
+
+  bool GetWorkerExitNotification(WorkerExitNotification* notification);
+ 
+  std::deque<WorkerExitNotification> worker_exit_notifications_;
+  
   MessagePort* owner_ = nullptr;
   std::shared_ptr<SiblingGroup> group_;
   friend class MessagePort;
diff --git a/test/parallel/test-worker-broadcastchannel.js b/test/parallel/test-worker-broadcastchannel.js
index 12535271c15..3f67bd18739 100644
--- a/test/parallel/test-worker-broadcastchannel.js
+++ b/test/parallel/test-worker-broadcastchannel.js
@@ -183,3 +183,30 @@ assert.throws(() => new BroadcastChannel(), {
     "BroadcastChannel { name: 'channel5', active: false }"
   );
 }
+
+{
+  const bc = new BroadcastChannel('channel6');
+
+  const worker = new Worker(`
+    const { BroadcastChannel } = require('worker_threads');
+
+    const bc = new BroadcastChannel('channel6');
+
+    // Keep the BroadcastChannel alive long enough for the exit
+    // notification to be observed by the parent.
+    setImmediate(() => {
+      process.exit(42);
+    });
+  `, { eval: true });
+
+  bc.onworkerexited = common.mustCall((event) => {
+    assert.strictEqual(event.data.threadId, worker.threadId);
+    assert.strictEqual(event.data.exitCode, 42);
+
+    bc.close();
+  });
+
+  worker.on('exit', common.mustCall((exitCode) => {
+    assert.strictEqual(exitCode, 42);
+  }));
+}

From 4bb938346a8760e040dc2a6892b5367c49215486 Mon Sep 17 00:00:00 2001
From: SudhansuBandha <bandhasudhansu@gmail.com>
Date: Thu, 3 Sep 2026 12:31:49 +0530
Subject: [PATCH 2/3] worker: updated worker exit notification messaging
 pipeline

---
 doc/api/worker_threads.md |   4 ++
 src/node_messaging.cc     | 114 +++++++++++++++++---------------------
 src/node_messaging.h      |  29 +++++++---
 3 files changed, 76 insertions(+), 71 deletions(-)

diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index 9e96840b13b..30f79b4d178 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -989,6 +989,10 @@ added: v15.4.0
 
 ### `broadcastChannel.onworkerexited`
 
+<!-- YAML
+added: REPLACEME
+-->
+
 * Type: {Function} Invoked when worker associated with the
   `BroadcastChannel` terminates.
 
diff --git a/src/node_messaging.cc b/src/node_messaging.cc
index dd6ed8b07c1..8189b6dc16a 100644
--- a/src/node_messaging.cc
+++ b/src/node_messaging.cc
@@ -651,10 +651,9 @@ void MessagePortData::AddToIncomingQueue(std::shared_ptr<Message> message) {
 void MessagePortData::AddWorkerExitNotification(uint64_t thread_id,
                                                 ExitCode exit_code) {
   Mutex::ScopedLock lock(mutex_);
-  worker_exit_notifications_.emplace_back(WorkerExitNotification{
-      thread_id,
-      exit_code,
-  });
+  auto message = std::make_shared<Message>(
+    WorkerExitNotification{thread_id, exit_code});
+  AddToIncomingQueue(std::move(message));
 
   if (owner_ != nullptr) {
     Debug(owner_, "Adding worker-exit notification");
@@ -662,17 +661,6 @@ void MessagePortData::AddWorkerExitNotification(uint64_t thread_id,
   }
 }
 
-bool MessagePortData::GetWorkerExitNotification(
-    WorkerExitNotification* notification) {
-  Mutex::ScopedLock lock(mutex_);
-
-  if (worker_exit_notifications_.empty()) return false;
-
-  *notification = worker_exit_notifications_.front();
-  worker_exit_notifications_.pop_front();
-
-  return true;
-}
 
 void MessagePortData::Entangle(MessagePortData* a, MessagePortData* b) {
   auto group = std::make_shared<SiblingGroup>();
@@ -802,7 +790,8 @@ MessagePort* MessagePort::New(
 
 MaybeLocal<Value> MessagePort::ReceiveMessage(Local<Context> context,
                                               MessageProcessingMode mode,
-                                              Local<Value>* port_list) {
+                                              Local<Value>* port_list,
+                    std::optional<WorkerExitNotification>* worker_exit) {
   std::shared_ptr<Message> received;
   {
     // Get the head of the message queue.
@@ -827,6 +816,13 @@ MaybeLocal<Value> MessagePort::ReceiveMessage(Local<Context> context,
     data_->incoming_messages_.pop_front();
   }
 
+  if ( received->IsWorkerExitMessage() ) {
+    if ( worker_exit != nullptr ) {
+      *worker_exit = received->worker_exit_notification();
+       return env()->no_message_symbol();
+    }
+  }
+
   if (received->IsCloseMessage()) {
     Close();
     return env()->no_message_symbol();
@@ -845,12 +841,9 @@ void MessagePort::OnMessage(MessageProcessingMode mode) {
   // context, it will call the constructor and trigger the async handle empty.
   // Because all data was sent from the previous context.
   if (IsDetached()) return;
-
   HandleScope handle_scope(env()->isolate());
   Local<Context> context =
       object(env()->isolate())->GetCreationContextChecked();
-  Local<Function> emit_message = PersistentToLocal::Strong(emit_message_fn_);
-
   size_t processing_limit;
   if (mode == MessageProcessingMode::kNormalOperation) {
     Mutex::ScopedLock lock(data_->mutex_);
@@ -877,60 +870,28 @@ void MessagePort::OnMessage(MessageProcessingMode mode) {
       return;
     }
 
-    MessagePortData::WorkerExitNotification worker_exit;
-
-    if (data_->GetWorkerExitNotification(&worker_exit)) {
-      Debug(this,
-            "Worker exited: thread_id=%" PRIu64 ", exit_code=%d",
-            worker_exit.thread_id,
-            static_cast<int>(worker_exit.exit_code));
-
-      Local<Object> exit_info = Object::New(env()->isolate());
-
-      exit_info
-          ->Set(context,
-                FIXED_ONE_BYTE_STRING(env()->isolate(), "threadId"),
-                v8::Number::New(env()->isolate(), worker_exit.thread_id))
-          .Check();
-
-      exit_info
-          ->Set(context,
-                FIXED_ONE_BYTE_STRING(env()->isolate(), "exitCode"),
-                v8::Integer::New(env()->isolate(),
-                                 static_cast<int>(worker_exit.exit_code)))
-          .Check();
-
-      Local<Value> argv[3];
-      argv[0] = exit_info;
-      argv[1] = Undefined(env()->isolate());
-      argv[2] = FIXED_ONE_BYTE_STRING(env()->isolate(), "workerexited");
-
-      if (MakeCallback(emit_message, arraysize(argv), argv).IsEmpty()) {
-        if (data_) TriggerAsync();
-        return;
-      }
-      continue;
-    }
-
-    HandleScope handle_scope(env()->isolate());
     Context::Scope context_scope(context);
+    Local<Function> emit_message = PersistentToLocal::Strong(emit_message_fn_);
 
     Local<Value> payload;
     Local<Value> port_list = Undefined(env()->isolate());
     Local<Value> message_error;
     Local<Value> argv[3];
+    std::optional<WorkerExitNotification> worker_exit;
 
     {
       // Catch any exceptions from parsing the message itself (not from
       // emitting it) as 'messageeror' events.
       TryCatchScope try_catch(env());
-      if (!ReceiveMessage(context, mode, &port_list).ToLocal(&payload)) {
+      if (!ReceiveMessage(context, mode, &port_list,
+         &worker_exit).ToLocal(&payload)) {
         if (try_catch.HasCaught() && !try_catch.HasTerminated())
           message_error = try_catch.Exception();
         goto reschedule;
       }
     }
-    if (payload == env()->no_message_symbol()) break;
+    if (payload == env()->no_message_symbol()
+     && !worker_exit.has_value()) break;
 
     if (!env()->can_call_into_js()) {
       Debug(this, "MessagePort drains queue because !can_call_into_js()");
@@ -938,9 +899,38 @@ void MessagePort::OnMessage(MessageProcessingMode mode) {
       continue;
     }
 
-    argv[0] = payload;
-    argv[1] = port_list;
-    argv[2] = env()->message_string();
+    if ( worker_exit.has_value() ) {
+      const WorkerExitNotification& notification = *worker_exit;
+
+      Debug(this,
+            "Worker exited: thread_id=%d, exit_code=%d",
+            static_cast<int>(notification.thread_id),
+            static_cast<int>(notification.exit_code));
+      Local<Object> exit_info = Object::New(env()->isolate());
+
+      exit_info
+          ->Set(context,
+                FIXED_ONE_BYTE_STRING(env()->isolate(), "threadId"),
+                v8::Number::New(
+                    env()->isolate(),
+                    static_cast<double>(notification.thread_id)))
+          .Check();
+
+      exit_info
+          ->Set(context,
+                FIXED_ONE_BYTE_STRING(env()->isolate(), "exitCode"),
+                v8::Integer::New(
+                    env()->isolate(),
+                    static_cast<int>(notification.exit_code)))
+          .Check();
+     argv[0] = exit_info;
+     argv[1] = Undefined(env()->isolate());
+     argv[2] = FIXED_ONE_BYTE_STRING(env()->isolate(), "workerexited");
+    } else {
+     argv[0] = payload;
+     argv[1] = port_list;
+     argv[2] = env()->message_string();
+    }
 
     if (MakeCallback(emit_message, arraysize(argv), argv).IsEmpty()) {
     reschedule:
@@ -968,8 +958,8 @@ void MessagePort::OnClose() {
       const ExitCode exit_code = environment->exit_code(ExitCode::kNoFailure);
 
       Debug(this,
-            "Worker exiting: thread_id=%" PRIu64 ", exit_code=%d",
-            thread_id,
+            "Worker exiting: thread_id=%d, exit_code=%d",
+            static_cast<int>(thread_id),
             static_cast<int>(exit_code));
 
       if (data_->group_) {
diff --git a/src/node_messaging.h b/src/node_messaging.h
index 0555ba77f36..1b16010d1ad 100644
--- a/src/node_messaging.h
+++ b/src/node_messaging.h
@@ -17,6 +17,11 @@ namespace worker {
 class MessagePortData;
 class MessagePort;
 
+struct WorkerExitNotification {
+    uint64_t thread_id;
+    ExitCode exit_code;
+};
+
 typedef MaybeStackBuffer<v8::Value, 8> TransferList;
 
 // Used to represent the in-flight structure of an object that is being
@@ -49,6 +54,10 @@ class Message : public MemoryRetainer {
   // V8 ValueSerializer API. If `payload` is empty, this message indicates
   // that the receiving message port should close itself.
   explicit Message(MallocedBuffer<char>&& payload = MallocedBuffer<char>());
+
+  explicit Message(WorkerExitNotification notification)
+    : worker_exit_notification_(std::move(notification)) {}
+
   ~Message() = default;
 
   Message(Message&& other) = default;
@@ -60,6 +69,14 @@ class Message : public MemoryRetainer {
   // This is the last message to be received by a MessagePort.
   bool IsCloseMessage() const;
 
+  bool IsWorkerExitMessage() const {
+    return worker_exit_notification_.has_value();
+  }
+
+  const WorkerExitNotification& worker_exit_notification() const {
+    return worker_exit_notification_.value();
+  }
+
   // Deserialize the contained JS value. May only be called once, and only
   // after Serialize() has been called (e.g. by another thread).
   v8::MaybeLocal<v8::Value> Deserialize(
@@ -118,6 +135,7 @@ class Message : public MemoryRetainer {
   std::vector<std::unique_ptr<TransferData>> transferables_;
   std::vector<v8::CompiledWasmModule> wasm_modules_;
   std::optional<v8::SharedValueConveyor> shared_value_conveyor_;
+  std::optional<WorkerExitNotification> worker_exit_notification_;
 
   friend class MessagePort;
 };
@@ -189,7 +207,6 @@ class MessagePortData : public TransferData {
   v8::Maybe<bool> Dispatch(
       std::shared_ptr<Message> message,
       std::string* error = nullptr);
-  
   // Internal worker-exit notification.
   void AddWorkerExitNotification(uint64_t thread_id, ExitCode exit_code);
 
@@ -220,15 +237,8 @@ class MessagePortData : public TransferData {
   // once that is available with C++17, because std::shared_ptr comes with
   // overhead that is only necessary for BroadcastChannel.
   std::deque<std::shared_ptr<Message>> incoming_messages_;
-  struct WorkerExitNotification {
-    uint64_t thread_id;
-    ExitCode exit_code;
-  };
-
   bool GetWorkerExitNotification(WorkerExitNotification* notification);
- 
   std::deque<WorkerExitNotification> worker_exit_notifications_;
-  
   MessagePort* owner_ = nullptr;
   std::shared_ptr<SiblingGroup> group_;
   friend class MessagePort;
@@ -324,7 +334,8 @@ class MessagePort : public HandleWrap {
   v8::MaybeLocal<v8::Value> ReceiveMessage(
       v8::Local<v8::Context> context,
       MessageProcessingMode mode,
-      v8::Local<v8::Value>* port_list = nullptr);
+      v8::Local<v8::Value>* port_list = nullptr,
+    std::optional<WorkerExitNotification>* worker_exit = nullptr);
 
   std::unique_ptr<MessagePortData> data_ = nullptr;
   bool receiving_messages_ = false;

From b1c9fb9fc43bc4d0f3771865c0ed29beb0c75793 Mon Sep 17 00:00:00 2001
From: SudhansuBandha <bandhasudhansu@gmail.com>
Date: Thu, 3 Sep 2026 13:01:06 +0530
Subject: [PATCH 3/3] worker: resolved clang lint issues

---
 src/node_messaging.cc | 52 +++++++++++++++++++++----------------------
 src/node_messaging.h  | 12 +++++-----
 2 files changed, 31 insertions(+), 33 deletions(-)

diff --git a/src/node_messaging.cc b/src/node_messaging.cc
index 8189b6dc16a..3c13653d1e3 100644
--- a/src/node_messaging.cc
+++ b/src/node_messaging.cc
@@ -651,8 +651,8 @@ void MessagePortData::AddToIncomingQueue(std::shared_ptr<Message> message) {
 void MessagePortData::AddWorkerExitNotification(uint64_t thread_id,
                                                 ExitCode exit_code) {
   Mutex::ScopedLock lock(mutex_);
-  auto message = std::make_shared<Message>(
-    WorkerExitNotification{thread_id, exit_code});
+  auto message =
+      std::make_shared<Message>(WorkerExitNotification{thread_id, exit_code});
   AddToIncomingQueue(std::move(message));
 
   if (owner_ != nullptr) {
@@ -661,7 +661,6 @@ void MessagePortData::AddWorkerExitNotification(uint64_t thread_id,
   }
 }
 
-
 void MessagePortData::Entangle(MessagePortData* a, MessagePortData* b) {
   auto group = std::make_shared<SiblingGroup>();
   group->Entangle({a, b});
@@ -788,10 +787,11 @@ MessagePort* MessagePort::New(
   return port;
 }
 
-MaybeLocal<Value> MessagePort::ReceiveMessage(Local<Context> context,
-                                              MessageProcessingMode mode,
-                                              Local<Value>* port_list,
-                    std::optional<WorkerExitNotification>* worker_exit) {
+MaybeLocal<Value> MessagePort::ReceiveMessage(
+    Local<Context> context,
+    MessageProcessingMode mode,
+    Local<Value>* port_list,
+    std::optional<WorkerExitNotification>* worker_exit) {
   std::shared_ptr<Message> received;
   {
     // Get the head of the message queue.
@@ -816,10 +816,10 @@ MaybeLocal<Value> MessagePort::ReceiveMessage(Local<Context> context,
     data_->incoming_messages_.pop_front();
   }
 
-  if ( received->IsWorkerExitMessage() ) {
-    if ( worker_exit != nullptr ) {
+  if (received->IsWorkerExitMessage()) {
+    if (worker_exit != nullptr) {
       *worker_exit = received->worker_exit_notification();
-       return env()->no_message_symbol();
+      return env()->no_message_symbol();
     }
   }
 
@@ -883,15 +883,15 @@ void MessagePort::OnMessage(MessageProcessingMode mode) {
       // Catch any exceptions from parsing the message itself (not from
       // emitting it) as 'messageeror' events.
       TryCatchScope try_catch(env());
-      if (!ReceiveMessage(context, mode, &port_list,
-         &worker_exit).ToLocal(&payload)) {
+      if (!ReceiveMessage(context, mode, &port_list, &worker_exit)
+               .ToLocal(&payload)) {
         if (try_catch.HasCaught() && !try_catch.HasTerminated())
           message_error = try_catch.Exception();
         goto reschedule;
       }
     }
-    if (payload == env()->no_message_symbol()
-     && !worker_exit.has_value()) break;
+    if (payload == env()->no_message_symbol() && !worker_exit.has_value())
+      break;
 
     if (!env()->can_call_into_js()) {
       Debug(this, "MessagePort drains queue because !can_call_into_js()");
@@ -899,7 +899,7 @@ void MessagePort::OnMessage(MessageProcessingMode mode) {
       continue;
     }
 
-    if ( worker_exit.has_value() ) {
+    if (worker_exit.has_value()) {
       const WorkerExitNotification& notification = *worker_exit;
 
       Debug(this,
@@ -911,25 +911,23 @@ void MessagePort::OnMessage(MessageProcessingMode mode) {
       exit_info
           ->Set(context,
                 FIXED_ONE_BYTE_STRING(env()->isolate(), "threadId"),
-                v8::Number::New(
-                    env()->isolate(),
-                    static_cast<double>(notification.thread_id)))
+                v8::Number::New(env()->isolate(),
+                                static_cast<double>(notification.thread_id)))
           .Check();
 
       exit_info
           ->Set(context,
                 FIXED_ONE_BYTE_STRING(env()->isolate(), "exitCode"),
-                v8::Integer::New(
-                    env()->isolate(),
-                    static_cast<int>(notification.exit_code)))
+                v8::Integer::New(env()->isolate(),
+                                 static_cast<int>(notification.exit_code)))
           .Check();
-     argv[0] = exit_info;
-     argv[1] = Undefined(env()->isolate());
-     argv[2] = FIXED_ONE_BYTE_STRING(env()->isolate(), "workerexited");
+      argv[0] = exit_info;
+      argv[1] = Undefined(env()->isolate());
+      argv[2] = FIXED_ONE_BYTE_STRING(env()->isolate(), "workerexited");
     } else {
-     argv[0] = payload;
-     argv[1] = port_list;
-     argv[2] = env()->message_string();
+      argv[0] = payload;
+      argv[1] = port_list;
+      argv[2] = env()->message_string();
     }
 
     if (MakeCallback(emit_message, arraysize(argv), argv).IsEmpty()) {
diff --git a/src/node_messaging.h b/src/node_messaging.h
index 1b16010d1ad..073bb2574fa 100644
--- a/src/node_messaging.h
+++ b/src/node_messaging.h
@@ -18,8 +18,8 @@ class MessagePortData;
 class MessagePort;
 
 struct WorkerExitNotification {
-    uint64_t thread_id;
-    ExitCode exit_code;
+  uint64_t thread_id;
+  ExitCode exit_code;
 };
 
 typedef MaybeStackBuffer<v8::Value, 8> TransferList;
@@ -56,7 +56,7 @@ class Message : public MemoryRetainer {
   explicit Message(MallocedBuffer<char>&& payload = MallocedBuffer<char>());
 
   explicit Message(WorkerExitNotification notification)
-    : worker_exit_notification_(std::move(notification)) {}
+      : worker_exit_notification_(std::move(notification)) {}
 
   ~Message() = default;
 
@@ -168,8 +168,8 @@ class SiblingGroup final : public std::enable_shared_from_this<SiblingGroup> {
   void Disentangle(MessagePortData* data);
 
   void NotifyWorkerExit(MessagePortData* exiting_port,
-                      uint64_t thread_id,
-                      ExitCode exit_code);
+                        uint64_t thread_id,
+                        ExitCode exit_code);
 
   const std::string& name() const { return name_; }
 
@@ -335,7 +335,7 @@ class MessagePort : public HandleWrap {
       v8::Local<v8::Context> context,
       MessageProcessingMode mode,
       v8::Local<v8::Value>* port_list = nullptr,
-    std::optional<WorkerExitNotification>* worker_exit = nullptr);
+      std::optional<WorkerExitNotification>* worker_exit = nullptr);
 
   std::unique_ptr<MessagePortData> data_ = nullptr;
   bool receiving_messages_ = false;