minot-cli 0.10.2__tar.gz → 0.11.1__tar.gz

{minot_cli-0.10.2 → minot_cli-0.11.1}/Cargo.lock

@@ -441,9 +441,9 @@ dependencies = [
 
 [[package]]
 name = "bindgen"
-version = "0.71.1"
+version = "0.72.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
 dependencies = [
  "bitflags 2.13.1",
  "cexpr",
@@ -3802,7 +3802,7 @@ dependencies = [
 
 [[package]]
 name = "minot"
-version = "0.10.2"
+version = "0.11.1"
 dependencies = [
  "anyhow",
  "bytesize",
@@ -3929,7 +3929,7 @@ dependencies = [
 
 [[package]]
 name = "mt_action"
-version = "0.10.2"
+version = "0.11.1"
 dependencies = [
  "anyhow",
  "log",
@@ -3944,7 +3944,7 @@ dependencies = [
 
 [[package]]
 name = "mt_bagread"
-version = "0.10.2"
+version = "0.11.1"
 dependencies = [
  "anyhow",
  "camino",
@@ -3965,7 +3965,7 @@ dependencies = [
 
 [[package]]
 name = "mt_coord"
-version = "0.10.2"
+version = "0.11.1"
 dependencies = [
  "anyhow",
  "fs2",
@@ -3979,7 +3979,7 @@ dependencies = [
 
 [[package]]
 name = "mt_dataset"
-version = "0.10.2"
+version = "0.11.1"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -4022,7 +4022,7 @@ dependencies = [
 
 [[package]]
 name = "mt_flow"
-version = "0.10.2"
+version = "0.11.1"
 dependencies = [
  "anyhow",
  "env_logger",
@@ -4036,7 +4036,7 @@ dependencies = [
 
 [[package]]
 name = "mt_log"
-version = "0.10.2"
+version = "0.11.1"
 dependencies = [
  "env_filter 2.0.0",
  "env_logger",
@@ -4048,7 +4048,7 @@ dependencies = [
 
 [[package]]
 name = "mt_mtc"
-version = "0.10.2"
+version = "0.11.1"
 dependencies = [
  "anyhow",
  "ariadne",
@@ -4061,7 +4061,7 @@ dependencies = [
 
 [[package]]
 name = "mt_net"
-version = "0.10.2"
+version = "0.11.1"
 dependencies = [
  "anyhow",
  "rkyv 0.8.18",
@@ -4071,7 +4071,7 @@ dependencies = [
 
 [[package]]
 name = "mt_pubsub"
-version = "0.10.2"
+version = "0.11.1"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -4090,7 +4090,7 @@ dependencies = [
 
 [[package]]
 name = "mt_rat"
-version = "0.10.2"
+version = "0.11.1"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -4105,7 +4105,7 @@ dependencies = [
 
 [[package]]
 name = "mt_scope"
-version = "0.10.2"
+version = "0.11.1"
 dependencies = [
  "anyhow",
  "env_logger",
@@ -4118,7 +4118,7 @@ dependencies = [
 
 [[package]]
 name = "mt_sea"
-version = "0.10.2"
+version = "0.11.1"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -4135,7 +4135,7 @@ dependencies = [
 
 [[package]]
 name = "mt_service"
-version = "0.10.2"
+version = "0.11.1"
 dependencies = [
  "anyhow",
  "log",
@@ -4149,7 +4149,7 @@ dependencies = [
 
 [[package]]
 name = "mt_wind"
-version = "0.10.2"
+version = "0.11.1"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -5442,9 +5442,9 @@ checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
 [[package]]
 name = "r2r"
-version = "0.9.5"
+version = "0.9.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b36b61a6252e8e7a24919b9877dacf1dc9f0ac4c2d0eba91c68b35c1b2283ed2"
+checksum = "1fe8623ef13a4f3c25f4ef407c6032eee9e1c95d0912d8ed758f616cbb95a6cd"
 dependencies = [
  "force-send-sync",
  "futures",
@@ -5470,9 +5470,9 @@ dependencies = [
 
 [[package]]
 name = "r2r_actions"
-version = "0.9.5"
+version = "0.9.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ca8488195951aaadef421b470c823cd095848bebf2004ff96ef5d351067eac1"
+checksum = "441f4aca2b1dfe553ab40f03bd869445d02dccd7ddff4c5f32e3a681fcd47c57"
 dependencies = [
  "bindgen",
  "r2r_common",
@@ -5482,9 +5482,9 @@ dependencies = [
 
 [[package]]
 name = "r2r_common"
-version = "0.9.5"
+version = "0.9.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9838c2f88c9fd088f188eadbf9459371b1e576affd7b2df04c45cd1e44b79b99"
+checksum = "786a8b50036ed5d38a1dfbee73c711e270acd9a518b73351c66d541c1fa05422"
 dependencies = [
  "bindgen",
  "os_str_bytes",
@@ -5494,9 +5494,9 @@ dependencies = [
 
 [[package]]
 name = "r2r_macros"
-version = "0.9.5"
+version = "0.9.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be0cda9778c21f78d2d593df41298c14b6530061dc70d2d31eb831f7fec8d648"
+checksum = "743bfcbea83d856d97d222b3c3545d4848ba81572f1d52dc5b6bff4899b8583d"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -5505,9 +5505,9 @@ dependencies = [
 
 [[package]]
 name = "r2r_msg_gen"
-version = "0.9.5"
+version = "0.9.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03d5e77385a6b959014c14c45a444e1fbff99afad70912e120c21c30e7a65488"
+checksum = "db410864937e12357cd65f3e82c6fb7c8372d0493f154886952522bad87817c9"
 dependencies = [
  "bindgen",
  "force-send-sync",
@@ -5523,9 +5523,9 @@ dependencies = [
 
 [[package]]
 name = "r2r_rcl"
-version = "0.9.5"
+version = "0.9.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e5c208b2fbe64a00a42a70391f708298b6765769d39987286f4b7c82539561e"
+checksum = "7c0420d9ea790fe2b4f66f7a88c8a7901491075d2fed4037010b03173392a22a"
 dependencies = [
  "bindgen",
  "paste",

{minot_cli-0.10.2 → minot_cli-0.11.1}/Cargo.toml

@@ -4,12 +4,12 @@ members = ["minot", "mt_pubsub", "mt_coord", "mt_bagread", "mt_mtc", "mt_sea", "
 resolver = "3"
 
 [workspace.package]
-version = "0.10.2"
+version = "0.11.1"
 keywords = ["robotics"]
 license = "MIT OR Apache-2.0"
-repository = "https://codeberg.org/stelzo/minot"
+repository = "https://codeberg.org/stelzo/minot.git"
 edition = "2024"
-authors = ["Christopher Sieh <stelzo@steado.de>"]
+authors = ["stelzo <stelzo@steado.de>"]
 categories = ["science::robotics"]
 documentation = "https://uos.github.io/minot"
 homepage = "https://uos.github.io/minot"
@@ -28,19 +28,19 @@ exclude = [
 ]
 
 [workspace.dependencies]
-mt_sea = { path = "mt_sea", version = "0.10.2", default-features = false }
-mt_coord = { path = "mt_coord", version = "0.10.2", default-features = false }
-mt_pubsub = { path = "mt_pubsub", version = "0.10.2", default-features = false }
-mt_service = { path = "mt_service", version = "0.10.2", default-features = false }
-mt_action = { path = "mt_action", version = "0.10.2", default-features = false }
-mt_scope = { path = "mt_scope", version = "0.10.2", default-features = false }
-mt_bagread = { path = "mt_bagread", version = "0.10.2", default-features = false }
-mt_net = { path = "mt_net", version = "0.10.2", default-features = false }
-mt_flow = { path = "mt_flow", version = "0.10.2", default-features = false }
-mt_dataset = { path = "mt_dataset", version = "0.10.2", default-features = false }
-mt_wind = { path = "mt_wind", version = "0.10.2", default-features = false }
-mt_mtc = { path = "mt_mtc", version = "0.10.2", default-features = false }
-mt_log = { path = "mt_log", version = "0.10.2", default-features = false }
+mt_sea = { path = "mt_sea", version = "0.11.1", default-features = false }
+mt_coord = { path = "mt_coord", version = "0.11.1", default-features = false }
+mt_pubsub = { path = "mt_pubsub", version = "0.11.1", default-features = false }
+mt_service = { path = "mt_service", version = "0.11.1", default-features = false }
+mt_action = { path = "mt_action", version = "0.11.1", default-features = false }
+mt_scope = { path = "mt_scope", version = "0.11.1", default-features = false }
+mt_bagread = { path = "mt_bagread", version = "0.11.1", default-features = false }
+mt_net = { path = "mt_net", version = "0.11.1", default-features = false }
+mt_flow = { path = "mt_flow", version = "0.11.1", default-features = false }
+mt_dataset = { path = "mt_dataset", version = "0.11.1", default-features = false }
+mt_wind = { path = "mt_wind", version = "0.11.1", default-features = false }
+mt_mtc = { path = "mt_mtc", version = "0.11.1", default-features = false }
+mt_log = { path = "mt_log", version = "0.11.1", default-features = false }
 
 # Tools
 anyhow = "1.0"
@@ -88,7 +88,7 @@ rkyv = { version = "0.8.18" }
 serde = { version = "1.0", features = ["derive"] }
 
 # ROS
-r2r = "0.9.5"
+r2r = "0.9.7"
 hiroz = { version = "0.2.0", git = "https://github.com/ZettaScaleLabs/hiroz.git", tag = "v0.2.0" }
 hiroz-msgs = { version = "0.2.0", git = "https://github.com/ZettaScaleLabs/hiroz.git", tag = "v0.2.0", default-features = false, features = [
   "std_msgs",

{minot_cli-0.10.2 → minot_cli-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minot-cli
-Version: 0.10.2
+Version: 0.11.1
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License

{minot_cli-0.10.2 → minot_cli-0.11.1}/minot/Cargo.toml

@@ -109,6 +109,25 @@ assets = [
   ],
 ]
 
+[package.metadata.binstall]
+pkg-fmt = "tgz"
+bin-dir = "minot-{ target }/min/{ bin }{ binary-ext }"
+
+[package.metadata.binstall.overrides.x86_64-unknown-linux-gnu]
+pkg-url = "https://uos-robotics.codeberg.page/ppa/bin/minot-{ version }-x86_64-unknown-linux-gnu.tar.gz"
+
+[package.metadata.binstall.overrides.x86_64-unknown-linux-musl]
+pkg-url = "https://uos-robotics.codeberg.page/ppa/bin/minot-{ version }-x86_64-unknown-linux-musl.tar.gz"
+
+[package.metadata.binstall.overrides.aarch64-unknown-linux-gnu]
+pkg-url = "https://uos-robotics.codeberg.page/ppa/bin/minot-{ version }-aarch64-unknown-linux-gnu.tar.gz"
+
+[package.metadata.binstall.overrides.armv7-unknown-linux-gnueabihf]
+pkg-url = "https://uos-robotics.codeberg.page/ppa/bin/minot-{ version }-armv7-unknown-linux-gnueabihf.tar.gz"
+
+[package.metadata.binstall.overrides.aarch64-apple-darwin]
+pkg-url = "https://uos-robotics.codeberg.page/ppa/bin/minot-{ version }-aarch64-apple-darwin.tar.gz"
+
 [package.metadata.generate-rpm]
 
 [[package.metadata.generate-rpm.assets]]

{minot_cli-0.10.2 → minot_cli-0.11.1}/minot/src/gen_c.rs

@@ -295,7 +295,7 @@ fn ffi_lib_rs() -> String {
 use std::ffi::{c_char, CStr, CString};
 use std::sync::{Arc, LazyLock, Mutex, OnceLock};
 
-use mt_pubsub::{Node, NodeConfig, Qos};
+use mt_pubsub::{Durability, Node, NodeConfig, Qos, Reliability};
 pub mod generated;
 
 static RT: LazyLock<Mutex<Option<Arc<tokio::runtime::Runtime>>>> =
@@ -369,20 +369,31 @@ fn parse_level(filter: &str) -> Option<log::LevelFilter> {
     }
 }
 
-pub(crate) fn qos_from_i32(qos: i32) -> Option<Qos> {
-    match qos {
-        0 => Some(Qos::Reliable),
-        1 => Some(Qos::BestEffort),
-        _ => None,
-    }
+pub(crate) fn qos_from_i32(reliability: i32, durability: i32) -> Option<Qos> {
+    let reliability = match reliability {
+        0 => Reliability::Reliable,
+        1 => Reliability::TryReliable,
+        2 => Reliability::BestEffort,
+        _ => return None,
+    };
+    let durability = match durability {
+        0 => Durability::Volatile,
+        1 => Durability::TransientLocal,
+        _ => return None,
+    };
+    Some(Qos::new(reliability, durability))
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn mt_node_init(name: *const c_char, node_qos: i32) -> i32 {
+pub unsafe extern "C" fn mt_node_init(
+    name: *const c_char,
+    reliability: i32,
+    durability: i32,
+) -> i32 {
     if name.is_null() {
         return -1;
     }
-    let Some(mode) = qos_from_i32(node_qos) else {
+    let Some(mode) = qos_from_i32(reliability, durability) else {
         return -1;
     };
     let name_str = match CStr::from_ptr(name).to_str() {
@@ -492,11 +503,12 @@ fn go_core_file() -> String {
 
 /*
 #include <stdlib.h>
+#include <stdint.h>
 #cgo darwin CFLAGS: -mmacosx-version-min=26.2
 #cgo darwin LDFLAGS: -L${SRCDIR}/../../ffi/target/release -lminot_ffi -framework Security -framework CoreFoundation -mmacosx-version-min=26.2
-#cgo linux LDFLAGS: -L${SRCDIR}/../../ffi/target/release -lminot_ffi -lpthread -ldl
+#cgo linux LDFLAGS: -L${SRCDIR}/../../ffi/target/release -lminot_ffi -lpthread -ldl -lm
 
-extern int mt_node_init(const char* name, int node_qos);
+extern int mt_node_init(const char* name, int reliability, int durability);
 extern void mt_sleep_ms(uint64_t ms);
 extern int mt_node_shutdown_cancelled(void);
 extern int mt_configure_logging(const char* filter);
@@ -512,13 +524,37 @@ import (
 "unsafe"
 )
 
-type Qos int
+type Reliability int
 
 const (
-QosReliable   Qos = 0
-QosBestEffort Qos = 1
+ReliabilityReliable Reliability = iota
+ReliabilityTryReliable
+ReliabilityBestEffort
 )
 
+type Durability int
+
+const (
+DurabilityVolatile Durability = iota
+DurabilityTransientLocal
+)
+
+type Qos struct {
+Reliability Reliability
+Durability  Durability
+}
+
+var (
+QosReliable    = Qos{Reliability: ReliabilityReliable}
+QosTryReliable = Qos{Reliability: ReliabilityTryReliable}
+QosBestEffort  = Qos{Reliability: ReliabilityBestEffort}
+)
+
+func (q Qos) TransientLocal() Qos {
+q.Durability = DurabilityTransientLocal
+return q
+}
+
 type Node struct {
 Name     string
 shutdown chan struct{}
@@ -585,7 +621,7 @@ return cb, ok
 func NewNode(name string, nodeQos Qos) (*Node, error) {
 cName := C.CString(name)
 defer C.free(unsafe.Pointer(cName))
-if C.mt_node_init(cName, C.int(nodeQos)) != 0 {
+if C.mt_node_init(cName, C.int(nodeQos.Reliability), C.int(nodeQos.Durability)) != 0 {
 return nil, fmt.Errorf("failed to initialize Minot node")
 }
 n := &Node{Name: name, shutdown: make(chan struct{})}
@@ -767,9 +803,9 @@ fn go_typed_message_spec(
 
     let root_c = format!("minot_{}", root_go.to_snake_case());
     out.push_str(&format!(
-        "extern uintptr_t mt_create_{root_safe}_publisher(const char* topic, int qos);\n"
+        "extern uintptr_t mt_create_{root_safe}_publisher(const char* topic, int reliability, int durability);\n"
     ));
-    out.push_str(&format!("extern uintptr_t mt_create_{root_safe}_subscriber(const char* topic, uint32_t queue_size, int qos, uintptr_t callback_handle);\n"));
+    out.push_str(&format!("extern uintptr_t mt_create_{root_safe}_subscriber(const char* topic, uint32_t queue_size, int reliability, int durability, uintptr_t callback_handle);\n"));
     out.push_str(&format!("extern int mt_{root_safe}_publisher_publish(uintptr_t publisher_handle, const {root_c}* message);\n"));
     out.push_str(&format!("extern void mt_register_{root_safe}_callback(uintptr_t handle, void (*callback)(const {root_c}*, uintptr_t));\n"));
     out.push_str(&format!(
@@ -781,7 +817,7 @@ fn go_typed_message_spec(
     out.push_str(&format!("extern int mt_{root_safe}_service_request(uintptr_t client_handle, const {root_c}* request, uint64_t timeout_ms, {root_c}** out_response);\n"));
     out.push_str(&format!("extern void mt_register_{root_safe}_service_callback(uintptr_t handle, int (*callback)(const {root_c}* request, {root_c}* response, uintptr_t));\n"));
     out.push_str(&format!("extern uintptr_t mt_create_{root_safe}_service_server(const char* topic, uintptr_t callback_handle);\n"));
-    out.push_str(&format!("extern uintptr_t mt_create_{root_safe}_action_client(const char* topic, int feedback_qos);\n"));
+    out.push_str(&format!("extern uintptr_t mt_create_{root_safe}_action_client(const char* topic, int reliability, int durability);\n"));
     out.push_str(&format!("extern int mt_{root_safe}_action_wait_for_server(uintptr_t client_handle, uint64_t timeout_ms);\n"));
     out.push_str(&format!("extern int mt_{root_safe}_action_send_goal(uintptr_t client_handle, uint64_t goal_id, const {root_c}* goal, uint64_t timeout_ms, int* out_accepted, uint64_t* out_time_ms);\n"));
     out.push_str(&format!("extern int mt_{root_safe}_action_cancel_goal(uintptr_t client_handle, uint64_t goal_id, uint64_t timeout_ms);\n"));
@@ -866,10 +902,10 @@ fn go_typed_message_spec(
         .get(root)
         .ok_or_else(|| anyhow!("missing root type"))?;
     let root_c_type = format!("C.minot_{}", root_type.to_snake_case());
-    out.push_str(&format!("func create{root_go}Publisher(topic string, qos Qos) (uintptr, error) {{\n\tcTopic := C.CString(topic)\n\tdefer C.free(unsafe.Pointer(cTopic))\n\th := C.mt_create_{root_safe}_publisher(cTopic, C.int(qos))\n\tif h == 0 {{\n\t\treturn 0, fmt.Errorf(\"failed to create publisher for topic %s\", topic)\n\t}}\n\treturn uintptr(h), nil\n}}\n\n"));
+    out.push_str(&format!("func create{root_go}Publisher(topic string, qos Qos) (uintptr, error) {{\n\tcTopic := C.CString(topic)\n\tdefer C.free(unsafe.Pointer(cTopic))\n\th := C.mt_create_{root_safe}_publisher(cTopic, C.int(qos.Reliability), C.int(qos.Durability))\n\tif h == 0 {{\n\t\treturn 0, fmt.Errorf(\"failed to create publisher for topic %s\", topic)\n\t}}\n\treturn uintptr(h), nil\n}}\n\n"));
     out.push_str(&format!("func publish{root_go}(handle uintptr, msg {root_type}) error {{\n\tcMsg := toC{root_type}(msg)\n\tdefer freeC{root_type}(&cMsg)\n\tif C.mt_{root_safe}_publisher_publish(C.uintptr_t(handle), (*{root_c_type})(unsafe.Pointer(&cMsg))) != 0 {{\n\t\treturn fmt.Errorf(\"publish failed\")\n\t}}\n\treturn nil\n}}\n\n"));
     out.push_str(&format!("//export Go{root_go}Callback\nfunc Go{root_go}Callback(message *{root_c_type}, handle C.uintptr_t) {{\n\tif cb, ok := GetHandler(uintptr(handle)); ok {{\n\t\tif typedCb, ok := cb.(func({root_type})); ok {{\n\t\t\tif message == nil {{\n\t\t\t\tvar zero {root_type}\n\t\t\t\ttypedCb(zero)\n\t\t\t\treturn\n\t\t\t}}\n\t\t\ttypedCb(cToGo{root_type}(*message))\n\t\t}}\n\t}}\n}}\n\n"));
-    out.push_str(&format!("func create{root_go}Subscriber(topic string, queueSize int, qos Qos, callback func({root_type})) (uintptr, error) {{\n\th := RegisterHandler(callback)\n\tcTopic := C.CString(topic)\n\tdefer C.free(unsafe.Pointer(cTopic))\n\tC.registerGo{root_go}Callback(C.uintptr_t(h))\n\ts := C.mt_create_{root_safe}_subscriber(cTopic, C.uint32_t(queueSize), C.int(qos), C.uintptr_t(h))\n\tif s == 0 {{\n\t\treturn 0, fmt.Errorf(\"failed to create subscriber for topic %s\", topic)\n\t}}\n\treturn uintptr(s), nil\n}}\n\n"));
+    out.push_str(&format!("func create{root_go}Subscriber(topic string, queueSize int, qos Qos, callback func({root_type})) (uintptr, error) {{\n\th := RegisterHandler(callback)\n\tcTopic := C.CString(topic)\n\tdefer C.free(unsafe.Pointer(cTopic))\n\tC.registerGo{root_go}Callback(C.uintptr_t(h))\n\ts := C.mt_create_{root_safe}_subscriber(cTopic, C.uint32_t(queueSize), C.int(qos.Reliability), C.int(qos.Durability), C.uintptr_t(h))\n\tif s == 0 {{\n\t\treturn 0, fmt.Errorf(\"failed to create subscriber for topic %s\", topic)\n\t}}\n\treturn uintptr(s), nil\n}}\n\n"));
     out.push_str(&format!("var {root_go}Spec = MessageSpec[{root_type}]{{\n\tCreatePublisher: create{root_go}Publisher,\n\tPublish: publish{root_go},\n\tCreateSubscriber: create{root_go}Subscriber,\n}}\n\n"));
     out.push_str(&format!("func (n *Node) New{root_go}Publisher(topic string, qos Qos) (*Publisher[{root_type}], error) {{\n\treturn newPublisher(topic, qos, {root_go}Spec)\n}}\n\n"));
     out.push_str(&format!("func (n *Node) New{root_go}Subscriber(topic string, queueSize int, qos Qos, callback func({root_type})) (*Subscriber[{root_type}], error) {{\n\treturn newSubscriber(topic, queueSize, qos, {root_go}Spec, callback)\n}}\n"));
@@ -887,7 +923,7 @@ fn go_typed_message_spec(
     out.push_str(&format!(
         "type {root_go}ActionClient struct {{\n\thandle uintptr\n\ttopic  string\n}}\n\n"
     ));
-    out.push_str(&format!("func (n *Node) New{root_go}ActionClient(topic string, feedbackQos Qos) (*{root_go}ActionClient, error) {{\n\tcTopic := C.CString(topic)\n\tdefer C.free(unsafe.Pointer(cTopic))\n\th := C.mt_create_{root_safe}_action_client(cTopic, C.int(feedbackQos))\n\tif h == 0 {{\n\t\treturn nil, fmt.Errorf(\"failed to create action client for topic %s\", topic)\n\t}}\n\treturn &{root_go}ActionClient{{handle: uintptr(h), topic: topic}}, nil\n}}\n\n"));
+    out.push_str(&format!("func (n *Node) New{root_go}ActionClient(topic string, feedbackQos Qos) (*{root_go}ActionClient, error) {{\n\tcTopic := C.CString(topic)\n\tdefer C.free(unsafe.Pointer(cTopic))\n\th := C.mt_create_{root_safe}_action_client(cTopic, C.int(feedbackQos.Reliability), C.int(feedbackQos.Durability))\n\tif h == 0 {{\n\t\treturn nil, fmt.Errorf(\"failed to create action client for topic %s\", topic)\n\t}}\n\treturn &{root_go}ActionClient{{handle: uintptr(h), topic: topic}}, nil\n}}\n\n"));
     out.push_str(&format!("func (c *{root_go}ActionClient) WaitForServer(timeoutMs uint64) bool {{\n\treturn C.mt_{root_safe}_action_wait_for_server(C.uintptr_t(c.handle), C.uint64_t(timeoutMs)) != 0\n}}\n\n"));
     out.push_str(&format!("func (c *{root_go}ActionClient) SendGoal(goalID uint64, goal {root_type}, timeoutMs uint64) (bool, uint64, error) {{\n\tcGoal := toC{root_type}(goal)\n\tdefer freeC{root_type}(&cGoal)\n\tvar accepted C.int\n\tvar timeMs C.uint64_t\n\tres := C.mt_{root_safe}_action_send_goal(C.uintptr_t(c.handle), C.uint64_t(goalID), (*{root_c_type})(unsafe.Pointer(&cGoal)), C.uint64_t(timeoutMs), &accepted, &timeMs)\n\tif res != 0 {{\n\t\treturn false, 0, fmt.Errorf(\"send goal failed\")\n\t}}\n\treturn accepted != 0, uint64(timeMs), nil\n}}\n\n"));
     out.push_str(&format!("func (c *{root_go}ActionClient) CancelGoal(goalID uint64, timeoutMs uint64) error {{\n\tif C.mt_{root_safe}_action_cancel_goal(C.uintptr_t(c.handle), C.uint64_t(goalID), C.uint64_t(timeoutMs)) != 0 {{\n\t\treturn fmt.Errorf(\"cancel goal failed\")\n\t}}\n\treturn nil\n}}\n\n"));
@@ -1012,15 +1048,15 @@ fn rust_typed_message_module(
     out.push_str(&format!("#[no_mangle]\npub extern \"C\" fn mt_register_{}_callback(handle: usize, callback: extern \"C\" fn(*const {}, usize)) {{\n    {}_CALLBACKS.lock().unwrap().insert(handle, callback);\n}}\n\n", root_safe, root_c, root_safe.to_ascii_uppercase()));
     out.push_str(&format!("#[no_mangle]\npub extern \"C\" fn mt_register_{}_service_callback(handle: usize, callback: extern \"C\" fn(*const {}, *mut {}, usize) -> i32) {{\n    {}_SERVICE_CALLBACKS.lock().unwrap().insert(handle, callback);\n}}\n\n", root_safe, root_c, root_c, root_safe.to_ascii_uppercase()));
 
-    out.push_str(&format!("#[no_mangle]\npub unsafe extern \"C\" fn mt_create_{}_publisher(topic: *const c_char, qos: i32) -> usize {{\n    if topic.is_null() {{ return 0; }}\n    let Some(q) = qos_from_i32(qos) else {{ return 0; }};\n    let topic_str = match CStr::from_ptr(topic).to_str() {{ Ok(s) => s.to_owned(), Err(_) => return 0 }};\n    let node_lock = NODE.lock().unwrap();\n    let Some(node) = node_lock.as_ref().cloned() else {{ return 0; }};\n    drop(node_lock);\n    let rt_lock = RT.lock().unwrap();\n    let Some(rt) = rt_lock.as_ref().cloned() else {{ return 0; }};\n    drop(rt_lock);\n    let publisher = match rt.block_on(async {{ node.create_publisher::<{}>(topic_str, q).await }}) {{ Ok(p) => p, Err(_) => return 0 }};\n    let handle = rand::random::<usize>();\n    {}_PUBLISHERS.lock().unwrap().insert(handle, publisher);\n    handle\n}}\n\n", root_safe, root_mod_type, root_safe.to_ascii_uppercase()));
+    out.push_str(&format!("#[no_mangle]\npub unsafe extern \"C\" fn mt_create_{}_publisher(topic: *const c_char, reliability: i32, durability: i32) -> usize {{\n    if topic.is_null() {{ return 0; }}\n    let Some(q) = qos_from_i32(reliability, durability) else {{ return 0; }};\n    let topic_str = match CStr::from_ptr(topic).to_str() {{ Ok(s) => s.to_owned(), Err(_) => return 0 }};\n    let node_lock = NODE.lock().unwrap();\n    let Some(node) = node_lock.as_ref().cloned() else {{ return 0; }};\n    drop(node_lock);\n    let rt_lock = RT.lock().unwrap();\n    let Some(rt) = rt_lock.as_ref().cloned() else {{ return 0; }};\n    drop(rt_lock);\n    let publisher = match rt.block_on(async {{ node.create_publisher::<{}>(topic_str, q).await }}) {{ Ok(p) => p, Err(_) => return 0 }};\n    let handle = rand::random::<usize>();\n    {}_PUBLISHERS.lock().unwrap().insert(handle, publisher);\n    handle\n}}\n\n", root_safe, root_mod_type, root_safe.to_ascii_uppercase()));
 
     out.push_str(&format!("#[no_mangle]\npub unsafe extern \"C\" fn mt_{}_publisher_publish(publisher_handle: usize, message: *const {}) -> i32 {{\n    let rust_msg = match {}_to_rust(message) {{ Ok(m) => m, Err(_) => return -3 }};\n    let publishers = {}_PUBLISHERS.lock().unwrap();\n    let publisher = match publishers.get(&publisher_handle) {{ Some(p) => p.clone(), None => return -1 }};\n    drop(publishers);\n    let publish_fut = async move {{ publisher.publish(&rust_msg).await }};\n    let result = if tokio::runtime::Handle::try_current().is_ok() {{ tokio::task::block_in_place(|| tokio::runtime::Handle::current().block_on(publish_fut)) }} else {{ let rt_lock = RT.lock().unwrap(); let Some(rt) = rt_lock.as_ref().cloned() else {{ return -4; }}; drop(rt_lock); rt.block_on(publish_fut) }};\n    if result.is_ok() {{ 0 }} else {{ -2 }}\n}}\n\n", root_safe, root_c, root_go.to_snake_case(), root_safe.to_ascii_uppercase()));
 
-    out.push_str(&format!("#[no_mangle]\npub unsafe extern \"C\" fn mt_create_{}_subscriber(topic: *const c_char, queue_size: u32, qos: i32, callback_handle: usize) -> usize {{\n    if topic.is_null() {{ return 0; }}\n    let Some(q) = qos_from_i32(qos) else {{ return 0; }};\n    let topic_str = match CStr::from_ptr(topic).to_str() {{ Ok(s) => s.to_owned(), Err(_) => return 0 }};\n    let node_lock = NODE.lock().unwrap();\n    let Some(node) = node_lock.as_ref().cloned() else {{ return 0; }};\n    drop(node_lock);\n    let rt_lock = RT.lock().unwrap();\n    let Some(rt) = rt_lock.as_ref().cloned() else {{ return 0; }};\n    drop(rt_lock);\n    let mut subscriber = match rt.block_on(async {{ node.create_subscriber::<{}>(topic_str, queue_size as usize, q).await }}) {{ Ok(s) => s, Err(_) => return 0 }};\n    let handle = rand::random::<usize>();\n    rt.spawn(async move {{\n        while let Some(msg) = subscriber.next().await {{\n            let c_msg = {}_from_rust(&msg);\n            let cb_opt = {{ let map = {}_CALLBACKS.lock().unwrap(); map.get(&callback_handle).copied() }};\n            if let Some(cb) = cb_opt {{\n                let boxed = Box::new(c_msg);\n                cb(Box::as_ref(&boxed), callback_handle);\n                let raw = Box::into_raw(boxed);\n                mt_free_{}_message(raw);\n            }}\n        }}\n    }});\n    handle\n}}\n", root_safe, root_mod_type, root_go.to_snake_case(), root_safe.to_ascii_uppercase(), root_safe));
+    out.push_str(&format!("#[no_mangle]\npub unsafe extern \"C\" fn mt_create_{}_subscriber(topic: *const c_char, queue_size: u32, reliability: i32, durability: i32, callback_handle: usize) -> usize {{\n    if topic.is_null() {{ return 0; }}\n    let Some(q) = qos_from_i32(reliability, durability) else {{ return 0; }};\n    let topic_str = match CStr::from_ptr(topic).to_str() {{ Ok(s) => s.to_owned(), Err(_) => return 0 }};\n    let node_lock = NODE.lock().unwrap();\n    let Some(node) = node_lock.as_ref().cloned() else {{ return 0; }};\n    drop(node_lock);\n    let rt_lock = RT.lock().unwrap();\n    let Some(rt) = rt_lock.as_ref().cloned() else {{ return 0; }};\n    drop(rt_lock);\n    let mut subscriber = match rt.block_on(async {{ node.create_subscriber::<{}>(topic_str, queue_size as usize, q).await }}) {{ Ok(s) => s, Err(_) => return 0 }};\n    let handle = rand::random::<usize>();\n    rt.spawn(async move {{\n        while let Some(msg) = subscriber.next().await {{\n            let c_msg = {}_from_rust(&msg);\n            let cb_opt = {{ let map = {}_CALLBACKS.lock().unwrap(); map.get(&callback_handle).copied() }};\n            if let Some(cb) = cb_opt {{\n                let boxed = Box::new(c_msg);\n                cb(Box::as_ref(&boxed), callback_handle);\n                let raw = Box::into_raw(boxed);\n                mt_free_{}_message(raw);\n            }}\n        }}\n    }});\n    handle\n}}\n", root_safe, root_mod_type, root_go.to_snake_case(), root_safe.to_ascii_uppercase(), root_safe));
     out.push_str(&format!("#[no_mangle]\npub unsafe extern \"C\" fn mt_create_{}_service_client(topic: *const c_char) -> usize {{\n    if topic.is_null() {{ return 0; }}\n    let topic_str = match CStr::from_ptr(topic).to_str() {{ Ok(s) => s.to_owned(), Err(_) => return 0 }};\n    let node_lock = NODE.lock().unwrap();\n    let Some(node) = node_lock.as_ref().cloned() else {{ return 0; }};\n    drop(node_lock);\n    let rt_lock = RT.lock().unwrap();\n    let Some(rt) = rt_lock.as_ref().cloned() else {{ return 0; }};\n    drop(rt_lock);\n    let client = match rt.block_on(async {{ ServiceClient::<{}, {}>::new(node, topic_str).await }}) {{ Ok(c) => c, Err(_) => return 0 }};\n    let handle = rand::random::<usize>();\n    {}_SERVICE_CLIENTS.lock().unwrap().insert(handle, client);\n    handle\n}}\n\n", root_safe, root_mod_type, root_mod_type, root_safe.to_ascii_uppercase()));
     out.push_str(&format!("#[no_mangle]\npub unsafe extern \"C\" fn mt_{}_service_request(client_handle: usize, request: *const {}, timeout_ms: u64, out_response: *mut *mut {}) -> i32 {{\n    if out_response.is_null() {{ return -1; }}\n    let req = match {}_to_rust(request) {{ Ok(v) => v, Err(_) => return -2 }};\n    let clients = {}_SERVICE_CLIENTS.lock().unwrap();\n    let Some(client) = clients.get(&client_handle) else {{ return -3; }};\n    let fut = client.request(req, Some(Duration::from_millis(timeout_ms)));\n    let result = if tokio::runtime::Handle::try_current().is_ok() {{ tokio::task::block_in_place(|| tokio::runtime::Handle::current().block_on(fut)) }} else {{ let rt_lock = RT.lock().unwrap(); let Some(rt) = rt_lock.as_ref().cloned() else {{ return -4; }}; drop(rt_lock); rt.block_on(fut) }};\n    match result {{\n        Ok(resp) => {{\n            let c_resp = {}_from_rust(&resp);\n            *out_response = Box::into_raw(Box::new(c_resp));\n            0\n        }}\n        Err(_) => -5,\n    }}\n}}\n\n", root_safe, root_c, root_c, root_go.to_snake_case(), root_safe.to_ascii_uppercase(), root_go.to_snake_case()));
     out.push_str(&format!("#[no_mangle]\npub unsafe extern \"C\" fn mt_create_{}_service_server(topic: *const c_char, callback_handle: usize) -> usize {{\n    if topic.is_null() {{ return 0; }}\n    let topic_str = match CStr::from_ptr(topic).to_str() {{ Ok(s) => s.to_owned(), Err(_) => return 0 }};\n    let cb_opt = {{ let cbs = {}_SERVICE_CALLBACKS.lock().unwrap(); cbs.get(&callback_handle).copied() }};\n    let Some(cb) = cb_opt else {{ return 0; }};\n    let node_lock = NODE.lock().unwrap();\n    let Some(node) = node_lock.as_ref().cloned() else {{ return 0; }};\n    drop(node_lock);\n    let rt_lock = RT.lock().unwrap();\n    let Some(rt) = rt_lock.as_ref().cloned() else {{ return 0; }};\n    drop(rt_lock);\n    let server = match rt.block_on(async {{ ServiceServer::<{}, {}>::new(node, topic_str).await }}) {{ Ok(s) => s, Err(_) => return 0 }};\n    let server_clone = server.clone();\n    rt.spawn(async move {{\n        let callback = std::sync::Arc::new(move |req: {}| {{\n            let c_req = {}_from_rust(&req);\n            let mut c_resp: {} = unsafe {{ std::mem::zeroed() }};\n            let rc = cb(&c_req as *const {}, &mut c_resp as *mut {}, callback_handle);\n            std::future::ready(if rc != 0 {{\n                Err(\"service callback failed\".to_string())\n            }} else {{\n                match {}_to_rust(&c_resp as *const {}) {{\n                    Ok(v) => Ok(v),\n                    Err(_) => Err(\"service callback response conversion failed\".to_string()),\n                }}\n            }})\n        }});\n        let _ = ServiceServer::start(server_clone, callback).await;\n    }});\n    let handle = rand::random::<usize>();\n    {}_SERVICE_SERVERS.lock().unwrap().insert(handle, server);\n    handle\n}}\n\n", root_safe, root_safe.to_ascii_uppercase(), root_mod_type, root_mod_type, root_mod_type, root_go.to_snake_case(), root_c, root_c, root_c, root_go.to_snake_case(), root_c, root_safe.to_ascii_uppercase()));
-    out.push_str(&format!("#[no_mangle]\npub unsafe extern \"C\" fn mt_create_{}_action_client(topic: *const c_char, feedback_qos: i32) -> usize {{\n    if topic.is_null() {{ return 0; }}\n    let Some(q) = qos_from_i32(feedback_qos) else {{ return 0; }};\n    let topic_str = match CStr::from_ptr(topic).to_str() {{ Ok(s) => s.to_owned(), Err(_) => return 0 }};\n    let node_lock = NODE.lock().unwrap();\n    let Some(node) = node_lock.as_ref().cloned() else {{ return 0; }};\n    drop(node_lock);\n    let rt_lock = RT.lock().unwrap();\n    let Some(rt) = rt_lock.as_ref().cloned() else {{ return 0; }};\n    drop(rt_lock);\n    let client = match rt.block_on(async {{ ActionClient::<{}, {}, {}>::new(node, topic_str, q).await }}) {{ Ok(c) => c, Err(_) => return 0 }};\n    let handle = rand::random::<usize>();\n    {}_ACTION_CLIENTS.lock().unwrap().insert(handle, client);\n    handle\n}}\n\n", root_safe, root_mod_type, root_mod_type, root_mod_type, root_safe.to_ascii_uppercase()));
+    out.push_str(&format!("#[no_mangle]\npub unsafe extern \"C\" fn mt_create_{}_action_client(topic: *const c_char, reliability: i32, durability: i32) -> usize {{\n    if topic.is_null() {{ return 0; }}\n    let Some(q) = qos_from_i32(reliability, durability) else {{ return 0; }};\n    let topic_str = match CStr::from_ptr(topic).to_str() {{ Ok(s) => s.to_owned(), Err(_) => return 0 }};\n    let node_lock = NODE.lock().unwrap();\n    let Some(node) = node_lock.as_ref().cloned() else {{ return 0; }};\n    drop(node_lock);\n    let rt_lock = RT.lock().unwrap();\n    let Some(rt) = rt_lock.as_ref().cloned() else {{ return 0; }};\n    drop(rt_lock);\n    let client = match rt.block_on(async {{ ActionClient::<{}, {}, {}>::new(node, topic_str, q).await }}) {{ Ok(c) => c, Err(_) => return 0 }};\n    let handle = rand::random::<usize>();\n    {}_ACTION_CLIENTS.lock().unwrap().insert(handle, client);\n    handle\n}}\n\n", root_safe, root_mod_type, root_mod_type, root_mod_type, root_safe.to_ascii_uppercase()));
     out.push_str(&format!("#[no_mangle]\npub unsafe extern \"C\" fn mt_{}_action_wait_for_server(client_handle: usize, timeout_ms: u64) -> i32 {{\n    let clients = {}_ACTION_CLIENTS.lock().unwrap();\n    let Some(client) = clients.get(&client_handle) else {{ return 0; }};\n    let fut = ActionClient::<{}, {}, {}>::wait_for_action_server(client.clone(), Duration::from_millis(timeout_ms));\n    let ready = if tokio::runtime::Handle::try_current().is_ok() {{ tokio::task::block_in_place(|| tokio::runtime::Handle::current().block_on(fut)) }} else {{ let rt_lock = RT.lock().unwrap(); let Some(rt) = rt_lock.as_ref().cloned() else {{ return 0; }}; drop(rt_lock); rt.block_on(fut) }};\n    if ready {{ 1 }} else {{ 0 }}\n}}\n\n", root_safe, root_safe.to_ascii_uppercase(), root_mod_type, root_mod_type, root_mod_type));
     out.push_str(&format!("#[no_mangle]\npub unsafe extern \"C\" fn mt_{}_action_send_goal(client_handle: usize, goal_id: u64, goal: *const {}, timeout_ms: u64, out_accepted: *mut i32, out_time_ms: *mut u64) -> i32 {{\n    if out_accepted.is_null() || out_time_ms.is_null() {{ return -1; }}\n    let goal_msg = match {}_to_rust(goal) {{ Ok(v) => v, Err(_) => return -2 }};\n    let clients = {}_ACTION_CLIENTS.lock().unwrap();\n    let Some(client) = clients.get(&client_handle) else {{ return -3; }};\n    let req = ActionSendGoalRequest {{ id: goal_id, goal: goal_msg }};\n    let fut = ActionClient::<{}, {}, {}>::send_goal(client.clone(), req, Some(Duration::from_millis(timeout_ms)));\n    let result = if tokio::runtime::Handle::try_current().is_ok() {{ tokio::task::block_in_place(|| tokio::runtime::Handle::current().block_on(fut)) }} else {{ let rt_lock = RT.lock().unwrap(); let Some(rt) = rt_lock.as_ref().cloned() else {{ return -4; }}; drop(rt_lock); rt.block_on(fut) }};\n    match result {{\n        Ok(resp) => {{\n            *out_accepted = if resp.accepted {{ 1 }} else {{ 0 }};\n            *out_time_ms = resp.time.unwrap_or(0) as u64;\n            0\n        }}\n        Err(_) => -5,\n    }}\n}}\n\n", root_safe, root_c, root_go.to_snake_case(), root_safe.to_ascii_uppercase(), root_mod_type, root_mod_type, root_mod_type));
     out.push_str(&format!("#[no_mangle]\npub unsafe extern \"C\" fn mt_{}_action_cancel_goal(client_handle: usize, goal_id: u64, timeout_ms: u64) -> i32 {{\n    let clients = {}_ACTION_CLIENTS.lock().unwrap();\n    let Some(client) = clients.get(&client_handle) else {{ return -1; }};\n    let req = ActionCancelGoalRequest {{ id: Some(goal_id), time: None }};\n    let fut = ActionClient::<{}, {}, {}>::cancel_goal(client.clone(), req, Some(Duration::from_millis(timeout_ms)));\n    let result = if tokio::runtime::Handle::try_current().is_ok() {{ tokio::task::block_in_place(|| tokio::runtime::Handle::current().block_on(fut)) }} else {{ let rt_lock = RT.lock().unwrap(); let Some(rt) = rt_lock.as_ref().cloned() else {{ return -2; }}; drop(rt_lock); rt.block_on(fut) }};\n    if result.is_ok() {{ 0 }} else {{ -3 }}\n}}\n\n", root_safe, root_safe.to_ascii_uppercase(), root_mod_type, root_mod_type, root_mod_type));
@@ -2421,6 +2457,20 @@ fn c_and_go_scalar(ty: &Type) -> Result<(&'static str, &'static str)> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn go_qos_combines_reliability_and_durability() {
+        let go = go_core_file();
+        assert!(go.contains("type Reliability int"));
+        assert!(go.contains("type Durability int"));
+        assert!(go.contains("type Qos struct"));
+        assert!(go.contains("func (q Qos) TransientLocal() Qos"));
+
+        let ffi = ffi_lib_rs();
+        assert!(ffi.contains("1 => Reliability::TryReliable"));
+        assert!(ffi.contains("1 => Durability::TransientLocal"));
+        assert!(ffi.contains("Some(Qos::new(reliability, durability))"));
+    }
+
     #[test]
     fn test_parse_and_generate_simple_struct() {
         let input = "

{minot_cli-0.10.2 → minot_cli-0.11.1}/mt_bagread/src/lib.rs

@@ -139,6 +139,9 @@ where
         where
             E: de::Error,
         {
+            if value.trim().is_empty() {
+                return Ok(Vec::new());
+            }
             serde_yml::from_str(value).map_err(de::Error::custom)
         }
 
@@ -1629,6 +1632,21 @@ rosbag2_bagfile_information:
         );
     }
 
+    #[test]
+    fn empty_qos_profile_string_is_an_empty_list() {
+        let metadata: TopicMetadata = serde_yml::from_str(
+            r#"
+name: /ouster/points
+type: sensor_msgs/msg/PointCloud2
+serialization_format: cdr
+offered_qos_profiles: ""
+"#,
+        )
+        .expect("empty QoS profile string should parse");
+
+        assert!(metadata.offered_qos_profiles.is_empty());
+    }
+
     #[test]
     fn both_formats_parse_without_errors() {
         let v5_result = std::fs::read_to_string("test/metadata-v5.yml").and_then(|contents| {

{minot_cli-0.10.2 → minot_cli-0.11.1}/mt_coord/src/lib.rs

@@ -5,7 +5,7 @@ use mt_sea::net::{self, Packet};
 use mt_sea::{coordinator::CoordinatorImpl, net::PacketKind};
 
 use mt_net::{ActionPlan, COMPARE_NODE_NAME, RatPubRegisterKind, Rules, VariableHuman};
-use mt_sea::{Coordinator, Qos, ShipKind, WindData};
+use mt_sea::{Coordinator, Qos, Reliability, ShipKind, WindData};
 
 const EMBEDDED_COORDINATOR_READY_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(5);
 
@@ -1095,7 +1095,9 @@ fn run_coordinator_with_ready(
                     node_mode,
                 } => {
                     // Track BE publishers
-                    if kind == net::RatPubRegisterKind::Publish && node_mode == Qos::BestEffort {
+                    if kind == net::RatPubRegisterKind::Publish
+                        && node_mode.reliability_mode() == Reliability::BestEffort
+                    {
                         coordinator
                             .be_publisher_vars
                             .write()

{minot_cli-0.10.2 → minot_cli-0.11.1}/mt_pubsub/README.md

@@ -48,15 +48,15 @@ If you have multiple Minot networks on the same physical network, use the `MINOT
 
 ## Delivery modes
 
-`Qos` sets a node's delivery mode. It encodes two independent things, and it is worth
-keeping them apart: how Zenoh carries the bytes, and what the rest of the system does
-when the node stops answering.
+`Qos` combines `Reliability` and `Durability`. Reliability also controls failure
+handling and congestion behavior.
 
-| | Wire | Congestion | Peer monitoring | On loss | Send dispatch |
-|---|---|---|---|---|---|
-| `Reliable` | reliable | `Block` | yes | torpedoes the run | inline, unbounded retry |
-| `TryReliable` | reliable | `BlockFirst` | no | rest keeps running | spawned, retry within budget |
-| `BestEffort` | best-effort | `Drop` | no | rest keeps running | spawned, single attempt |
+| | Wire | Congestion | Peer monitoring | On loss | Send dispatch | Durability |
+|---|---|---|---|---|---|---|
+| `Reliable` | reliable | `Block` | yes | torpedoes the run | inline, unbounded retry | volatile |
+| `TryReliable` | reliable | `BlockFirst` | no | rest keeps running | spawned, retry within budget | volatile |
+| `BestEffort` | best-effort | `Drop` | no | rest keeps running | spawned, single attempt | volatile |
+| `.transient_local()` | preserves base mode | preserves base mode | preserves base mode | preserves base mode | preserves base mode | replay latest sample to late subscribers |
 
 `Reliable` is the default and the strict one: peers heartbeat-monitor each other, and a
 node that stops answering tears the whole run down. That is what you want for a
@@ -70,6 +70,15 @@ publisher's loop.
 
 `BestEffort` tries once and moves on.
 
+Transient-local durability combines with every reliability mode. It retains the latest
+sample and replays it to late subscribers. It is disabled by default.
+
+```rust
+let publisher = node
+    .create_publisher::<Transform>("/tf_static".to_owned(), Qos::Reliable.transient_local())
+    .await?;
+```
+
 Note that reliable wire delivery is close to free over TCP, which already retransmits and
 orders. The meaningful difference between `Reliable` and `TryReliable` is the failure
 policy, not the wire.

{minot_cli-0.10.2 → minot_cli-0.11.1}/mt_pubsub/src/lib.rs

@@ -5,7 +5,9 @@ use std::{marker::PhantomData, sync::Arc};
 use mt_sea::{net::Packet, ship::NetworkShipImpl, *};
 use tokio_util::sync::CancellationToken;
 
-pub use mt_sea::{ArchivedMessage, NodeOptions, Qos, ReconnectPolicy, Timing};
+pub use mt_sea::{
+    ArchivedMessage, Durability, NodeOptions, Qos, ReconnectPolicy, Reliability, Timing,
+};
 
 #[derive(Debug, Clone, Copy, Default)]
 pub enum CoordMode {
@@ -217,6 +219,12 @@ impl<T: Sendable> Publisher<T> {
     }
 
     pub async fn publish(&self, data: &T) -> anyhow::Result<()> {
+        if self.qos.is_transient_local() {
+            self.ship
+                .get_cannon()
+                .retain(data, VariableType::StaticOnly, &self.topic)
+                .await?;
+        }
         self.ensure_registered().await?;
         match self.ship.ask_for_action(&self.topic).await {
             Ok((mt_sea::Action::Sail, _)) => {