refactor(data-plane): replace encoder::Name with ProtoName throughout (agntcy#1596)

## Description

Removes the `encoder::Name` struct entirely and replaces it with
`ProtoName` (the prost-generated protobuf message type) across all
crates in the data plane.

`encoder::Name` was a conversion shim between human-readable string
components and the 4×u64 XxHash64-encoded wire representation
(`EncodedName`). Every message already carried a `ProtoName` directly in
its `SlimHeader`, making `Name` a pure overhead layer: code would
convert `ProtoName → Name` to get ergonomic helpers (`from_strings`,
`with_id`, etc.), then immediately convert `Name → ProtoName` before
sending.

### What changed

**`ProtoName` gains constructor/utility methods** (added to `api.rs`):
- `from_strings([s0, s1, s2])` — hashes components via XxHash64 and
stores both the encoded and string forms
- `with_id(u64)`, `id()`, `has_id()`, `set_id()`, `reset_id()` — manage
the 4th component (instance ID)
- `match_prefix()` — compare first 3 components, ignoring ID (used for
subscription prefix matching)
- `str_components() -> (&str, &str, &str)` — access human-readable
components
- `NULL_COMPONENT` / `is_reserved_id()` — sentinel value for unset IDs

**Routing hot path** — `ProtoName → EncodedName` is now a direct field
access (`name.name.unwrap()`), with no intermediate `Name` allocation.
All routing table keys are `EncodedName` (a `Copy` + `Hash` + `Eq` 4×u64
struct).

**Collection types** — `HashMap<Name, _>` / `HashSet<Name>` across
session, service, and controller crates are replaced with
`HashMap<EncodedName, _>` / `HashSet<EncodedName>` for hot-path
collections, and `HashMap<ProtoName, _>` where the full name is needed
as a value.

**`SlimHeader` constructor** — the `new_from_protos(ProtoName,
ProtoName, ...)` / `new(&ProtoName, &ProtoName, ...)` split is collapsed
into a single `new(ProtoName, ProtoName, ...)` that owns its arguments
directly.

**Bindings** — the `Name` UniFFI wrapper in `bindings/rust/src/name.rs`
now holds a `ProtoName` directly rather than converting to/from
`encoder::Name`.

**`encoder.rs`** — the `Name` struct, all its `From` impls, and the
re-exports in `messages/mod.rs` are removed. The file retains only
`calculate_hash` (used internally by `ProtoName::from_strings`).

### Scope

68 files changed across `datapath`, `session`, `service`, `controller`,
`bindings/rust`, `slimctl`, `testing`, and `examples`.

## Type of Change

- [ ] Bugfix
- [x] New Feature
- [ ] Breaking Change
- [x] Refactor
- [ ] Documentation
- [ ] Other (please describe)

## Checklist

- [x] I have read the [contributing
guidelines](/agntcy/repo-template/blob/main/CONTRIBUTING.md)
- [ ] Existing issues have been referenced (where applicable)
- [x] I have verified this change is not present in other open pull
requests
- [ ] Functionality is documented
- [x] All code style checks pass
- [x] New code contribution is covered by automated tests
- [x] All new and existing tests pass

---------

Signed-off-by: Sam Betts <1769706+Tehsmash@users.noreply.github.com>

Author: Tehsmash

data-plane/bindings/rust/src/app.rs

@@ -27,7 +27,7 @@ use slim_auth::auth_provider::{AuthProvider, AuthVerifier};
 use crate::identity_config::{IdentityProviderConfig, IdentityVerifierConfig};
 
 use futures_timer::Delay;
-use slim_datapath::messages::Name as SlimName;
+use slim_datapath::api::ProtoName as SlimName;
 use slim_service::Service as SlimService;
 use slim_service::app::App as SlimApp;
 use slim_session::Direction as CoreDirection;
@@ -678,7 +678,7 @@ mod tests {
     use super::*;
 
     use slim_config::component::ComponentBuilder;
-    use slim_datapath::messages::Name as SlimName;
+    use slim_datapath::api::ProtoName as SlimName;
     use slim_testing::utils::TEST_VALID_SECRET;
 
     // Helper to create test identity configs

data-plane/bindings/rust/src/message_context.rs

@@ -4,8 +4,8 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 
+use slim_datapath::api::ProtoName as SlimName;
 use slim_datapath::api::{ProtoMessage, ProtoPublishType};
-use slim_datapath::messages::Name as SlimName;
 
 use slim_session::SessionError;
 
@@ -150,8 +150,8 @@ mod tests {
         let content = ApplicationPayload::new(&content_type, payload).as_content();
 
         let mut slim_header = SlimHeader::default();
-        slim_header.set_source(&source);
-        slim_header.set_destination(&dest);
+        slim_header.set_source(source);
+        slim_header.set_destination(dest);
 
         let publish = ProtoPublish {
             header: Some(slim_header),
@@ -272,8 +272,8 @@ mod tests {
 
         // Create ProtoPublish without msg content
         let mut slim_header = SlimHeader::default();
-        slim_header.set_source(&source_slim);
-        slim_header.set_destination(&dest_slim);
+        slim_header.set_source(source_slim);
+        slim_header.set_destination(dest_slim);
 
         let publish = ProtoPublish {
             header: Some(slim_header),

data-plane/bindings/rust/src/name.rs

@@ -3,37 +3,37 @@
 
 use std::fmt::Display;
 
-use slim_datapath::messages::Name as SlimName;
+use slim_datapath::api::ProtoName;
 
 use crate::errors::SlimError;
 
 /// Name type for SLIM (Secure Low-Latency Interactive Messaging)
 #[derive(Debug, Clone, PartialEq, uniffi::Object)]
 #[uniffi::export(Display, Debug, Eq)]
 pub struct Name {
-    inner: SlimName,
+    inner: ProtoName,
 }
 
-impl From<Name> for SlimName {
+impl From<Name> for ProtoName {
     fn from(name: Name) -> Self {
         name.inner.clone()
     }
 }
 
-impl From<&Name> for SlimName {
+impl From<&Name> for ProtoName {
     fn from(name: &Name) -> Self {
         name.inner.clone()
     }
 }
 
-impl From<SlimName> for Name {
-    fn from(name: SlimName) -> Self {
+impl From<ProtoName> for Name {
+    fn from(name: ProtoName) -> Self {
         Name { inner: name }
     }
 }
 
-impl From<&SlimName> for Name {
-    fn from(name: &SlimName) -> Self {
+impl From<&ProtoName> for Name {
+    fn from(name: &ProtoName) -> Self {
         Name {
             inner: name.clone(),
         }
@@ -42,7 +42,8 @@ impl From<&SlimName> for Name {
 
 impl Display for Name {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.inner)
+        let (c0, c1, c2) = self.inner.str_components();
+        write!(f, "{}/{}/{}", c0, c1, c2)
     }
 }
 
@@ -51,7 +52,7 @@ impl Name {
     /// Create a new Name from components without an ID
     #[uniffi::constructor]
     pub fn new(component0: String, component1: String, component2: String) -> Self {
-        let inner = SlimName::from_strings([component0, component1, component2]);
+        let inner = ProtoName::from_strings([component0, component1, component2]);
         Name { inner }
     }
 
@@ -74,7 +75,7 @@ impl Name {
             });
         }
         Ok(Name {
-            inner: SlimName::from_strings([parts[0], parts[1], parts[2]]),
+            inner: ProtoName::from_strings([parts[0], parts[1], parts[2]]),
         })
     }
 
@@ -86,16 +87,17 @@ impl Name {
         component2: String,
         id: u64,
     ) -> Self {
-        if SlimName::is_reserved_id(id) {
+        if ProtoName::is_reserved_id(id) {
             panic!("id {id:#x} is a reserved sentinel value and cannot be used as a name id");
         }
-        let inner = SlimName::from_strings([component0, component1, component2]).with_id(id);
+        let inner = ProtoName::from_strings([component0, component1, component2]).with_id(id);
         Name { inner }
     }
 
     /// Get the name components as a vector of strings
     pub fn components(&self) -> Vec<String> {
-        self.inner.components_strings().to_vec()
+        let (c0, c1, c2) = self.inner.str_components();
+        vec![c0.to_string(), c1.to_string(), c2.to_string()]
     }
 
     /// Get the name ID
@@ -105,21 +107,14 @@ impl Name {
 }
 
 impl Name {
-    /// Get the name components as a reference (for internal Rust use only, not exposed to FFI)
-    ///
-    /// This avoids copying when used internally in Rust code.
-    pub fn components_ref(&self) -> &[String; 3] {
-        self.inner.components_strings()
-    }
-
-    /// Convert to SlimName (for internal Rust use only, not exposed to FFI)
-    pub fn as_slim_name(&self) -> SlimName {
+    /// Get the inner ProtoName (for internal Rust use only)
+    pub fn as_slim_name(&self) -> ProtoName {
         self.inner.clone()
     }
 
-    /// Create from SlimName (for internal Rust use only, not exposed to FFI)
-    pub fn from_slim_name(slim_name: SlimName) -> Self {
-        Name { inner: slim_name }
+    /// Create from ProtoName (for internal Rust use only)
+    pub fn from_slim_name(proto_name: ProtoName) -> Self {
+        Name { inner: proto_name }
     }
 }
 
@@ -131,7 +126,7 @@ mod tests {
     // Name Conversion Tests
     // ========================================================================
 
-    /// Test Name to SlimName conversion with full components
+    /// Test Name to ProtoName conversion with full components
     #[test]
     fn test_name_to_slim_name_full() {
         let name = Name::new_with_id(
@@ -141,47 +136,47 @@ mod tests {
             12345,
         );
 
-        let slim_name: SlimName = name.into();
-        let components = slim_name.components_strings();
+        let proto_name: ProtoName = name.into();
+        let (c0, c1, c2) = proto_name.str_components();
 
-        assert_eq!(components[0], "org");
-        assert_eq!(components[1], "namespace");
-        assert_eq!(components[2], "app");
-        assert_eq!(slim_name.id(), 12345);
+        assert_eq!(c0, "org");
+        assert_eq!(c1, "namespace");
+        assert_eq!(c2, "app");
+        assert_eq!(proto_name.id(), 12345);
     }
 
-    /// Test Name to SlimName conversion with partial components
+    /// Test Name to ProtoName conversion with partial components
     #[test]
     fn test_name_to_slim_name_partial() {
         let name = Name::new("org".to_string(), "".to_string(), "".to_string());
 
-        let slim_name: SlimName = name.into();
-        let components = slim_name.components_strings();
+        let proto_name: ProtoName = name.into();
+        let (c0, c1, c2) = proto_name.str_components();
 
-        assert_eq!(components[0], "org");
-        assert_eq!(components[1], "");
-        assert_eq!(components[2], "");
+        assert_eq!(c0, "org");
+        assert_eq!(c1, "");
+        assert_eq!(c2, "");
     }
 
-    /// Test Name to SlimName conversion with empty components
+    /// Test Name to ProtoName conversion with empty components
     #[test]
     fn test_name_to_slim_name_empty() {
         let name = Name::new("".to_string(), "".to_string(), "".to_string());
 
-        let slim_name: SlimName = name.into();
-        let components = slim_name.components_strings();
+        let proto_name: ProtoName = name.into();
+        let (c0, c1, c2) = proto_name.str_components();
 
-        assert_eq!(components[0], "");
-        assert_eq!(components[1], "");
-        assert_eq!(components[2], "");
+        assert_eq!(c0, "");
+        assert_eq!(c1, "");
+        assert_eq!(c2, "");
     }
 
-    /// Test SlimName to Name conversion
+    /// Test ProtoName to Name conversion
     #[test]
     fn test_slim_name_to_name() {
-        let slim_name = SlimName::from_strings(["org", "namespace", "app"]).with_id(54321);
+        let proto_name = ProtoName::from_strings(["org", "namespace", "app"]).with_id(54321);
 
-        let name = Name::from(&slim_name);
+        let name = Name::from(&proto_name);
 
         assert_eq!(name.components(), vec!["org", "namespace", "app"]);
         assert_eq!(name.id(), 54321);
@@ -197,8 +192,8 @@ mod tests {
             99999,
         );
 
-        let slim_name: SlimName = original.clone().into();
-        let converted = Name::from(&slim_name);
+        let proto_name: ProtoName = original.clone().into();
+        let converted = Name::from(&proto_name);
 
         assert_eq!(original.components(), converted.components());
         assert_eq!(original.id(), converted.id());
@@ -238,7 +233,7 @@ mod tests {
         );
         let display_str = format!("{}", name);
 
-        // Should display the SlimName format
+        // Should display the ProtoName format
         assert!(!display_str.is_empty());
     }
 
@@ -250,8 +245,8 @@ mod tests {
         assert_eq!(name_with_id.id(), 42);
 
         let name_without_id = Name::new("org".to_string(), "ns".to_string(), "app".to_string());
-        // SlimName generates a default ID, so it should be non-zero
-        assert!(name_without_id.id() > 0);
+        // ProtoName without with_id sets component_3 to NULL_COMPONENT
+        assert_eq!(name_without_id.id(), ProtoName::NULL_COMPONENT);
     }
 
     /// Test Name::from_string with a valid input

data-plane/bindings/rust/src/service.rs

@@ -19,7 +19,7 @@ use slim_config::component::id::{ID, Kind};
 use slim_config::grpc::client::ClientConfig as CoreClientConfig;
 use slim_config::grpc::server::ServerConfig as CoreServerConfig;
 use slim_controller::config::Config as CoreControllerConfig;
-use slim_datapath::messages::Name as SlimName;
+use slim_datapath::api::ProtoName as SlimName;
 use slim_service::{
     KIND, Service as SlimService, ServiceConfiguration as SlimServiceConfiguration,
 };
@@ -515,7 +515,7 @@ pub fn create_service_with_config(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use slim_datapath::messages::Name as SlimName;
+    use slim_datapath::api::ProtoName as SlimName;
     use slim_testing::utils::TEST_VALID_SECRET;
 
     use crate::app::App;

data-plane/bindings/rust/src/session.rs

@@ -8,8 +8,8 @@ use std::sync::Arc;
 use tokio::sync::RwLock;
 
 use futures_timer::Delay;
+use slim_datapath::api::ProtoName as SlimName;
 use slim_datapath::api::ProtoSessionType;
-use slim_datapath::messages::Name as SlimName;
 use slim_datapath::messages::utils::{PUBLISH_TO, SlimHeaderFlags, TRUE_VAL};
 use slim_session::SessionConfig as SlimSessionConfig;
 use slim_session::SessionError;
@@ -735,8 +735,8 @@ mod tests {
         let content = ApplicationPayload::new(content_type, payload).as_content();
 
         let mut slim_header = SlimHeader::default();
-        slim_header.set_source(&source);
-        slim_header.set_destination(&dest);
+        slim_header.set_source(source);
+        slim_header.set_destination(dest);
 
         let publish = ProtoPublish {
             header: Some(slim_header),
@@ -1346,10 +1346,10 @@ mod tests {
         );
 
         let slim_name = message_ctx.source_as_slim_name();
-        let components = slim_name.components_strings();
-        assert_eq!(components[0], "org");
-        assert_eq!(components[1], "namespace");
-        assert_eq!(components[2], "app");
+        let (c0, c1, c2) = slim_name.str_components();
+        assert_eq!(c0, "org");
+        assert_eq!(c1, "namespace");
+        assert_eq!(c2, "app");
     }
 
     // ==================== Empty/Edge Case Tests ====================

data-plane/bindings/rust/src/slimrpc.rs

@@ -22,7 +22,7 @@
 //! This crate works directly with core SLIM types:
 //! - `slim_service::app::App` - The SLIM application instance
 //! - `slim_session::context::SessionContext` - Session context for RPC calls
-//! - `slim_datapath::messages::Name` - SLIM names for service addressing
+//! - `slim_datapath::api::ProtoName` - SLIM names for service addressing
 //!
 //! ## Client Example
 //!
@@ -92,7 +92,7 @@
 //! # }
 //! ```
 
-use slim_datapath::messages::Name;
+use slim_datapath::api::ProtoName as Name;
 
 /// Build a method-specific subscription name (base-service-method)
 ///
@@ -111,22 +111,12 @@ pub fn build_method_subscription_name(
     service_name: &str,
     method_name: &str,
 ) -> Name {
-    let components_strings = base_name.components_strings();
-    if components_strings.len() < 3 {
-        panic!("Base name must have at least 3 components");
-    }
+    let (c0, c1, c2) = base_name.str_components();
 
     // Create subscription name: org/namespace/app-service-method
-    let app_with_method = format!(
-        "{}-{}-{}",
-        &components_strings[2], service_name, method_name
-    );
+    let app_with_method = format!("{}-{}-{}", c2, service_name, method_name);
 
-    Name::from_strings([
-        components_strings[0].clone(),
-        components_strings[1].clone(),
-        app_with_method,
-    ])
+    Name::from_strings([c0, c1, &app_with_method])
 }
 
 mod channel;