rclnodejs 1.1.0 → 1.3.0

package/src/executor.cpp

@@ -190,10 +190,11 @@ RclResult Executor::WaitForReadyCallbacks(rcl_wait_set_t* wait_set,
     size_t num_timers = 0u;
     size_t num_clients = 0u;
     size_t num_services = 0u;
+    size_t num_events = 0u;
 
     rcl_ret_t get_entity_ret = handle_manager_->GetEntityCounts(
         &num_subscriptions, &num_guard_conditions, &num_timers, &num_clients,
-        &num_services);
+        &num_services, &num_events);
     if (get_entity_ret != RCL_RET_OK) {
       std::string error_message = std::string("Failed to get entity counts: ") +
                                   std::string(rcl_get_error_string().str);
@@ -202,9 +203,7 @@ RclResult Executor::WaitForReadyCallbacks(rcl_wait_set_t* wait_set,
 
     rcl_ret_t resize_ret =
         rcl_wait_set_resize(wait_set, num_subscriptions, num_guard_conditions,
-                            num_timers, num_clients, num_services,
-                            // TODO(minggang): support events.
-                            0u);
+                            num_timers, num_clients, num_services, num_events);
     if (resize_ret != RCL_RET_OK) {
       std::string error_message = std::string("Failed to resize: ") +
                                   std::string(rcl_get_error_string().str);

package/src/handle_manager.cpp

@@ -40,7 +40,6 @@ HandleManager::~HandleManager() {
 
 void HandleManager::SynchronizeHandles(const Napi::Object& node) {
   Napi::HandleScope scope(node.Env());
-
   Napi::Value timers = node.Get("_timers");
   Napi::Value subscriptions = node.Get("_subscriptions");
   Napi::Value clients = node.Get("_clients");
@@ -48,6 +47,7 @@ void HandleManager::SynchronizeHandles(const Napi::Object& node) {
   Napi::Value guard_conditions = node.Get("_guards");
   Napi::Value action_clients = node.Get("_actionClients");
   Napi::Value action_servers = node.Get("_actionServers");
+  Napi::Value events = node.Get("_events");
 
   uint32_t sum = 0;
   is_synchronizing_.store(true);
@@ -66,6 +66,7 @@ void HandleManager::SynchronizeHandles(const Napi::Object& node) {
                                     &action_clients_);
     sum += SynchronizeHandlesByType(action_servers.As<Napi::Object>(),
                                     &action_servers_);
+    sum += SynchronizeHandlesByType(events.As<Napi::Object>(), &events_);
   }
   is_synchronizing_.store(false);
 
@@ -98,6 +99,7 @@ void HandleManager::ClearHandles() {
   guard_conditions_.clear();
   action_clients_.clear();
   action_servers_.clear();
+  events_.clear();
 }
 
 rcl_ret_t HandleManager::AddHandlesToWaitSet(rcl_wait_set_t* wait_set) {
@@ -152,6 +154,11 @@ rcl_ret_t HandleManager::AddHandlesToWaitSet(rcl_wait_set_t* wait_set) {
     if (ret != RCL_RET_OK) return ret;
   }
 
+  for (auto& event : events_) {
+    rcl_event_t* rcl_event = reinterpret_cast<rcl_event_t*>(event->ptr());
+    rcl_ret_t ret = rcl_wait_set_add_event(wait_set, rcl_event, nullptr);
+    if (ret != RCL_RET_OK) return ret;
+  }
   return RCL_RET_OK;
 }
 
@@ -169,6 +176,8 @@ rcl_ret_t HandleManager::CollectReadyHandles(rcl_wait_set_t* wait_set) {
   CollectReadyHandlesByType(wait_set->guard_conditions,
                             wait_set->size_of_guard_conditions,
                             guard_conditions_, &ready_handles);
+  CollectReadyHandlesByType(wait_set->events, wait_set->size_of_events, events_,
+                            &ready_handles);
 
   rcl_ret_t ret = CollectReadyActionHandles(wait_set, &ready_handles);
   if (!ready_handles.empty()) {
@@ -184,7 +193,8 @@ rcl_ret_t HandleManager::GetEntityCounts(size_t* subscriptions_size,
                                          size_t* guard_conditions_size,
                                          size_t* timers_size,
                                          size_t* clients_size,
-                                         size_t* services_size) {
+                                         size_t* services_size,
+                                         size_t* events_size) {
   size_t num_subscriptions = 0u;
   size_t num_guard_conditions = 0u;
   size_t num_timers = 0u;
@@ -230,6 +240,7 @@ rcl_ret_t HandleManager::GetEntityCounts(size_t* subscriptions_size,
   *timers_size += timer_count();
   *clients_size += client_count();
   *services_size += service_count();
+  *events_size += event_count();
 
   return RCL_RET_OK;
 }

package/src/handle_manager.h

@@ -68,13 +68,15 @@ class HandleManager {
   rcl_ret_t CollectReadyHandles(rcl_wait_set_t* wait_set);
   rcl_ret_t GetEntityCounts(size_t* subscriptions_size,
                             size_t* guard_conditions_size, size_t* timers_size,
-                            size_t* clients_size, size_t* services_size);
+                            size_t* clients_size, size_t* services_size,
+                            size_t* events_size);
 
   uint32_t subscription_count() const { return subscriptions_.size(); }
   uint32_t service_count() const { return services_.size(); }
   uint32_t client_count() const { return clients_.size(); }
   uint32_t timer_count() const { return timers_.size(); }
   uint32_t guard_condition_count() const { return guard_conditions_.size(); }
+  uint32_t event_count() const { return events_.size(); }
   uv_rwlock_t* handle_rwlock() { return &sync_handles_rwlock_; }
 
   uint32_t ready_handles_count();
@@ -110,6 +112,7 @@ class HandleManager {
   std::vector<rclnodejs::RclHandle*> action_servers_;
   std::vector<rclnodejs::RclHandle*> action_clients_;
   std::vector<rclnodejs::RclHandle*> ready_handles_;
+  std::vector<rclnodejs::RclHandle*> events_;
 
   // Protects the handles.
   uv_rwlock_t sync_handles_rwlock_;

package/src/macros.h

@@ -23,17 +23,33 @@
   {                                                                 \
     if (lhs op rhs) {                                               \
       rcl_reset_error();                                            \
-      Napi::Error::New(rclnodejs::GetEnv(), message)                \
+      Napi::Error::New(env, message)                                \
           .ThrowAsJavaScriptException();                            \
+      return env.Undefined();                                       \
     }                                                               \
   }
 
+#define CHECK_OP_AND_THROW_ERROR_IF_NOT_TRUE_NO_RETURN(op, lhs, rhs, message) \
+  {                                                                           \
+    if (lhs op rhs) {                                                         \
+      rcl_reset_error();                                                      \
+      Napi::Error::New(env, message)                                          \
+          .ThrowAsJavaScriptException();                                      \
+    }                                                                         \
+  }
+
 #define THROW_ERROR_IF_NOT_EQUAL(lhs, rhs, message) \
   CHECK_OP_AND_THROW_ERROR_IF_NOT_TRUE(!=, lhs, rhs, message)
 
 #define THROW_ERROR_IF_EQUAL(lhs, rhs, message) \
   CHECK_OP_AND_THROW_ERROR_IF_NOT_TRUE(==, lhs, rhs, message)
 
+#define THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(lhs, rhs, message) \
+  CHECK_OP_AND_THROW_ERROR_IF_NOT_TRUE_NO_RETURN(!=, lhs, rhs, message)
+
+#define THROW_ERROR_IF_EQUAL_NO_RETURN(lhs, rhs, message) \
+  CHECK_OP_AND_THROW_ERROR_IF_NOT_TRUE_NO_RETURN(==, lhs, rhs, message)
+
 #define PACKAGE_NAME "rclnodejs"
 
 #ifdef DEBUG_ON

package/src/rcl_action_client_bindings.cpp

@@ -75,12 +75,13 @@ Napi::Value ActionCreateClient(const Napi::CallbackInfo& info) {
                                &action_client_ops),
         RCL_RET_OK, rcl_get_error_string().str);
     auto js_obj = RclHandle::NewInstance(
-        env, action_client, node_handle, [node](void* ptr) {
+        env, action_client, node_handle, [node, env](void* ptr) {
           rcl_action_client_t* action_client =
               reinterpret_cast<rcl_action_client_t*>(ptr);
           rcl_ret_t ret = rcl_action_client_fini(action_client, node);
           free(ptr);
-          THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+          THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                             rcl_get_error_string().str);
         });
 
     return js_obj;

package/src/rcl_action_goal_bindings.cpp

@@ -49,12 +49,13 @@ Napi::Value ActionAcceptNewGoal(const Napi::CallbackInfo& info) {
           malloc(sizeof(rcl_action_goal_handle_t)));
   *goal_handle = *new_goal;
   auto js_obj =
-      RclHandle::NewInstance(env, goal_handle, nullptr, [](void* ptr) {
+      RclHandle::NewInstance(env, goal_handle, nullptr, [env](void* ptr) {
         rcl_action_goal_handle_t* goal_handle =
             reinterpret_cast<rcl_action_goal_handle_t*>(ptr);
         rcl_ret_t ret = rcl_action_goal_handle_fini(goal_handle);
         free(ptr);
-        THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+        THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                           rcl_get_error_string().str);
       });
 
   return js_obj;

package/src/rcl_action_server_bindings.cpp

@@ -81,12 +81,13 @@ Napi::Value ActionCreateServer(const Napi::CallbackInfo& info) {
                                action_name.c_str(), &action_server_ops),
         RCL_RET_OK, rcl_get_error_string().str);
     auto js_obj = RclHandle::NewInstance(
-        env, action_server, node_handle, [node](void* ptr) {
+        env, action_server, node_handle, [node, env](void* ptr) {
           rcl_action_server_t* action_server =
               reinterpret_cast<rcl_action_server_t*>(ptr);
           rcl_ret_t ret = rcl_action_server_fini(action_server, node);
           free(ptr);
-          THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+          THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                             rcl_get_error_string().str);
         });
 
     return js_obj;
@@ -390,13 +391,14 @@ Napi::Value ActionProcessCancelRequest(const Napi::CallbackInfo& info) {
   }
 
   *response = cancel_response_ptr->msg;
-  auto js_obj =
-      RclHandle::NewInstance(env, cancel_response_ptr, nullptr, [](void* ptr) {
+  auto js_obj = RclHandle::NewInstance(
+      env, cancel_response_ptr, nullptr, [env](void* ptr) {
         rcl_action_cancel_response_t* cancel_response_ptr =
             reinterpret_cast<rcl_action_cancel_response_t*>(ptr);
         rcl_ret_t ret = rcl_action_cancel_response_fini(cancel_response_ptr);
         free(ptr);
-        THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+        THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                           rcl_get_error_string().str);
       });
   return js_obj;
 }

package/src/rcl_client_bindings.cpp

@@ -53,12 +53,13 @@ Napi::Value CreateClient(const Napi::CallbackInfo& info) {
         rcl_client_init(client, node, ts, service_name.c_str(), &client_ops),
         RCL_RET_OK, rcl_get_error_string().str);
 
-    auto js_obj =
-        RclHandle::NewInstance(env, client, node_handle, [node](void* ptr) {
+    auto js_obj = RclHandle::NewInstance(
+        env, client, node_handle, [node, env](void* ptr) {
           rcl_client_t* client = reinterpret_cast<rcl_client_t*>(ptr);
           rcl_ret_t ret = rcl_client_fini(client, node);
           free(ptr);
-          THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+          THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                             rcl_get_error_string().str);
         });
 
     return js_obj;

package/src/rcl_context_bindings.cpp

@@ -17,7 +17,8 @@
 #include <rcl/logging.h>
 #include <rcl/rcl.h>
 
-#include <cstdio>
+#include <rcpputils/scope_exit.hpp>
+// NOLINTNEXTLINE
 #include <string>
 
 #include "macros.h"
@@ -35,6 +36,15 @@ Napi::Value Init(const Napi::CallbackInfo& info) {
                            rcl_init_options_init(&init_options, allocator),
                            rcl_get_error_string().str);
 
+  RCPPUTILS_SCOPE_EXIT({
+    rcl_ret_t fini_ret = rcl_init_options_fini(&init_options);
+    if (RCL_RET_OK != fini_ret) {
+      Napi::Error::New(env, rcl_get_error_string().str)
+          .ThrowAsJavaScriptException();
+      rcl_reset_error();
+    }
+  });
+
   // Preprocess Context
   RclHandle* context_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
   rcl_context_t* context =
@@ -42,17 +52,20 @@ Napi::Value Init(const Napi::CallbackInfo& info) {
 
   // Preprocess argc & argv
   Napi::Array jsArgv = info[1].As<Napi::Array>();
-  int argc = jsArgv.Length();
-  char** argv = nullptr;
-
-  if (argc > 0) {
-    argv = reinterpret_cast<char**>(malloc(argc * sizeof(char*)));
-    for (int i = 0; i < argc; i++) {
-      std::string arg = jsArgv.Get(i).As<Napi::String>().Utf8Value();
-      int len = arg.length() + 1;
-      argv[i] = reinterpret_cast<char*>(malloc(len * sizeof(char)));
-      snprintf(argv[i], len, "%s", arg.c_str());
-    }
+  size_t argc = jsArgv.Length();
+  char** argv = AbstractArgsFromNapiArray(jsArgv);
+
+  // Set up the domain id.
+  size_t domain_id = RCL_DEFAULT_DOMAIN_ID;
+  if (info.Length() > 2 && info[2].IsBigInt()) {
+    bool lossless;
+    domain_id = info[2].As<Napi::BigInt>().Uint64Value(&lossless);
+  }
+  rcl_ret_t ret = rcl_init_options_set_domain_id(&init_options, domain_id);
+  if (RCL_RET_OK != ret) {
+    Napi::Error::New(env, "failed to set domain id to init options")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
   }
 
   THROW_ERROR_IF_NOT_EQUAL(
@@ -64,11 +77,7 @@ Napi::Value Init(const Napi::CallbackInfo& info) {
       RCL_RET_OK, rcl_logging_configure(&context->global_arguments, &allocator),
       rcl_get_error_string().str);
 
-  for (int i = 0; i < argc; i++) {
-    free(argv[i]);
-  }
-  free(argv);
-
+  RCPPUTILS_SCOPE_EXIT({ FreeArgs(argv, argc); });
   return env.Undefined();
 }
 
@@ -111,7 +120,8 @@ Napi::Value CreateContext(const Napi::CallbackInfo& info) {
         rcl_context_t* context = reinterpret_cast<rcl_context_t*>(ptr);
         rcl_ret_t ret = DestroyContext(env, context);
         free(ptr);
-        THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+        THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                           rcl_get_error_string().str);
       });
 
   return js_obj;
@@ -141,7 +151,7 @@ Napi::Value GetDomainId(const Napi::CallbackInfo& info) {
     return env.Undefined();
   }
 
-  return Napi::Number::New(env, domain_id);
+  return Napi::BigInt::New(env, domain_id);
 }
 
 Napi::Object InitContextBindings(Napi::Env env, Napi::Object exports) {

package/src/rcl_event_handle_bindings.cpp

@@ -0,0 +1,294 @@
+// Copyright (c) 2025, The Robot Web Tools Contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "rcl_event_handle_bindings.h"
+
+#include <rcl/error_handling.h>
+#include <rcl/rcl.h>
+
+#include "rcl_handle.h"
+
+namespace {
+
+typedef union event_callback_data {
+  // Subscription events
+  rmw_requested_deadline_missed_status_t requested_deadline_missed;
+  rmw_liveliness_changed_status_t liveliness_changed;
+  rmw_message_lost_status_t message_lost;
+  rmw_requested_qos_incompatible_event_status_t requested_incompatible_qos;
+  rmw_matched_status_t subscription_matched;
+  // Publisher events
+  rmw_offered_deadline_missed_status_t offered_deadline_missed;
+  rmw_liveliness_lost_status_t liveliness_lost;
+  rmw_offered_qos_incompatible_event_status_t offered_incompatible_qos;
+  rmw_matched_status_t publisher_matched;
+
+  rmw_incompatible_type_status_t incompatible_type;
+} event_callback_data_t;
+
+rcl_event_t* CreateEventHandle() {
+  rcl_event_t* event =
+      reinterpret_cast<rcl_event_t*>(malloc(sizeof(rcl_event_t)));
+  *event = rcl_get_zero_initialized_event();
+  return event;
+}
+
+Napi::Value CreateJSObjectForSubscriptionEvent(
+    Napi::Env env, rcl_subscription_event_type_t subscription_event_type,
+    const event_callback_data_t& data) {
+  Napi::Object obj = Napi::Object::New(env);
+  switch (subscription_event_type) {
+    case RCL_SUBSCRIPTION_REQUESTED_DEADLINE_MISSED: {
+      obj.Set(
+          "total_count",
+          Napi::Number::New(env, data.requested_deadline_missed.total_count));
+      obj.Set("total_count_change",
+              Napi::Number::New(
+                  env, data.requested_deadline_missed.total_count_change));
+      break;
+    }
+    case RCL_SUBSCRIPTION_LIVELINESS_CHANGED: {
+      obj.Set("alive_count",
+              Napi::Number::New(env, data.liveliness_changed.alive_count));
+      obj.Set("not_alive_count",
+              Napi::Number::New(env, data.liveliness_changed.not_alive_count));
+      obj.Set(
+          "alive_count_change",
+          Napi::Number::New(env, data.liveliness_changed.alive_count_change));
+      obj.Set("not_alive_count_change",
+              Napi::Number::New(
+                  env, data.liveliness_changed.not_alive_count_change));
+      break;
+    }
+    case RCL_SUBSCRIPTION_MESSAGE_LOST: {
+      obj.Set("total_count",
+              Napi::Number::New(env, data.message_lost.total_count));
+      obj.Set("total_count_change",
+              Napi::Number::New(env, data.message_lost.total_count_change));
+      break;
+    }
+    case RCL_SUBSCRIPTION_REQUESTED_INCOMPATIBLE_QOS: {
+      obj.Set(
+          "total_count",
+          Napi::Number::New(env, data.requested_incompatible_qos.total_count));
+      obj.Set("total_count_change",
+              Napi::Number::New(
+                  env, data.requested_incompatible_qos.total_count_change));
+      obj.Set("last_policy_kind",
+              Napi::Number::New(
+                  env, data.requested_incompatible_qos.last_policy_kind));
+      break;
+    }
+    case RCL_SUBSCRIPTION_INCOMPATIBLE_TYPE: {
+      obj.Set("total_count",
+              Napi::Number::New(env, data.incompatible_type.total_count));
+      obj.Set(
+          "total_count_change",
+          Napi::Number::New(env, data.incompatible_type.total_count_change));
+      break;
+    }
+    case RCL_SUBSCRIPTION_MATCHED: {
+      obj.Set("total_count",
+              Napi::Number::New(env, data.subscription_matched.total_count));
+      obj.Set(
+          "total_count_change",
+          Napi::Number::New(env, data.subscription_matched.total_count_change));
+      obj.Set("current_count",
+              Napi::Number::New(env, data.subscription_matched.current_count));
+      obj.Set("current_count_change",
+              Napi::Number::New(
+                  env, data.subscription_matched.current_count_change));
+      break;
+    }
+    default:
+      break;
+  }
+  return obj;
+}
+
+Napi::Value CreateJSObjectForPublisherEvent(
+    Napi::Env env, rcl_publisher_event_type_t publisher_event_type,
+    const event_callback_data_t& data) {
+  Napi::Object obj = Napi::Object::New(env);
+  switch (publisher_event_type) {
+    case RCL_PUBLISHER_OFFERED_DEADLINE_MISSED: {
+      obj.Set("total_count",
+              Napi::Number::New(env, data.offered_deadline_missed.total_count));
+      obj.Set("total_count_change",
+              Napi::Number::New(
+                  env, data.offered_deadline_missed.total_count_change));
+      break;
+    }
+    case RCL_PUBLISHER_LIVELINESS_LOST: {
+      obj.Set("total_count",
+              Napi::Number::New(env, data.liveliness_lost.total_count));
+      obj.Set("total_count_change",
+              Napi::Number::New(env, data.liveliness_lost.total_count_change));
+      break;
+    }
+    case RCL_PUBLISHER_OFFERED_INCOMPATIBLE_QOS: {
+      obj.Set(
+          "total_count",
+          Napi::Number::New(env, data.offered_incompatible_qos.total_count));
+      obj.Set("total_count_change",
+              Napi::Number::New(
+                  env, data.offered_incompatible_qos.total_count_change));
+      obj.Set("last_policy_kind",
+              Napi::Number::New(
+                  env, data.offered_incompatible_qos.last_policy_kind));
+      break;
+    }
+    case RCL_PUBLISHER_INCOMPATIBLE_TYPE: {
+      obj.Set("total_count",
+              Napi::Number::New(env, data.incompatible_type.total_count));
+      obj.Set(
+          "total_count_change",
+          Napi::Number::New(env, data.incompatible_type.total_count_change));
+      break;
+    }
+    case RCL_PUBLISHER_MATCHED: {
+      obj.Set("total_count",
+              Napi::Number::New(env, data.publisher_matched.total_count));
+      obj.Set(
+          "total_count_change",
+          Napi::Number::New(env, data.publisher_matched.total_count_change));
+      obj.Set("current_count",
+              Napi::Number::New(env, data.publisher_matched.current_count));
+      obj.Set(
+          "current_count_change",
+          Napi::Number::New(env, data.publisher_matched.current_count_change));
+      break;
+    }
+    default:
+      break;
+  }
+  return obj;
+}
+
+}  // namespace
+
+namespace rclnodejs {
+
+Napi::Value CreateSubscriptionEventHandle(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* subscription_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_subscription_t* subscription =
+      reinterpret_cast<rcl_subscription_t*>(subscription_handle->ptr());
+  rcl_subscription_event_type_t event_type =
+      static_cast<rcl_subscription_event_type_t>(
+          info[1].As<Napi::Number>().Int32Value());
+
+  rcl_event_t* event = CreateEventHandle();
+  rcl_ret_t ret = rcl_subscription_event_init(event, subscription, event_type);
+
+  if (ret != RCL_RET_OK) {
+    Napi::Error::New(env, "failed to create subscription event")
+        .ThrowAsJavaScriptException();
+    rcl_reset_error();
+    free(event);
+    return env.Undefined();
+  }
+
+  auto js_obj = RclHandle::NewInstance(env, event, nullptr, [env](void* ptr) {
+    rcl_event_t* event = reinterpret_cast<rcl_event_t*>(ptr);
+    rcl_ret_t ret = rcl_event_fini(event);
+    if (ret != RCL_RET_OK) {
+      Napi::Error::New(env, rcl_get_error_string().str)
+          .ThrowAsJavaScriptException();
+      rcl_reset_error();
+    }
+    free(ptr);
+  });
+  return js_obj;
+}
+
+Napi::Value CreatePublisherEventHandle(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* publisher_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_publisher_t* publisher =
+      reinterpret_cast<rcl_publisher_t*>(publisher_handle->ptr());
+  rcl_publisher_event_type_t event_type =
+      static_cast<rcl_publisher_event_type_t>(
+          info[1].As<Napi::Number>().Int32Value());
+
+  rcl_event_t* event = CreateEventHandle();
+  rcl_ret_t ret = rcl_publisher_event_init(event, publisher, event_type);
+
+  if (ret != RCL_RET_OK) {
+    Napi::Error::New(env, "failed to create publisher event")
+        .ThrowAsJavaScriptException();
+    rcl_reset_error();
+    free(event);
+    return env.Undefined();
+  }
+
+  auto js_obj = RclHandle::NewInstance(env, event, nullptr, [env](void* ptr) {
+    rcl_event_t* event = reinterpret_cast<rcl_event_t*>(ptr);
+    rcl_ret_t ret = rcl_event_fini(event);
+    if (ret != RCL_RET_OK) {
+      Napi::Error::New(env, rcl_get_error_string().str)
+          .ThrowAsJavaScriptException();
+      rcl_reset_error();
+    }
+    free(ptr);
+  });
+  return js_obj;
+}
+
+Napi::Value TakeEvent(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* event_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_event_t* event = reinterpret_cast<rcl_event_t*>(event_handle->ptr());
+  auto event_type = info[1].As<Napi::Object>();
+
+  event_callback_data_t data;
+  rcl_ret_t ret;
+  if (event_type.Has("subscription_event_type")) {
+    rcl_subscription_event_type_t subscription_event_type =
+        static_cast<rcl_subscription_event_type_t>(
+            event_type.Get("subscription_event_type")
+                .As<Napi::Number>()
+                .Int32Value());
+    ret = rcl_take_event(event, &data);
+    if (RCL_RET_OK == ret) {
+      return CreateJSObjectForSubscriptionEvent(env, subscription_event_type,
+                                                data);
+    }
+  } else if (event_type.Has("publisher_event_type")) {
+    rcl_publisher_event_type_t publisher_event_type =
+        static_cast<rcl_publisher_event_type_t>(
+            event_type.Get("publisher_event_type")
+                .As<Napi::Number>()
+                .Int32Value());
+    ret = rcl_take_event(event, &data);
+    if (RCL_RET_OK == ret) {
+      return CreateJSObjectForPublisherEvent(env, publisher_event_type, data);
+    }
+  }
+
+  Napi::Error::New(env, "failed to take event").ThrowAsJavaScriptException();
+  return env.Undefined();
+}
+
+Napi::Object InitEventHandleBindings(Napi::Env env, Napi::Object exports) {
+  exports.Set("createSubscriptionEventHandle",
+              Napi::Function::New(env, CreateSubscriptionEventHandle));
+  exports.Set("createPublisherEventHandle",
+              Napi::Function::New(env, CreatePublisherEventHandle));
+  exports.Set("takeEvent", Napi::Function::New(env, TakeEvent));
+  return exports;
+}
+
+}  // namespace rclnodejs

package/src/rcl_event_handle_bindings.h

@@ -0,0 +1,26 @@
+// Copyright (c) 2025, The Robot Web Tools Contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_RCL_EVENT_HANDLE_BINDINGS_H_
+#define SRC_RCL_EVENT_HANDLE_BINDINGS_H_
+
+#include <napi.h>
+
+namespace rclnodejs {
+
+Napi::Object InitEventHandleBindings(Napi::Env env, Napi::Object exports);
+
+}
+
+#endif  // SRC_RCL_EVENT_HANDLE_BINDINGS_H_

package/src/rcl_guard_condition_bindings.cpp

@@ -41,11 +41,12 @@ Napi::Value CreateGuardCondition(const Napi::CallbackInfo& info) {
                            rcl_guard_condition_init(gc, context, gc_options),
                            rcl_get_error_string().str);
 
-  auto handle = RclHandle::NewInstance(env, gc, nullptr, [](void* ptr) {
+  auto handle = RclHandle::NewInstance(env, gc, nullptr, [env](void* ptr) {
     rcl_guard_condition_t* gc = reinterpret_cast<rcl_guard_condition_t*>(ptr);
     rcl_ret_t ret = rcl_guard_condition_fini(gc);
     free(ptr);
-    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+    THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                       rcl_get_error_string().str);
   });
 
   return handle;