rclnodejs 1.0.0 → 1.2.0

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/rcl_action_client_bindings.cpp

@@ -16,6 +16,7 @@
 
 #include <rcl/error_handling.h>
 #include <rcl/rcl.h>
+#include <rcl_action/action_client.h>
 #include <rcl_action/rcl_action.h>
 
 #include <string>
@@ -126,28 +127,6 @@ Napi::Value ActionSendGoalRequest(const Napi::CallbackInfo& info) {
   return Napi::Number::New(env, static_cast<int32_t>(sequence_number));
 }
 
-Napi::Value ActionTakeCancelRequest(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-
-  RclHandle* action_server_handle =
-      RclHandle::Unwrap(info[0].As<Napi::Object>());
-  rcl_action_server_t* action_server =
-      reinterpret_cast<rcl_action_server_t*>(action_server_handle->ptr());
-  rmw_request_id_t* header =
-      reinterpret_cast<rmw_request_id_t*>(malloc(sizeof(rmw_request_id_t)));
-
-  void* taken_request = info[1].As<Napi::Buffer<char>>().Data();
-  rcl_ret_t ret =
-      rcl_action_take_cancel_request(action_server, header, taken_request);
-  if (ret != RCL_RET_ACTION_SERVER_TAKE_FAILED) {
-    auto js_obj = RclHandle::NewInstance(env, header, nullptr,
-                                         [](void* ptr) { free(ptr); });
-    return js_obj;
-  }
-
-  return env.Undefined();
-}
-
 Napi::Value ActionSendResultRequest(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
 
@@ -211,6 +190,97 @@ Napi::Value ActionTakeStatus(const Napi::CallbackInfo& info) {
   return env.Undefined();
 }
 
+Napi::Value GetNumEntities(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* action_client_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_action_client_t* action_client =
+      reinterpret_cast<rcl_action_client_t*>(action_client_handle->ptr());
+
+  size_t num_subscriptions = 0u;
+  size_t num_guard_conditions = 0u;
+  size_t num_timers = 0u;
+  size_t num_clients = 0u;
+  size_t num_services = 0u;
+
+  rcl_ret_t ret;
+  ret = rcl_action_client_wait_set_get_num_entities(
+      action_client, &num_subscriptions, &num_guard_conditions, &num_timers,
+      &num_clients, &num_services);
+  if (RCL_RET_OK != ret) {
+    rcl_reset_error();
+    std::string error_text{
+        "Failed to get number of entities for 'rcl_action_client_t'"};
+    Napi::Error::New(env, error_text).ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  Napi::Object entities = Napi::Object::New(env);
+  entities.Set("subscriptionsNumber",
+               Napi::Number::New(env, num_subscriptions));
+  entities.Set("guardConditionsNumber",
+               Napi::Number::New(env, num_guard_conditions));
+  entities.Set("timersNumber", Napi::Number::New(env, num_timers));
+  entities.Set("clientsNumber", Napi::Number::New(env, num_clients));
+  entities.Set("servicesNumber", Napi::Number::New(env, num_services));
+  return entities;
+}
+
+Napi::Value ActionSendCancelRequest(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* action_client_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_action_client_t* action_client =
+      reinterpret_cast<rcl_action_client_t*>(action_client_handle->ptr());
+  void* buffer = info[1].As<Napi::Buffer<char>>().Data();
+
+  int64_t sequence_number;
+  THROW_ERROR_IF_NOT_EQUAL(
+      rcl_action_send_cancel_request(action_client, buffer, &sequence_number),
+      RCL_RET_OK, rcl_get_error_string().str);
+
+  return Napi::Number::New(env, static_cast<int32_t>(sequence_number));
+}
+
+#if ROS_VERSION >= 2505  // ROS2 >= Kilted
+Napi::Value ConfigureActionClientIntrospection(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* action_client_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_action_client_t* action_client =
+      reinterpret_cast<rcl_action_client_t*>(action_client_handle->ptr());
+  RclHandle* node_handle = RclHandle::Unwrap(info[1].As<Napi::Object>());
+  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
+  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(
+      RclHandle::Unwrap(info[2].As<Napi::Object>())->ptr());
+
+  std::string action_name = info[3].As<Napi::String>().Utf8Value();
+  std::string package_name = info[4].As<Napi::String>().Utf8Value();
+  const rosidl_action_type_support_t* ts =
+      GetActionTypeSupport(package_name, action_name);
+  rcl_ret_t ret = RCL_RET_ERROR;
+  if (ts) {
+    rcl_publisher_options_t publisher_ops = rcl_publisher_get_default_options();
+    auto qos_profile = GetQoSProfile(info[5]);
+    if (qos_profile) {
+      publisher_ops.qos = *qos_profile;
+    }
+    rcl_service_introspection_state_t state =
+        static_cast<rcl_service_introspection_state_t>(
+            info[6].As<Napi::Number>().Uint32Value());
+    ret = rcl_action_client_configure_action_introspection(
+        action_client, node, clock, ts, publisher_ops, state);
+    if (ret == RCL_RET_OK) {
+      return env.Undefined();
+    }
+  }
+
+  Napi::Error::New(env, "failed to configure action client introspection")
+      .ThrowAsJavaScriptException();
+  return env.Undefined();
+}
+#endif  // ROS_VERSION >= 2505
+
 Napi::Object InitActionClientBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("actionCreateClient",
               Napi::Function::New(env, ActionCreateClient));
@@ -218,13 +288,18 @@ Napi::Object InitActionClientBindings(Napi::Env env, Napi::Object exports) {
               Napi::Function::New(env, ActionServerIsAvailable));
   exports.Set("actionSendGoalRequest",
               Napi::Function::New(env, ActionSendGoalRequest));
-  exports.Set("actionTakeCancelRequest",
-              Napi::Function::New(env, ActionTakeCancelRequest));
   exports.Set("actionSendResultRequest",
               Napi::Function::New(env, ActionSendResultRequest));
   exports.Set("actionTakeFeedback",
               Napi::Function::New(env, ActionTakeFeedback));
   exports.Set("actionTakeStatus", Napi::Function::New(env, ActionTakeStatus));
+  exports.Set("getNumEntities", Napi::Function::New(env, GetNumEntities));
+  exports.Set("actionSendCancelRequest",
+              Napi::Function::New(env, ActionSendCancelRequest));
+#if ROS_VERSION >= 2505  // ROS2 >= Kilted
+  exports.Set("configureActionClientIntrospection",
+              Napi::Function::New(env, ConfigureActionClientIntrospection));
+#endif  // ROS_VERSION >= 2505
   return exports;
 }
 

package/src/rcl_action_server_bindings.cpp

@@ -16,6 +16,7 @@
 
 #include <rcl/error_handling.h>
 #include <rcl/rcl.h>
+#include <rcl_action/action_server.h>
 #include <rcl_action/rcl_action.h>
 
 #include <string>
@@ -96,23 +97,6 @@ Napi::Value ActionCreateServer(const Napi::CallbackInfo& info) {
   }
 }
 
