fix: improve type description robustness and fix console issues

- Add sequence length safety check (max 100M elements) to prevent OOM from malformed data
- Fix type description dependency resolution to handle proper ordering
- Preserve explicit type_info when provided (don't overwrite with schema-derived hash)
- Fix blocking operation in DynamicTopicSubscriber (use spawn_blocking)
- Set default-run for ros-z-console and remove test binary

Author: YuanYuYuan

ros-z-cdr/src/primitives.rs

@@ -333,9 +333,21 @@ impl<'a, BO: ByteOrder> CdrReader<'a, BO> {
     }
 
     /// Read a sequence length prefix.
+    ///
+    /// # Safety
+    /// Includes a sanity check to prevent absurd allocations from malformed data.
+    /// Maximum sequence length is 100 million elements (~400MB for float32 arrays).
     #[inline]
     pub fn read_sequence_length(&mut self) -> Result<usize> {
-        Ok(self.read_u32()? as usize)
+        const MAX_SEQUENCE_LENGTH: u32 = 100_000_000;
+        let len = self.read_u32()?;
+        if len > MAX_SEQUENCE_LENGTH {
+            return Err(Error::Custom(format!(
+                "Sequence length {} exceeds maximum allowed ({}). Possible schema mismatch or corrupted data.",
+                len, MAX_SEQUENCE_LENGTH
+            )));
+        }
+        Ok(len as usize)
     }
 
     /// Read raw bytes with length prefix.

ros-z-console/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2024"
 description = "ROS 2 Graph Inspector & Dataflow Monitor TUI"
 homepage = "https://github.com/ZettaScaleLabs/ros-z"
+default-run = "ros-z-console"
 
 [dependencies]
 ros-z = { path = "../ros-z" }
@@ -21,7 +22,3 @@ tracing = { workspace = true }
 tracing-subscriber = { version = "0.3", features = ["json", "env-filter"] }
 zenoh = { workspace = true }
 chrono = { version = "0.4", features = ["serde"] }
-
-[[bin]]
-name = "simple-test-pub"
-path = "simple-test-pub.rs"

ros-z-console/src/core/dynamic_subscriber.rs

@@ -63,7 +63,7 @@ impl DynamicTopicSubscriber {
         // Spawn background task to forward messages to channel
         let subscriber = Arc::new(subscriber);
         let sub_clone = subscriber.clone();
-        tokio::spawn(async move {
+        tokio::task::spawn_blocking(move || {
             loop {
                 match sub_clone.recv() {
                     Ok(msg) => {

ros-z/src/dynamic/type_description.rs

@@ -247,10 +247,31 @@ pub fn type_description_msg_to_schema(
     }
 
     // Second pass: resolve nested types in referenced schemas
+    // Process in dependency order: iterate until all are resolved
     let mut resolved_map: HashMap<String, Arc<MessageSchema>> = HashMap::new();
-    for ref_td in &msg.referenced_type_descriptions {
-        let schema = type_description_to_schema_full(ref_td, &type_map)?;
-        resolved_map.insert(ref_td.type_name.clone(), Arc::new(schema));
+    let mut remaining: Vec<&TypeDescription> = msg.referenced_type_descriptions.iter().collect();
+
+    while !remaining.is_empty() {
+        let mut made_progress = false;
+        remaining.retain(|ref_td| {
+            // Try to build with current resolved_map
+            match type_description_to_schema_full(ref_td, &resolved_map) {
+                Ok(schema) => {
+                    resolved_map.insert(ref_td.type_name.clone(), Arc::new(schema));
+                    made_progress = true;
+                    false // Remove from remaining
+                }
+                Err(_) => true // Keep in remaining, dependencies not ready yet
+            }
+        });
+
+        if !made_progress && !remaining.is_empty() {
+            // Circular dependency or missing type
+            return Err(DynamicError::SerializationError(format!(
+                "Cannot resolve dependencies for types: {}",
+                remaining.iter().map(|t| t.type_name.as_str()).collect::<Vec<_>>().join(", ")
+            )));
+        }
     }
 
     // Build the main schema with resolved references

ros-z/src/pubsub.rs

@@ -141,29 +141,33 @@ impl<T, S> ZPubBuilder<T, S> {
     pub fn with_dyn_schema(mut self, schema: Arc<crate::dynamic::schema::MessageSchema>) -> Self {
         use crate::dynamic::MessageSchemaTypeDescription;
 
-        // Compute TypeInfo from schema for proper key expression matching with ROS 2
-        // Convert ROS 2 canonical name to DDS name
-        // "std_msgs/msg/String" → "std_msgs::msg::dds_::String_"
-        let dds_name = schema.type_name
-            .replace("/msg/", "::msg::dds_::")
-            .replace("/srv/", "::srv::dds_::")
-            .replace("/action/", "::action::dds_::")
-            + "_";
-
-        // Convert schema TypeHash to entity TypeHash via RIHS string
-        let type_hash = match schema.compute_type_hash() {
-            Ok(hash) => {
-                let rihs_string = hash.to_rihs_string();
-                crate::entity::TypeHash::from_rihs_string(&rihs_string)
-                    .unwrap_or_else(crate::entity::TypeHash::zero)
-            }
-            Err(_) => crate::entity::TypeHash::zero(),
-        };
+        // Only compute and set type_info if it hasn't been set already
+        // (e.g., from create_dyn_sub_auto which provides the publisher's hash)
+        if self.entity.type_info.is_none() {
+            // Compute TypeInfo from schema for proper key expression matching with ROS 2
+            // Convert ROS 2 canonical name to DDS name
+            // "std_msgs/msg/String" → "std_msgs::msg::dds_::String_"
+            let dds_name = schema.type_name
+                .replace("/msg/", "::msg::dds_::")
+                .replace("/srv/", "::srv::dds_::")
+                .replace("/action/", "::action::dds_::")
+                + "_";
+
+            // Convert schema TypeHash to entity TypeHash via RIHS string
+            let type_hash = match schema.compute_type_hash() {
+                Ok(hash) => {
+                    let rihs_string = hash.to_rihs_string();
+                    crate::entity::TypeHash::from_rihs_string(&rihs_string)
+                        .unwrap_or_else(crate::entity::TypeHash::zero)
+                }
+                Err(_) => crate::entity::TypeHash::zero(),
+            };
 
-        self.entity.type_info = Some(crate::entity::TypeInfo {
-            name: dds_name,
-            hash: type_hash,
-        });
+            self.entity.type_info = Some(crate::entity::TypeInfo {
+                name: dds_name,
+                hash: type_hash,
+            });
+        }
 
         self.dyn_schema = Some(schema);
         self
@@ -449,29 +453,33 @@ where
     pub fn with_dyn_schema(mut self, schema: Arc<crate::dynamic::schema::MessageSchema>) -> Self {
         use crate::dynamic::MessageSchemaTypeDescription;
 
-        // Compute TypeInfo from schema for proper key expression matching with ROS 2
-        // Convert ROS 2 canonical name to DDS name
-        // "std_msgs/msg/String" → "std_msgs::msg::dds_::String_"
-        let dds_name = schema.type_name
-            .replace("/msg/", "::msg::dds_::")
-            .replace("/srv/", "::srv::dds_::")
-            .replace("/action/", "::action::dds_::")
-            + "_";
-
-        // Convert schema TypeHash to entity TypeHash via RIHS string
-        let type_hash = match schema.compute_type_hash() {
-            Ok(hash) => {
-                let rihs_string = hash.to_rihs_string();
-                crate::entity::TypeHash::from_rihs_string(&rihs_string)
-                    .unwrap_or_else(crate::entity::TypeHash::zero)
-            }
-            Err(_) => crate::entity::TypeHash::zero(),
-        };
+        // Only compute and set type_info if it hasn't been set already
+        // (e.g., from create_dyn_sub_auto which provides the publisher's hash)
+        if self.entity.type_info.is_none() {
+            // Compute TypeInfo from schema for proper key expression matching with ROS 2
+            // Convert ROS 2 canonical name to DDS name
+            // "std_msgs/msg/String" → "std_msgs::msg::dds_::String_"
+            let dds_name = schema.type_name
+                .replace("/msg/", "::msg::dds_::")
+                .replace("/srv/", "::srv::dds_::")
+                .replace("/action/", "::action::dds_::")
+                + "_";
+
+            // Convert schema TypeHash to entity TypeHash via RIHS string
+            let type_hash = match schema.compute_type_hash() {
+                Ok(hash) => {
+                    let rihs_string = hash.to_rihs_string();
+                    crate::entity::TypeHash::from_rihs_string(&rihs_string)
+                        .unwrap_or_else(crate::entity::TypeHash::zero)
+                }
+                Err(_) => crate::entity::TypeHash::zero(),
+            };
 
-        self.entity.type_info = Some(crate::entity::TypeInfo {
-            name: dds_name,
-            hash: type_hash,
-        });
+            self.entity.type_info = Some(crate::entity::TypeInfo {
+                name: dds_name,
+                hash: type_hash,
+            });
+        }
 
         self.dyn_schema = Some(schema);
         self