rclnodejs 1.8.0 → 1.8.2

package/lib/lifecycle.js

@@ -291,7 +291,8 @@ class LifecycleNode extends Node {
     // initialize native handle to rcl_lifecycle_state_machine
     this._stateMachineHandle = rclnodejs.createLifecycleStateMachine(
       this.handle,
-      enableCommunicationInterface
+      enableCommunicationInterface,
+      this._clock.handle
     );
 
     // initialize Map<transitionId,TransitionCallback>

package/lib/native_loader.js

@@ -175,4 +175,14 @@ function loadNativeAddon() {
   }
 }
 
-module.exports = loadNativeAddon();
+const addon = loadNativeAddon();
+
+// Export internal functions for testing purposes
+if (process.env.NODE_ENV === 'test') {
+  addon.TestHelpers = {
+    customFallbackLoader,
+    loadNativeAddon,
+  };
+}
+
+module.exports = addon;

package/lib/parameter.js

@@ -883,7 +883,7 @@ function validValue(value, type) {
     return type === ParameterType.PARAMETER_NOT_SET;
   }
 
-  let result = true;
+  let result;
   switch (type) {
     case ParameterType.PARAMETER_NOT_SET:
       result = !value;

package/lib/time.js

@@ -352,8 +352,8 @@ class Time {
   toMsg() {
     const secondsAndNanoseconds = this.secondsAndNanoseconds;
     return {
-      sec: secondsAndNanoseconds.seconds,
-      nanosec: secondsAndNanoseconds.nanoseconds,
+      sec: Number(secondsAndNanoseconds.seconds),
+      nanosec: Number(secondsAndNanoseconds.nanoseconds),
     };
   }
 

package/lib/time_source.js

@@ -102,7 +102,7 @@ class TimeSource {
    * @return {undefined}
    */
   attachNode(node) {
-    if ((!node) instanceof rclnodejs.ShadowNode) {
+    if (!(node instanceof rclnodejs.ShadowNode)) {
       throw new TypeValidationError('node', node, 'Node', {
         entityType: 'time source',
       });

package/lib/utils.js

@@ -54,7 +54,7 @@ function ensureDirSync(dirPath) {
  */
 async function pathExists(filePath) {
   try {
-    await fsPromises.access(filePath);
+    await fsPromises.stat(filePath);
     return true;
   } catch {
     return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rclnodejs",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "description": "ROS2.0 JavaScript client with Node.js",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -25,7 +25,7 @@
     "install": "node scripts/install.js",
     "postinstall": "npm run generate-messages",
     "docs": "cd docs && make",
-    "test": "nyc node --expose-gc ./scripts/run_test.js && tsd",
+    "test": "nyc node --expose-gc ./scripts/run_test.js && tsd && npm install --no-save electron && node test/electron/run_test.js",
     "test-idl": "nyc node --expose-gc ./scripts/run_test.js --idl",
     "lint": "eslint && node ./scripts/cpplint.js",
     "format": "clang-format -i -style=file ./src/*.cpp ./src/*.h && npx --yes prettier --write \"{lib,rosidl_gen,rostsd_gen,rosidl_parser,types,example,test,scripts,benchmark,rostsd_gen}/**/*.{js,md,ts}\" ./*.{js,md,ts}",
@@ -48,7 +48,7 @@
     "url": "git+https://github.com/RobotWebTools/rclnodejs.git"
   },
   "devDependencies": {
-    "@eslint/js": "^9.36.0",
+    "@eslint/js": "^10.0.1",
     "@types/node": "^25.0.2",
     "@typescript-eslint/eslint-plugin": "^8.18.0",
     "@typescript-eslint/parser": "^8.18.0",
@@ -56,10 +56,10 @@
     "commander": "^14.0.0",
     "coveralls": "^3.1.1",
     "deep-equal": "^2.2.3",
-    "eslint": "^9.16.0",
+    "eslint": "^10.0.2",
     "eslint-config-prettier": "^10.0.2",
     "eslint-plugin-prettier": "^5.2.1",
-    "globals": "^16.0.0",
+    "globals": "^17.0.0",
     "husky": "^9.1.7",
     "jsdoc": "^4.0.4",
     "lint-staged": "^16.2.0",

package/rosidl_gen/packages.js

@@ -52,7 +52,12 @@ function getSubFolder(filePath, amentExecuted) {
   }
 
   if (amentExecuted) {
-    return filePath.match(/\w+\/share\/\w+\/(\w+)\//)[1];
+    const match = filePath.match(/\w+\/share\/\w+\/([\w-]+)\//);
+    if (match) {
+      // Handle non-standard subfolder names (e.g., msg-common, msg-ros2)
+      // by extracting only the base interface type before any hyphen.
+      return match[1].split('-')[0];
+    }
   }
   // If the |amentExecuted| equals to false, the file's extension will be assigned as
   // the name of sub folder.
@@ -223,7 +228,7 @@ async function findPackagesInDirectory(dir, useIDL) {
 
     // If there is a folder named 'share' under the root path, we consider that
     // the ament build tool has been executed and |amentExecuted| will be true.
-    fs.access(path.join(dir, 'share'), (err) => {
+    fs.stat(path.join(dir, 'share'), (err) => {
       if (err) {
         amentExecuted = false;
       }

package/src/rcl_bindings.cpp

@@ -14,7 +14,7 @@
 
 #include "rcl_bindings.h"
 
-#include <node.h>
+#include <node_version.h>
 #include <rcl/arguments.h>
 #include <rcl/rcl.h>
 

package/src/rcl_lifecycle_bindings.cpp

@@ -71,7 +71,30 @@ Napi::Value CreateLifecycleStateMachine(const Napi::CallbackInfo& info) {
   const rosidl_service_type_support_t* gs =
       GetServiceTypeSupport("lifecycle_msgs", "GetState");
 
-#if ROS_VERSION >= 2105
+#if ROS_VERSION >= 5000  // ROS2 Rolling
+  rcl_lifecycle_state_machine_options_t options =
+      rcl_lifecycle_get_default_state_machine_options();
+  options.enable_com_interface = info[1].As<Napi::Boolean>().Value();
+
+  RclHandle* clock_handle = RclHandle::Unwrap(info[2].As<Napi::Object>());
+  rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(clock_handle->ptr());
+
+  THROW_ERROR_IF_NOT_EQUAL(
+      RCL_RET_OK,
+      rcl_lifecycle_state_machine_init(state_machine, node, clock, pn, cs, gs,
+                                       gas, gat, gtg, &options),
+      rcl_get_error_string().str);
+
+  auto js_obj = RclHandle::NewInstance(
+      env, state_machine, node_handle, [node, env](void* ptr) {
+        rcl_lifecycle_state_machine_t* state_machine =
+            reinterpret_cast<rcl_lifecycle_state_machine_t*>(ptr);
+        rcl_ret_t ret = rcl_lifecycle_state_machine_fini(state_machine, node);
+        free(ptr);
+        THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
+                                           rcl_get_error_string().str);
+      });
+#elif ROS_VERSION >= 2105
   rcl_lifecycle_state_machine_options_t options =
       rcl_lifecycle_get_default_state_machine_options();
   options.enable_com_interface = info[1].As<Napi::Boolean>().Value();

package/src/rcl_subscription_bindings.cpp

@@ -38,9 +38,9 @@ Napi::Value RclTake(const Napi::CallbackInfo& info) {
   rcl_ret_t ret = rcl_take(subscription, msg_taken, nullptr, nullptr);
 
   if (ret != RCL_RET_OK && ret != RCL_RET_SUBSCRIPTION_TAKE_FAILED) {
+    std::string error_string = rcl_get_error_string().str;
     rcl_reset_error();
-    Napi::Error::New(env, rcl_get_error_string().str)
-        .ThrowAsJavaScriptException();
+    Napi::Error::New(env, error_string).ThrowAsJavaScriptException();
     return Napi::Boolean::New(env, false);
   }
 
@@ -99,7 +99,7 @@ Napi::Value CreateSubscription(const Napi::CallbackInfo& info) {
           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*)));
+            argv[i] = reinterpret_cast<char*>(malloc(len * sizeof(char)));
             snprintf(argv[i], len, "%s", arg.c_str());
           }
         }
@@ -109,9 +109,9 @@ Napi::Value CreateSubscription(const Napi::CallbackInfo& info) {
           expression.c_str(), argc, (const char**)argv, &subscription_ops);
 
       if (ret != RCL_RET_OK) {
+        std::string error_string = rcl_get_error_string().str;
         rcl_reset_error();
-        Napi::Error::New(env, rcl_get_error_string().str)
-            .ThrowAsJavaScriptException();
+        Napi::Error::New(env, error_string).ThrowAsJavaScriptException();
       }
 
       if (argc) {
@@ -120,6 +120,11 @@ Napi::Value CreateSubscription(const Napi::CallbackInfo& info) {
         }
         free(argv);
       }
+
+      if (ret != RCL_RET_OK) {
+        free(subscription);
+        return env.Undefined();
+      }
     }
   }
 
@@ -127,11 +132,15 @@ Napi::Value CreateSubscription(const Napi::CallbackInfo& info) {
       GetMessageTypeSupport(package_name, message_sub_folder, message_name);
 
   if (ts) {
-    THROW_ERROR_IF_NOT_EQUAL(
-        RCL_RET_OK,
-        rcl_subscription_init(subscription, node, ts, topic.c_str(),
-                              &subscription_ops),
-        rcl_get_error_string().str);
+    rcl_ret_t ret = rcl_subscription_init(subscription, node, ts, topic.c_str(),
+                                          &subscription_ops);
+    if (ret != RCL_RET_OK) {
+      std::string error_msg = rcl_get_error_string().str;
+      rcl_reset_error();
+      Napi::Error::New(env, error_msg).ThrowAsJavaScriptException();
+      free(subscription);
+      return env.Undefined();
+    }
 
     auto js_obj = RclHandle::NewInstance(
         env, subscription, node_handle, [node, env](void* ptr) {
@@ -139,14 +148,18 @@ Napi::Value CreateSubscription(const Napi::CallbackInfo& info) {
               reinterpret_cast<rcl_subscription_t*>(ptr);
           rcl_ret_t ret = rcl_subscription_fini(subscription, node);
           free(ptr);
-          THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
-                                             rcl_get_error_string().str);
+          if (ret != RCL_RET_OK) {
+            std::string error_msg = rcl_get_error_string().str;
+            rcl_reset_error();
+            Napi::Error::New(env, error_msg).ThrowAsJavaScriptException();
+          }
         });
 
     return js_obj;
   } else {
     Napi::Error::New(env, GetErrorMessageAndClear())
         .ThrowAsJavaScriptException();
+    free(subscription);
     return env.Undefined();
   }
 }
@@ -235,7 +248,7 @@ Napi::Value SetContentFilter(const Napi::CallbackInfo& info) {
       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*)));
+        argv[i] = reinterpret_cast<char*>(malloc(len * sizeof(char)));
         snprintf(argv[i], len, "%s", arg.c_str());
       }
     }
@@ -245,15 +258,23 @@ Napi::Value SetContentFilter(const Napi::CallbackInfo& info) {
   rcl_subscription_content_filter_options_t options =
       rcl_get_zero_initialized_subscription_content_filter_options();
 
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK,
-      rcl_subscription_content_filter_options_set(
-          subscription, expression.c_str(), argc, (const char**)argv, &options),
-      rcl_get_error_string().str);
+  rcl_ret_t ret = rcl_subscription_content_filter_options_set(
+      subscription, expression.c_str(), argc, (const char**)argv, &options);
+
+  if (ret != RCL_RET_OK) {
+    if (argc) {
+      for (int i = 0; i < argc; i++) {
+        free(argv[i]);
+      }
+      free(argv);
+    }
+    std::string error_string = rcl_get_error_string().str;
+    rcl_reset_error();
+    Napi::Error::New(env, error_string).ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
 
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK, rcl_subscription_set_content_filter(subscription, &options),
-      rcl_get_error_string().str);
+  ret = rcl_subscription_set_content_filter(subscription, &options);
 
   if (argc) {
     for (int i = 0; i < argc; i++) {
@@ -262,6 +283,27 @@ Napi::Value SetContentFilter(const Napi::CallbackInfo& info) {
     free(argv);
   }
 
+  std::string error_string = "";
+  if (ret != RCL_RET_OK) {
+    error_string = rcl_get_error_string().str;
+    rcl_reset_error();
+  }
+
+  rcl_ret_t fini_ret =
+      rcl_subscription_content_filter_options_fini(subscription, &options);
+
+  if (ret != RCL_RET_OK) {
+    Napi::Error::New(env, error_string).ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  if (fini_ret != RCL_RET_OK) {
+    error_string = rcl_get_error_string().str;
+    rcl_reset_error();
+    Napi::Error::New(env, error_string).ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
   return Napi::Boolean::New(env, true);
 }
 
@@ -277,15 +319,33 @@ Napi::Value ClearContentFilter(const Napi::CallbackInfo& info) {
   rcl_subscription_content_filter_options_t options =
       rcl_get_zero_initialized_subscription_content_filter_options();
 
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK,
-      rcl_subscription_content_filter_options_init(
-          subscription, "", 0, (const char**)nullptr, &options),
-      rcl_get_error_string().str);
+  rcl_ret_t ret = rcl_subscription_content_filter_options_init(
+      subscription, "", 0, (const char**)nullptr, &options);
+
+  if (ret != RCL_RET_OK) {
+    std::string error_string = rcl_get_error_string().str;
+    rcl_reset_error();
+    Napi::Error::New(env, error_string).ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  ret = rcl_subscription_set_content_filter(subscription, &options);
+  rcl_ret_t fini_ret =
+      rcl_subscription_content_filter_options_fini(subscription, &options);
+
+  if (ret != RCL_RET_OK) {
+    std::string error_string = rcl_get_error_string().str;
+    rcl_reset_error();
+    Napi::Error::New(env, error_string).ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
 
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK, rcl_subscription_set_content_filter(subscription, &options),
-      rcl_get_error_string().str);
+  if (fini_ret != RCL_RET_OK) {
+    std::string error_string = rcl_get_error_string().str;
+    rcl_reset_error();
+    Napi::Error::New(env, error_string).ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
 
   return Napi::Boolean::New(env, true);
 }
@@ -303,9 +363,9 @@ Napi::Value GetContentFilter(const Napi::CallbackInfo& info) {
 
   rcl_ret_t ret = rcl_subscription_get_content_filter(subscription, &options);
   if (ret != RCL_RET_OK) {
-    Napi::Error::New(env, rcl_get_error_string().str)
-        .ThrowAsJavaScriptException();
+    std::string error_msg = rcl_get_error_string().str;
     rcl_reset_error();
+    Napi::Error::New(env, error_msg).ThrowAsJavaScriptException();
     return env.Undefined();
   }
 
@@ -331,9 +391,9 @@ Napi::Value GetContentFilter(const Napi::CallbackInfo& info) {
   rcl_ret_t fini_ret =
       rcl_subscription_content_filter_options_fini(subscription, &options);
   if (fini_ret != RCL_RET_OK) {
-    Napi::Error::New(env, rcl_get_error_string().str)
-        .ThrowAsJavaScriptException();
+    std::string error_msg = rcl_get_error_string().str;
     rcl_reset_error();
+    Napi::Error::New(env, error_msg).ThrowAsJavaScriptException();
     return env.Undefined();
   }
 
@@ -347,9 +407,12 @@ Napi::Value GetPublisherCount(const Napi::CallbackInfo& info) {
       RclHandle::Unwrap(info[0].As<Napi::Object>())->ptr());
 
   size_t count = 0;
-  THROW_ERROR_IF_NOT_EQUAL(
-      rcl_subscription_get_publisher_count(subscription, &count), RCL_RET_OK,
-      rcl_get_error_string().str);
+  rcl_ret_t ret = rcl_subscription_get_publisher_count(subscription, &count);
+  if (ret != RCL_RET_OK) {
+    std::string error_msg = rcl_get_error_string().str;
+    rcl_reset_error();
+    Napi::Error::New(env, error_msg).ThrowAsJavaScriptException();
+  }
 
   return Napi::Number::New(env, count);
 }

package/test_data_integrity.js

@@ -0,0 +1,108 @@
+// Data integrity + throughput test for subscription
+'use strict';
+
+const rclnodejs = require('./index.js');
+
+const PUBLISH_HZ = 50;
+const TEST_DURATION_SEC = 10;
+
+async function main() {
+  await rclnodejs.init();
+
+  const pubNode = new rclnodejs.Node('data_pub_node');
+  const subNode = new rclnodejs.Node('data_sub_node');
+
+  const publisher = pubNode.createPublisher(
+    'std_msgs/msg/Float64MultiArray',
+    '/data_integrity_topic'
+  );
+
+  let msgCount = 0;
+  let errCount = 0;
+  let lastTs = null;
+  const hzSamples = [];
+  const errors = [];
+
+  subNode.createSubscription(
+    'std_msgs/msg/Float64MultiArray',
+    '/data_integrity_topic',
+    (msg) => {
+      const now = Date.now();
+      msgCount++;
+
+      // --- Data validation ---
+      // Each published message has data = [seqNo, seqNo*1.5, seqNo*2.5]
+      // Verify structure and values
+      if (!msg || !msg.data) {
+        errCount++;
+        errors.push(`msg#${msgCount}: missing data field, got: ${JSON.stringify(msg)}`);
+      } else if (!Array.isArray(msg.data) && !(msg.data instanceof Float64Array)) {
+        errCount++;
+        errors.push(`msg#${msgCount}: data is not array-like, type=${typeof msg.data}`);
+      } else if (msg.data.length !== 3) {
+        errCount++;
+        errors.push(`msg#${msgCount}: expected 3 elements, got ${msg.data.length}`);
+      } else {
+        const seqNo = msg.data[0];
+        const expectedB = seqNo * 1.5;
+        const expectedC = seqNo * 2.5;
+
+        if (Math.abs(msg.data[1] - expectedB) > 1e-9) {
+          errCount++;
+          errors.push(
+            `msg#${msgCount}: data[1] expected ${expectedB}, got ${msg.data[1]}`
+          );
+        }
+        if (Math.abs(msg.data[2] - expectedC) > 1e-9) {
+          errCount++;
+          errors.push(
+            `msg#${msgCount}: data[2] expected ${expectedC}, got ${msg.data[2]}`
+          );
+        }
+      }
+
+      if (lastTs) {
+        hzSamples.push(1000 / (now - lastTs));
+      }
+      lastTs = now;
+    }
+  );
+
+  pubNode.spin();
+  subNode.spin();
+
+  let pubSeq = 0;
+  const pubInterval = setInterval(() => {
+    pubSeq++;
+    publisher.publish({ data: [pubSeq, pubSeq * 1.5, pubSeq * 2.5] });
+  }, 1000 / PUBLISH_HZ);
+
+  setTimeout(() => {
+    clearInterval(pubInterval);
+
+    console.log(`\n=== Data Integrity Test Results ===`);
+    console.log(`Published:    ${pubSeq} messages at ${PUBLISH_HZ} Hz`);
+    console.log(`Received:     ${msgCount} messages`);
+    console.log(`Data errors:  ${errCount}`);
+
+    if (errors.length > 0) {
+      console.log(`\nFirst 10 errors:`);
+      errors.slice(0, 10).forEach((e) => console.log(`  ${e}`));
+    }
+
+    if (hzSamples.length > 0) {
+      const avgHz = hzSamples.reduce((a, b) => a + b, 0) / hzSamples.length;
+      console.log(`\nAvg Hz:       ${avgHz.toFixed(2)}`);
+    }
+
+    const pass = errCount === 0 && msgCount > 0;
+    console.log(`\nResult:       ${pass ? 'PASS - all data correct' : 'FAIL'}`);
+
+    pubNode.stop();
+    subNode.stop();
+    rclnodejs.shutdown();
+    process.exit(pass ? 0 : 1);
+  }, TEST_DURATION_SEC * 1000);
+}
+
+main().catch(console.error);

package/test_repro_exact.js

@@ -0,0 +1,57 @@
+// Thorough latency/throughput test matching the exact issue scenario
+'use strict';
+
+const rclnodejs = require('./index.js');
+
+async function main() {
+  await rclnodejs.init();
+
+  const node = new rclnodejs.Node('test_node');
+
+  let lastTs;
+  let msgCount = 0;
+  const hzSamples = [];
+
+  node.createSubscription(
+    'std_msgs/msg/Float64MultiArray',
+    '/map_to_base_link_pose2d',
+    (msg) => {
+      const now = Date.now();
+      msgCount++;
+      if (lastTs) {
+        const hz = 1000 / (now - lastTs);
+        hzSamples.push(hz);
+        console.log('Raw Hz:', hz.toFixed(2));
+      }
+      lastTs = now;
+    }
+  );
+
+  rclnodejs.spin(node);
+
+  console.log('Waiting for messages on /map_to_base_link_pose2d at ~10Hz...');
+  console.log('Run this in another terminal:');
+  console.log(
+    '  ros2 topic pub -r 10 /map_to_base_link_pose2d std_msgs/msg/Float64MultiArray "{data: [1.0, 2.0, 3.0]}"'
+  );
+
+  setTimeout(() => {
+    if (hzSamples.length > 0) {
+      const avgHz = hzSamples.reduce((a, b) => a + b, 0) / hzSamples.length;
+      console.log(`\n--- Summary ---`);
+      console.log(`Messages: ${msgCount}, Avg Hz: ${avgHz.toFixed(2)}`);
+      if (avgHz < 5) {
+        console.log('*** REGRESSION DETECTED ***');
+      } else {
+        console.log('Performance OK');
+      }
+    } else {
+      console.log('No messages received');
+    }
+    node.stop();
+    rclnodejs.shutdown();
+    process.exit(0);
+  }, 15000);
+}
+
+main().catch(console.error);

package/test_repro_hz.js

@@ -0,0 +1,86 @@
+// Reprocer for https://github.com/RobotWebTools/rclnodejs/issues/1394
+// Tests subscription throughput at ~10Hz publishing rate
+'use strict';
+
+const rclnodejs = require('./index.js');
+
+const PUBLISH_HZ = 10;
+const TEST_DURATION_SEC = 10;
+
+async function main() {
+  await rclnodejs.init();
+
+  const pubNode = new rclnodejs.Node('test_pub_node');
+  const subNode = new rclnodejs.Node('test_sub_node');
+
+  const publisher = pubNode.createPublisher(
+    'std_msgs/msg/Float64MultiArray',
+    '/test_hz_topic'
+  );
+
+  let msgCount = 0;
+  let lastTs = null;
+  const hzSamples = [];
+
+  subNode.createSubscription(
+    'std_msgs/msg/Float64MultiArray',
+    '/test_hz_topic',
+    (msg) => {
+      const now = Date.now();
+      msgCount++;
+      if (lastTs) {
+        const hz = 1000 / (now - lastTs);
+        hzSamples.push(hz);
+      }
+      lastTs = now;
+    }
+  );
+
+  pubNode.spin();
+  subNode.spin();
+
+  // Publish at target Hz
+  let pubCount = 0;
+  const pubInterval = setInterval(() => {
+    publisher.publish({ data: [1.0, 2.0, 3.0] });
+    pubCount++;
+  }, 1000 / PUBLISH_HZ);
+
+  // Wait for test duration then report
+  setTimeout(() => {
+    clearInterval(pubInterval);
+
+    if (hzSamples.length > 0) {
+      const avgHz =
+        hzSamples.reduce((a, b) => a + b, 0) / hzSamples.length;
+      const minHz = Math.min(...hzSamples);
+      const maxHz = Math.max(...hzSamples);
+
+      console.log(`Published:  ${pubCount} messages`);
+      console.log(`Received:   ${msgCount} messages`);
+      console.log(`Avg Hz:     ${avgHz.toFixed(2)}`);
+      console.log(`Min Hz:     ${minHz.toFixed(2)}`);
+      console.log(`Max Hz:     ${maxHz.toFixed(2)}`);
+      console.log(
+        `Expected:   ~${PUBLISH_HZ} Hz`
+      );
+
+      if (avgHz < PUBLISH_HZ * 0.5) {
+        console.log(
+          `\n*** REGRESSION DETECTED: Average Hz (${avgHz.toFixed(2)}) is less than 50% of expected (${PUBLISH_HZ}) ***`
+        );
+      } else {
+        console.log('\nPerformance looks OK.');
+      }
+    } else {
+      console.log('No messages received!');
+    }
+
+    pubNode.stop();
+    subNode.stop();
+    rclnodejs.shutdown();
+    process.exit(0);
+  }, TEST_DURATION_SEC * 1000);
+}
+
+main().catch(console.error);

package/test_repro_pub.js

@@ -0,0 +1,36 @@
+// Publisher for repro test - runs in separate process
+'use strict';
+
+const rclnodejs = require('./index.js');
+
+const PUBLISH_HZ = parseInt(process.argv[2] || '100');
+
+async function main() {
+  await rclnodejs.init();
+
+  const node = new rclnodejs.Node('test_publisher_node');
+  const publisher = node.createPublisher(
+    'std_msgs/msg/Float64MultiArray',
+    '/test_hz_topic'
+  );
+
+  node.spin();
+
+  let pubCount = 0;
+  console.log(`Publishing at ${PUBLISH_HZ} Hz...`);
+
+  const pubInterval = setInterval(() => {
+    publisher.publish({ data: [1.0, 2.0, 3.0] });
+    pubCount++;
+  }, 1000 / PUBLISH_HZ);
+
+  setTimeout(() => {
+    clearInterval(pubInterval);
+    console.log(`Published ${pubCount} messages total`);
+    node.stop();
+    rclnodejs.shutdown();
+    process.exit(0);
+  }, 15000);
+}
+
+main().catch(console.error);

package/test_repro_stress.js

@@ -0,0 +1,83 @@
+// Multi-frequency stress test for subscription performance
+'use strict';
+
+const rclnodejs = require('./index.js');
+
+const PUBLISH_HZ = parseInt(process.argv[2] || '100');
+const TEST_DURATION_SEC = 10;
+
+async function main() {
+  await rclnodejs.init();
+
+  const pubNode = new rclnodejs.Node('stress_pub_node');
+  const subNode = new rclnodejs.Node('stress_sub_node');
+
+  const publisher = pubNode.createPublisher(
+    'std_msgs/msg/Float64MultiArray',
+    '/stress_test_topic'
+  );
+
+  let msgCount = 0;
+  let lastTs = null;
+  const hzSamples = [];
+
+  subNode.createSubscription(
+    'std_msgs/msg/Float64MultiArray',
+    '/stress_test_topic',
+    (msg) => {
+      const now = Date.now();
+      msgCount++;
+      if (lastTs) {
+        const hz = 1000 / (now - lastTs);
+        hzSamples.push(hz);
+      }
+      lastTs = now;
+    }
+  );
+
+  pubNode.spin();
+  subNode.spin();
+
+  let pubCount = 0;
+
+  // Use high-resolution timer for more precise publishing
+  const intervalMs = 1000 / PUBLISH_HZ;
+  const pubInterval = setInterval(() => {
+    publisher.publish({ data: [1.0, 2.0, 3.0, 4.0, 5.0] });
+    pubCount++;
+  }, intervalMs);
+
+  setTimeout(() => {
+    clearInterval(pubInterval);
+
+    if (hzSamples.length > 0) {
+      const avgHz = hzSamples.reduce((a, b) => a + b, 0) / hzSamples.length;
+      const minHz = Math.min(...hzSamples);
+      const maxHz = Math.max(...hzSamples);
+      const dropRate = ((pubCount - msgCount) / pubCount * 100);
+
+      console.log(`Target:     ${PUBLISH_HZ} Hz`);
+      console.log(`Published:  ${pubCount}`);
+      console.log(`Received:   ${msgCount}`);
+      console.log(`Avg Hz:     ${avgHz.toFixed(2)}`);
+      console.log(`Min Hz:     ${minHz.toFixed(2)}`);
+      console.log(`Max Hz:     ${maxHz.toFixed(2)}`);
+      console.log(`Drop rate:  ${dropRate.toFixed(1)}%`);
+
+      if (avgHz < PUBLISH_HZ * 0.5) {
+        console.log(`FAIL: Avg Hz significantly below target`);
+      } else {
+        console.log(`PASS`);
+      }
+    } else {
+      console.log('No messages received!');
+    }
+
+    pubNode.stop();
+    subNode.stop();
+    rclnodejs.shutdown();
+    process.exit(0);
+  }, TEST_DURATION_SEC * 1000);
+}
+
+main().catch(console.error);

package/test_repro_sub.js

@@ -0,0 +1,64 @@
+// Subscriber for repro test - runs in separate process
+'use strict';
+
+const rclnodejs = require('./index.js');
+
+async function main() {
+  await rclnodejs.init();
+
+  const node = new rclnodejs.Node('test_subscriber_node');
+
+  let msgCount = 0;
+  let lastTs = null;
+  const hzSamples = [];
+  let startTime = null;
+
+  node.createSubscription(
+    'std_msgs/msg/Float64MultiArray',
+    '/test_hz_topic',
+    (msg) => {
+      const now = Date.now();
+      msgCount++;
+      if (!startTime) startTime = now;
+      if (lastTs) {
+        const hz = 1000 / (now - lastTs);
+        hzSamples.push(hz);
+        if (msgCount % 50 === 0) {
+          const recentSamples = hzSamples.slice(-50);
+          const recentAvg =
+            recentSamples.reduce((a, b) => a + b, 0) / recentSamples.length;
+          console.log(
+            `msg#${msgCount} recent avg Hz: ${recentAvg.toFixed(2)}`
+          );
+        }
+      }
+      lastTs = now;
+    }
+  );
+
+  node.spin();
+
+  setTimeout(() => {
+    if (hzSamples.length > 0) {
+      const avgHz =
+        hzSamples.reduce((a, b) => a + b, 0) / hzSamples.length;
+      const minHz = Math.min(...hzSamples);
+      const maxHz = Math.max(...hzSamples);
+      const elapsed = (Date.now() - startTime) / 1000;
+
+      console.log(`\n--- Results ---`);
+      console.log(`Received:   ${msgCount} messages in ${elapsed.toFixed(1)}s`);
+      console.log(`Avg Hz:     ${avgHz.toFixed(2)}`);
+      console.log(`Min Hz:     ${minHz.toFixed(2)}`);
+      console.log(`Max Hz:     ${maxHz.toFixed(2)}`);
+    } else {
+      console.log('No messages received!');
+    }
+
+    node.stop();
+    rclnodejs.shutdown();
+    process.exit(0);
+  }, 12000);
+}
+
+main().catch(console.error);

package/test_xproc_data.js

@@ -0,0 +1,64 @@
+// Cross-process data integrity test: validates data from external ROS2 publisher
+'use strict';
+
+const rclnodejs = require('./index.js');
+
+const EXPECTED_DATA = [1.0, 2.0, 3.0];
+
+async function main() {
+  await rclnodejs.init();
+
+  const node = new rclnodejs.Node('xproc_data_sub');
+  let msgCount = 0;
+  let errCount = 0;
+  const errors = [];
+
+  node.createSubscription(
+    'std_msgs/msg/Float64MultiArray',
+    '/xproc_data_topic',
+    (msg) => {
+      msgCount++;
+
+      if (!msg || !msg.data) {
+        errCount++;
+        errors.push(`msg#${msgCount}: missing data`);
+      } else {
+        const arr = Array.from(msg.data);
+        for (let i = 0; i < EXPECTED_DATA.length; i++) {
+          if (Math.abs(arr[i] - EXPECTED_DATA[i]) > 1e-9) {
+            errCount++;
+            errors.push(
+              `msg#${msgCount}: data[${i}] expected ${EXPECTED_DATA[i]}, got ${arr[i]}`
+            );
+          }
+        }
+        if (arr.length !== EXPECTED_DATA.length) {
+          errCount++;
+          errors.push(
+            `msg#${msgCount}: expected ${EXPECTED_DATA.length} elements, got ${arr.length}`
+          );
+        }
+      }
+    }
+  );
+
+  rclnodejs.spin(node);
+
+  console.log('Listening on /xproc_data_topic for 10s...');
+
+  setTimeout(() => {
+    console.log(`\n=== Cross-Process Data Integrity ===`);
+    console.log(`Received:    ${msgCount} messages`);
+    console.log(`Data errors: ${errCount}`);
+    if (errors.length > 0) {
+      errors.slice(0, 10).forEach((e) => console.log(`  ${e}`));
+    }
+    const pass = errCount === 0 && msgCount > 0;
+    console.log(`Result:      ${pass ? 'PASS' : 'FAIL'}`);
+    node.stop();
+    rclnodejs.shutdown();
+    process.exit(0);
+  }, 10000);
+}
+
+main().catch(console.error);