-Napi::Value ActionSendCancelRequest(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-
-  RclHandle* action_client_handle =
-      RclHandle::Unwrap(info[0].As<Napi::Object>());
-  rcl_action_client_t* action_client =
-      reinterpret_cast<rcl_action_client_t*>(action_client_handle->ptr());
-  void* buffer = info[1].As<Napi::Buffer<char>>().Data();
-
-  int64_t sequence_number;
-  THROW_ERROR_IF_NOT_EQUAL(
-      rcl_action_send_cancel_request(action_client, buffer, &sequence_number),
-      RCL_RET_OK, rcl_get_error_string().str);
-
-  return Napi::Number::New(env, static_cast<int32_t>(sequence_number));
-}
-
 Napi::Value ActionTakeResultRequest(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
 
@@ -432,11 +416,71 @@ Napi::Value ActionServerGoalExists(const Napi::CallbackInfo& info) {
   return Napi::Boolean::New(env, exists);
 }
 
+Napi::Value ActionTakeCancelRequest(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  RclHandle* action_server_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_action_server_t* action_server =
+      reinterpret_cast<rcl_action_server_t*>(action_server_handle->ptr());
+  rmw_request_id_t* header =
+      reinterpret_cast<rmw_request_id_t*>(malloc(sizeof(rmw_request_id_t)));
+
+  void* taken_request = info[1].As<Napi::Buffer<char>>().Data();
+  rcl_ret_t ret =
+      rcl_action_take_cancel_request(action_server, header, taken_request);
+  if (ret != RCL_RET_ACTION_SERVER_TAKE_FAILED) {
+    auto js_obj = RclHandle::NewInstance(env, header, nullptr,
+                                         [](void* ptr) { free(ptr); });
+    return js_obj;
+  }
+
+  return env.Undefined();
+}
+
+#if ROS_VERSION >= 2505  // ROS2 >= Kilted
+Napi::Value ConfigureActionServerIntrospection(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* action_server_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_action_server_t* action_server =
+      reinterpret_cast<rcl_action_server_t*>(action_server_handle->ptr());
+  RclHandle* node_handle = RclHandle::Unwrap(info[1].As<Napi::Object>());
+  rcl_node_t* node = reinterpret_cast<rcl_node_t*>(node_handle->ptr());
+  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(
+      RclHandle::Unwrap(info[2].As<Napi::Object>())->ptr());
+
+  std::string action_name = info[3].As<Napi::String>().Utf8Value();
+  std::string package_name = info[4].As<Napi::String>().Utf8Value();
+  const rosidl_action_type_support_t* ts =
+      GetActionTypeSupport(package_name, action_name);
+
+  rcl_ret_t ret = RCL_RET_ERROR;
+  if (ts) {
+    rcl_publisher_options_t publisher_ops = rcl_publisher_get_default_options();
+    auto qos_profile = GetQoSProfile(info[5]);
+    if (qos_profile) {
+      publisher_ops.qos = *qos_profile;
+    }
+    rcl_service_introspection_state_t state =
+        static_cast<rcl_service_introspection_state_t>(
+            info[6].As<Napi::Number>().Uint32Value());
+    ret = rcl_action_server_configure_action_introspection(
+        action_server, node, clock, ts, publisher_ops, state);
+    if (ret == RCL_RET_OK) {
+      return env.Undefined();
+    }
+  }
+
+  Napi::Error::New(env, "failed to configure action server introspection")
+      .ThrowAsJavaScriptException();
+  return env.Undefined();
+}
+#endif  // ROS_VERSION >= 2505
+
 Napi::Object InitActionServerBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("actionCreateServer",
               Napi::Function::New(env, ActionCreateServer));
-  exports.Set("actionSendCancelRequest",
-              Napi::Function::New(env, ActionSendCancelRequest));
   exports.Set("actionTakeResultRequest",
               Napi::Function::New(env, ActionTakeResultRequest));
   exports.Set("actionTakeGoalRequest",
@@ -464,6 +508,12 @@ Napi::Object InitActionServerBindings(Napi::Env env, Napi::Object exports) {
               Napi::Function::New(env, ActionProcessCancelRequest));
   exports.Set("actionServerGoalExists",
               Napi::Function::New(env, ActionServerGoalExists));
+  exports.Set("actionTakeCancelRequest",
+              Napi::Function::New(env, ActionTakeCancelRequest));
+#if ROS_VERSION >= 2505  // ROS2 >= Kilted
+  exports.Set("configureActionServerIntrospection",
+              Napi::Function::New(env, ConfigureActionServerIntrospection));
+#endif  // ROS_VERSION >= 2505
   return 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_lifecycle_bindings.cpp

@@ -360,6 +360,18 @@ Napi::Value GetLifecycleShutdownTransitionLabel(
   return Napi::String::New(env, rcl_lifecycle_shutdown_label);
 }
 
+Napi::Value IsInitialized(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* state_machine_handle =
+      RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_lifecycle_state_machine_t* state_machine =
+      reinterpret_cast<rcl_lifecycle_state_machine_t*>(
+          state_machine_handle->ptr());
+  const bool is_initialized =
+      RCL_RET_OK == rcl_lifecycle_state_machine_is_initialized(state_machine);
+  return Napi::Boolean::New(env, is_initialized);
+}
+
 Napi::Object InitLifecycleBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("createLifecycleStateMachine",
               Napi::Function::New(env, CreateLifecycleStateMachine));
@@ -383,6 +395,7 @@ Napi::Object InitLifecycleBindings(Napi::Env env, Napi::Object exports) {
               Napi::Function::New(env, GetLifecycleTransitionIdToLabel));
   exports.Set("getLifecycleShutdownTransitionLabel",
               Napi::Function::New(env, GetLifecycleShutdownTransitionLabel));
+  exports.Set("isInitialized", Napi::Function::New(env, IsInitialized));
   return exports;
 }