diff --git a/Tether4.md b/Tether4.md
index 490d518..b7ef075 100644
--- a/Tether4.md
+++ b/Tether4.md
@@ -12,10 +12,10 @@ For Output Plugs (publishing) NOW CHANNEL SENDERS, the topic will be constructed
 - agentRole/chanelName/optionalID
 
 For Input Plugs (subscribing) NOW CHANNEL RECEIVERS, the topic will be constructed as follows:
-- agentRole/chanelName/# (matches "no ID" part and "ID part included")
+- agentRole/chanelName/# (matches "no ID" part and "ID part(s) included")
 - agentRole/chanelName/optionalID (will only match when ID part is matched)
 
-The main practical difference between a "topic" and a "Channel" (previously "plug") is simply that a Channel is expected to match ONLY ONE TYPE OF MESSAGE. So, a single MQTT Client may have multiple subscriptions, but we ensure that the correct messages are matched with the correct Channel when received, by applying our additional Tether Complaint Topic (TCT) matching pattern.
+The main practical difference between a "topic" and a "Channel" (previously "plug") is simply that a Channel is expected to match ONLY ONE TYPE OF MESSAGE. So, a single MQTT Client may have multiple subscriptions, but we ensure that the correct messages are matched with the correct Channel when received, by applying our additional Tether Complaint Topic (TCT) matching pattern. The libraries (particularly typed languages such as TypeScript and Rust) should try to encourage (if not enforce) this practice.
 
 ## Cleaning up
 Unused "utilities" and the "explorer" will be removed.
@@ -49,3 +49,18 @@ Apart from the terminology changes, the following are important to note:
 ## Rust changes
 Apart from the terminology changes, the following are important to note:
 - `agent.send` used to assume an already-encoded payload, while `.encode_and_send` did auto-encoding. Now, `.send` is the auto-encoding version and additional `.send_raw` and `.send_empty` functions are provided. It is VERY important that the new `.send` will actually (incorrectly!) accept already-encoded payloads, because `&[u8]` is ALSO `T: Serialize`! So applications using the new version must be carefully checked to ensure that things are not (double) encoded before sending!
+
+The term "OptionsBuilder" suffix has now been replaced with the much simpler "Builder", so we have simply:
+- TetherAgentBuilder
+- ChannelSenderBuilder
+- ChannelReceiverBuilder
+
+Even better, the ChannelSenderBuilder/ChannelReceiver builder do not **have** to be used in all cases, since both ChannelSender and ChannelReceiver objects can be constructed via the Tether Agent object itself, i.e.
+
+- `tether_agent::create_sender`
+- `tether_agent::create_receiver`
+
+All that needs to be provided, in the default cases, is the name and the type. For example:
+- `tether_agent.create_sender::<u8>("numbersOnly")` creates a ChannelSender called "numbersOnly" which will automatically expect (require) u8 payloads
+
+The TypeScript library is now set up to mirror this as well (also, optional!). It means having to pass fewer arguments.
diff --git a/examples/nodejs-ts/src/index.ts b/examples/nodejs-ts/src/index.ts
index a83d726..df57021 100644
--- a/examples/nodejs-ts/src/index.ts
+++ b/examples/nodejs-ts/src/index.ts
@@ -17,15 +17,18 @@ logger.debug("Debug logging enabled; output could be verbose!");
 const main = async () => {
   const agent = await TetherAgent.create("brain");
 
-  const sender = new ChannelSender(agent, "randomValues");
+  // Note the alternative syntax for doing the same thing, below:
+  // ...
+  // const sender = new ChannelSender(agent, "randomValues");
+  const sender = agent.createSender("randomValues");
+
   sender.send({
     value: Math.random(),
     timestamp: Date.now(),
     something: "one",
   });
 
-  const genericReceiver = await ChannelReceiver.create(
-    agent,
+  const genericReceiver = await agent.createReceiver(
     "randomValuesStrictlyTyped"
   );
   genericReceiver.on("message", (payload, topic) => {
@@ -38,18 +41,14 @@ const main = async () => {
     );
   });
 
-  const typedReceiver = await ChannelReceiver.create<number>(
-    agent,
+  const typedReceiver = await agent.createReceiver<number>(
     "randomValuesStrictlyTyped"
   );
   typedReceiver.on("message", (payload) => {
     logger.info("Our typed receiver got", payload, typeof payload);
   });
 
-  const typedSender = new ChannelSender<number>(
-    agent,
-    "randomValuesStrictlyTyped"
-  );
+  const typedSender = agent.createSender<number>("randomValuesStrictlyTyped");
   // This will be rejected by TypeScript compiler:
   // typedSender.send({
   //   value: Math.random(),
diff --git a/examples/react-ts/src/Tether/Receiver.tsx b/examples/react-ts/src/Tether/Receiver.tsx
index 3694702..67f0d86 100644
--- a/examples/react-ts/src/Tether/Receiver.tsx
+++ b/examples/react-ts/src/Tether/Receiver.tsx
@@ -6,13 +6,15 @@ interface Props {
 }
 
 export const Receiver = (props: Props) => {
+  const { agent } = props;
   const [channel, setChannel] = useState<ChannelReceiver<unknown> | null>(null);
   const [lastMessage, setLastMessage] = useState("");
 
   useEffect(() => {
-    ChannelReceiver.create(props.agent, "everything", {
-      overrideTopic: "#",
-    })
+    agent
+      .createReceiver("everything", {
+        overrideTopic: "#",
+      })
       .then((channel) => {
         setChannel(channel);
         channel.on("message", (payload, topic) => {
@@ -24,7 +26,7 @@ export const Receiver = (props: Props) => {
       .catch((e) => {
         console.error("Error creating Channel Receiver:", e);
       });
-  }, [props.agent]);
+  }, [agent]);
 
   return (
     <div>
diff --git a/examples/react-ts/src/Tether/Sender.tsx b/examples/react-ts/src/Tether/Sender.tsx
index 2f21e96..c3370c8 100644
--- a/examples/react-ts/src/Tether/Sender.tsx
+++ b/examples/react-ts/src/Tether/Sender.tsx
@@ -6,10 +6,12 @@ interface Props {
 }
 
 export const Sender = (props: Props) => {
+  const { agent } = props;
+
   useEffect(() => {
     console.log("Sender useEffect");
-    setChannel(new ChannelSender(props.agent, "sender"));
-  }, [props.agent]);
+    setChannel(new ChannelSender(agent, "sender"));
+  }, [agent]);
 
   const [useCustomTopic, setUseCustomTopic] = useState(false);
   const [customTopic, setTCustomTopic] = useState("");
@@ -32,7 +34,7 @@ export const Sender = (props: Props) => {
             <button
               onClick={() =>
                 setChannel(
-                  new ChannelSender(props.agent, "sender", {
+                  agent.createSender("sender", {
                     overrideTopic: customTopic,
                   })
                 )
@@ -43,7 +45,7 @@ export const Sender = (props: Props) => {
             <button
               onClick={() => {
                 setUseCustomTopic(false);
-                setChannel(new ChannelSender(props.agent, "sender"));
+                setChannel(agent.createSender("sender"));
               }}
             >
               Back to default
@@ -65,9 +67,9 @@ export const Sender = (props: Props) => {
                 await channel.send();
               } catch (e) {
                 console.error("We got an error when trying to publish:", e);
-                console.log("agent connected?", props.agent.getIsConnected());
-                console.log("agent state?", props.agent.getState());
-                console.log("agent client?", props.agent.getClient());
+                console.log("agent connected?", agent.getIsConnected());
+                console.log("agent state?", agent.getState());
+                console.log("agent client?", agent.getClient());
               }
             }}
           >
diff --git a/examples/rust/custom_options.rs b/examples/rust/custom_options.rs
index fe2f54a..8362d27 100644
--- a/examples/rust/custom_options.rs
+++ b/examples/rust/custom_options.rs
@@ -1,11 +1,9 @@
 use std::time::Duration;
 
-use tether_agent::{
-    ChannelDefinition, ChannelDefinitionCommon, ChannelOptionsBuilder, TetherAgentOptionsBuilder,
-};
+use tether_agent::{definitions::*, TetherAgentBuilder};
 
 fn main() {
-    let mut tether_agent = TetherAgentOptionsBuilder::new("example")
+    let tether_agent = TetherAgentBuilder::new("example")
         .id(None)
         .host(Some("localhost"))
         .port(Some(1883))
@@ -14,41 +12,44 @@ fn main() {
         .build()
         .expect("failed to create Tether Agent");
 
-    let sender_channel = ChannelOptionsBuilder::create_sender("anOutput")
+    let sender_channel_def = ChannelSenderBuilder::new("anOutput")
         .role(Some("pretendingToBeSomethingElse"))
         .qos(Some(2))
         .retain(Some(true))
-        .build(&mut tether_agent)
-        .expect("failed to create sender channel");
-    let input_wildcard_channel = ChannelOptionsBuilder::create_receiver("everything")
-        .topic(Some("#"))
-        .build(&mut tether_agent);
+        .build(&tether_agent);
 
-    let input_customid_channel = ChannelOptionsBuilder::create_receiver("someData")
-        .role(None) // i.e., just use default
-        .id(Some("specificIDonly"))
-        .build(&mut tether_agent);
+    let sender_channel = tether_agent.create_sender_with_definition(sender_channel_def);
+
+    let input_wildcard_channel_def = ChannelReceiverBuilder::new("everything")
+        .override_topic(Some("#"))
+        .build();
+    let input_wildcard_channel = tether_agent
+        .create_receiver_with_definition::<u8>(input_wildcard_channel_def)
+        .expect("failed to create Channel Receiver");
+
+    // let input_customid_channel_def = ChannelReceiverOptions::new("someData")
+    //     .role(None) // i.e., just use default
+    //     .id(Some("specificIDonly"))
+    //     .build();
 
     println!("Agent looks like this: {:?}", tether_agent.description());
     let (role, id, _) = tether_agent.description();
     assert_eq!(role, "example");
     assert_eq!(id, "any"); // because we set None
 
-    if let ChannelDefinition::ChannelSender(p) = &sender_channel {
-        println!("sender channel: {:?}", p);
-        assert_eq!(
-            p.generated_topic(),
-            "pretendingToBeSomethingElse/any/anOutput"
-        );
-    }
-
-    println!("wildcard input channel: {:?}", input_wildcard_channel);
-    println!("speific ID input channel: {:?}", input_customid_channel);
+    println!(
+        "wildcard input channel: {:?}",
+        input_wildcard_channel.definition().generated_topic()
+    );
+    // println!(
+    //     "speific ID input channel: {:?}",
+    //     input_customid_channel_def.generated_topic()
+    // );
 
     let payload =
         rmp_serde::to_vec::<String>(&String::from("boo")).expect("failed to serialise payload");
     tether_agent
-        .send(&sender_channel, Some(&payload))
+        .send(&sender_channel, &payload)
         .expect("failed to publish");
 
     std::thread::sleep(Duration::from_millis(4000));
diff --git a/examples/rust/receive.rs b/examples/rust/receive.rs
index 0286555..e034433 100644
--- a/examples/rust/receive.rs
+++ b/examples/rust/receive.rs
@@ -1,11 +1,9 @@
-use std::{thread, time::Duration};
-
 use env_logger::{Builder, Env};
-use log::{debug, info, warn};
-use rmp_serde::from_slice;
+use log::*;
 use serde::Deserialize;
-use tether_agent::{ChannelOptionsBuilder, TetherAgentOptionsBuilder};
+use tether_agent::TetherAgentBuilder;
 
+#[allow(dead_code)]
 #[derive(Deserialize, Debug)]
 struct CustomMessage {
     id: usize,
@@ -17,127 +15,38 @@ struct CustomMessage {
 fn main() {
     println!("Rust Tether Agent subscribe example");
 
-    let mut builder = Builder::from_env(Env::default().default_filter_or("debug"));
+    let mut builder = Builder::from_env(Env::default().default_filter_or("info"));
     builder.filter_module("tether_agent", log::LevelFilter::Warn);
     builder.filter_module("rumqttc", log::LevelFilter::Warn);
     builder.init();
 
     debug!("Debugging is enabled; could be verbose");
 
-    let mut tether_agent = TetherAgentOptionsBuilder::new("RustDemo")
+    let tether_agent = TetherAgentBuilder::new("RustDemo")
         .id(Some("example"))
         .build()
         .expect("failed to init Tether agent");
 
-    let input_one = ChannelOptionsBuilder::create_receiver("one")
-        .build(&mut tether_agent)
-        .expect("failed to create input");
-    info!(
-        "input one {} = {}",
-        input_one.name(),
-        input_one.generated_topic()
-    );
-    let input_two = ChannelOptionsBuilder::create_receiver("two")
-        .role(Some("specific"))
-        .build(&mut tether_agent)
-        .expect("failed to create input");
-    info!(
-        "input two {} = {}",
-        input_two.name(),
-        input_two.generated_topic()
-    );
-    let input_empty = ChannelOptionsBuilder::create_receiver("nothing")
-        .build(&mut tether_agent)
-        .expect("failed to create input");
-
-    let input_everything = ChannelOptionsBuilder::create_receiver("everything")
-        .topic(Some("#"))
-        .build(&mut tether_agent)
-        .expect("failed to create input");
-
-    let input_specify_id = ChannelOptionsBuilder::create_receiver("groupMessages")
-        .id(Some("someGroup"))
-        .name(None)
-        .build(&mut tether_agent)
-        .expect("failed to create input");
-
-    debug!(
-        "input everything {} = {}",
-        input_everything.name(),
-        input_everything.generated_topic()
-    );
+    let receiver_of_numbers = tether_agent
+        .create_receiver::<u8>("numbersOnly")
+        .expect("failed to create receiver");
 
-    info!("Checking messages every 1s, 10x...");
+    let receiver_of_custom_structs = tether_agent
+        .create_receiver::<CustomMessage>("customStructs")
+        .expect("failed to create receiver");
 
     loop {
         debug!("Checking for messages...");
         while let Some((topic, payload)) = tether_agent.check_messages() {
-            // debug!(
-            //     "........ Received a message topic {:?} => topic parts {:?}",
-            //     topic, topic
-            // );
-
-            if input_one.matches(&topic) {
-                info!(
-                            "******** INPUT ONE:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
-                            input_one.name(),
-                            topic,
-                            payload.len()
-                        );
-                // assert_eq!(parse_plug_name(topic.un), Some("one"));
+            if let Some(m) = receiver_of_numbers.parse(&topic, &payload) {
+                info!("Decoded a message for our 'numbers' Channel: {:?}", m);
             }
-            if input_two.matches(&topic) {
+            if let Some(m) = receiver_of_custom_structs.parse(&topic, &payload) {
                 info!(
-                        "******** INPUT TWO:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
-                        input_two.name(),
-                        topic,
-                        payload.len()
-                    );
-                // assert_eq!(parse_plug_name(message.topic()), Some("two"));
-                // assert_ne!(parse_plug_name(message.topic()), Some("one"));
-
-                // Notice how you must give the from_slice function a type so it knows what to expect
-                let decoded = from_slice::<CustomMessage>(&payload);
-                match decoded {
-                    Ok(d) => {
-                        info!("Yes, we decoded the MessagePack payload as: {:?}", d);
-                        let CustomMessage { name, id } = d;
-                        debug!("Name is {} and ID is {}", name, id);
-                    }
-                    Err(e) => {
-                        warn!("Failed to decode the payload: {}", e)
-                    }
-                };
-            }
-            if input_empty.matches(&topic) {
-                info!(
-                        "******** EMPTY MESSAGE:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
-                        input_empty.name(),
-                        topic,
-                       payload.len()
-                    );
-                // assert_eq!(parse_plug_name(topic), Some("nothing"));
-            }
-            if input_everything.matches(&topic) {
-                info!(
-                    "******** EVERYTHING MATCHES HERE:\n Received a message for plug named \"{}\" on topic {:?} with length {} bytes",
-                    input_everything.name(),
-                    topic,
-                   payload.len()
+                    "Decoded a message for our 'custom structs' Channel: {:?}",
+                    m
                 );
             }
-            if input_specify_id.matches(&topic) {
-                info!("******** ID MATCH:\n Should match any role and plug name, but only messages with ID \"groupMessages\"");
-                info!(
-                    "\n Received a message from plug named \"{}\" on topic {:?} with length {} bytes",
-                    input_specify_id.name(),
-                    topic,
-                    payload.len()
-                );
-                // assert_eq!(parse_agent_id(message.topic()), Some("groupMessages"));
-            }
         }
-
-        thread::sleep(Duration::from_millis(1000))
     }
 }
diff --git a/examples/rust/send.rs b/examples/rust/send.rs
index 1e11d3e..8df5af0 100644
--- a/examples/rust/send.rs
+++ b/examples/rust/send.rs
@@ -1,9 +1,9 @@
-use std::{thread, time::Duration};
+use std::time::Duration;
 
 use env_logger::{Builder, Env};
 use log::{debug, info};
 use serde::Serialize;
-use tether_agent::{ChannelOptionsBuilder, TetherAgentOptionsBuilder};
+use tether_agent::*;
 
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -19,52 +19,36 @@ fn main() {
 
     debug!("Debugging is enabled; could be verbose");
 
-    let mut tether_agent = TetherAgentOptionsBuilder::new("rustExample")
+    let tether_agent = TetherAgentBuilder::new("rustExample")
         .build()
         .expect("failed to connect Tether");
     let (role, id, _) = tether_agent.description();
     info!("Created agent OK: {}, {}", role, id);
 
-    let empty_message_output = ChannelOptionsBuilder::create_sender("nothing")
-        .build(&mut tether_agent)
-        .expect("failed to create output");
-    let boolean_message_output = ChannelOptionsBuilder::create_sender("one")
-        .build(&mut tether_agent)
-        .expect("failed to create output");
-    let custom_output = ChannelOptionsBuilder::create_sender("two")
-        .topic(Some("custom/custom/two"))
-        .build(&mut tether_agent)
-        .expect("failed to create output");
-    let grouped_output_1 = ChannelOptionsBuilder::create_sender("one")
-        .id(Some("groupMessages"))
-        .build(&mut tether_agent)
-        .expect("failed to create output");
-    let grouped_output_2 = ChannelOptionsBuilder::create_sender("two")
-        .id(Some("groupMessages"))
-        .build(&mut tether_agent)
-        .expect("failed to create output");
+    let sender_definition = ChannelSenderBuilder::new("customStructs").build(&tether_agent);
+    let sender = tether_agent.create_sender_with_definition::<CustomStruct>(sender_definition);
 
-    for i in 1..=10 {
-        info!("#{i}: Sending empty message...");
-        tether_agent.send_raw(&empty_message_output, None).unwrap();
+    // let test_struct = CustomStruct {
+    //     id: 101,
+    //     name: "something".into(),
+    // };
+    let payload = rmp_serde::to_vec_named(&101).expect("failed to serialize");
+    sender.send_raw(&payload).expect("failed to send");
 
-        let just_a_boolean = i % 2 == 0;
-        info!("#{i}: Sending boolean message...");
-        tether_agent
-            .send(&boolean_message_output, just_a_boolean)
-            .unwrap();
+    let another_struct = CustomStruct {
+        id: 202,
+        name: "auto encoded".into(),
+    };
 
-        info!("#{i}: Sending custom struct message...");
-        let custom_message = CustomStruct {
-            id: i,
-            name: "hello".into(),
-        };
-        tether_agent.send(&custom_output, custom_message).unwrap();
+    // Notice how the line below will produce a compiler error, whereas sender.send_raw for the
+    // exact same payload (101) is fine, because .send_raw is not type-checked.
+    // sender.send(&101).expect("failed to encode+send");
 
-        info!("#{i}: Sending grouped messages...");
-        tether_agent.send_empty(&grouped_output_1).unwrap();
-        tether_agent.send_empty(&grouped_output_2).unwrap();
+    sender.send(&another_struct).expect("failed to encode+send");
 
-        thread::sleep(Duration::from_millis(1000))
-    }
+    let number_sender = tether_agent.create_sender::<u8>("numbersOnly");
+
+    number_sender.send(&8).expect("failed to send");
+
+    std::thread::sleep(Duration::from_millis(3000));
 }
diff --git a/examples/svelte-ts/src/lib/TetherTester.svelte b/examples/svelte-ts/src/lib/TetherTester.svelte
index 80fbe7c..3c6c12b 100644
--- a/examples/svelte-ts/src/lib/TetherTester.svelte
+++ b/examples/svelte-ts/src/lib/TetherTester.svelte
@@ -1,13 +1,6 @@
 <script lang="ts">
   import { onDestroy, onMount } from "svelte";
-  import {
-    TetherAgent,
-    BROWSER,
-    ChannelSender,
-    encode,
-    ChannelReceiver,
-    decode,
-  } from "tether-agent";
+  import { TetherAgent, BROWSER, ChannelSender } from "tether-agent";
 
   interface CustomMessage {
     timestamp: number;
@@ -27,9 +20,9 @@
       brokerOptions: BROWSER,
     });
 
-    sender = new ChannelSender(agent, "randomNumbers");
+    sender = agent.createSender("randomNumbers");
 
-    const receiver = await ChannelReceiver.create<number>(agent, "everything", {
+    const receiver = await agent.createReceiver<number>("everything", {
       overrideTopic: "#",
     });
     receiver.on("message", (payload, topic) => {
@@ -65,8 +58,7 @@
           onclick={async () => {
             if (sender) {
               const randomNumber = Math.round(Math.random() * 10000);
-              // await sender.send(encode(randomNumber));
-              await sender.encodeAndSend(randomNumber);
+              await sender.send(randomNumber);
             } else {
               throw Error("ChannelSender does not exist");
             }
diff --git a/lib/js/src/Agent.ts b/lib/js/src/Agent.ts
index bc11255..3646f43 100644
--- a/lib/js/src/Agent.ts
+++ b/lib/js/src/Agent.ts
@@ -1,8 +1,10 @@
 import mqtt, { AsyncMqttClient } from "async-mqtt";
 import { TetherAgentConfig, TetherOptions } from "./types";
+import { ChannelReceiver, ReceiverOptions } from "./Channel/ChannelReceiver";
 import { LogLevelDesc } from "loglevel";
-import { logger } from "./";
+import { ChannelSender, logger } from "./";
 import defaults from "./defaults";
+import { SenderOptions } from "./Channel/ChannelSender";
 
 enum State {
   INITIALISED = "INITIALISED",
@@ -153,4 +155,18 @@ export class TetherAgent {
   };
 
   public getConfig = () => this.config;
+
+  public async createReceiver<T>(
+    name: string,
+    options?: ReceiverOptions
+  ): Promise<ChannelReceiver<T>> {
+    return ChannelReceiver.create(this, name);
+  }
+
+  public createSender<T>(
+    name: string,
+    options?: SenderOptions
+  ): ChannelSender<T> {
+    return new ChannelSender(this, name);
+  }
 }
diff --git a/lib/js/src/Channel.ts b/lib/js/src/Channel/ChannelReceiver.ts
similarity index 56%
rename from lib/js/src/Channel.ts
rename to lib/js/src/Channel/ChannelReceiver.ts
index e0ceee4..45dd861 100644
--- a/lib/js/src/Channel.ts
+++ b/lib/js/src/Channel/ChannelReceiver.ts
@@ -1,28 +1,19 @@
-import { IClientPublishOptions, IClientSubscribeOptions } from "async-mqtt";
-import { TetherAgent, decode, encode, logger } from ".";
-import { ChannelDefinition } from "./types";
-import { Buffer } from "buffer";
-
-// declare interface ChannelReceiver<T> {
-//   on(
-//     event: "message",
-//     listener: (payload: Buffer, topic: string) => void
-//   ): this;
-//   on(event: string, listener: Function): this;
-// }
-
-class Channel {
-  protected definition: ChannelDefinition;
-  protected agent: TetherAgent;
-
-  constructor(agent: TetherAgent, definition: ChannelDefinition) {
-    this.agent = agent;
-
-    logger.debug("Channel super definition:", JSON.stringify(definition));
-    this.definition = definition;
-  }
-
-  public getDefinition = () => this.definition;
+import { IClientSubscribeOptions } from "async-mqtt";
+import { Channel, containsWildcards } from ".";
+import {
+  decode,
+  logger,
+  parseAgentIdOrGroup,
+  parseAgentRole,
+  parseChannelName,
+  TetherAgent,
+} from "..";
+
+export interface ReceiverOptions {
+  overrideTopic?: string;
+  id?: string;
+  role?: string;
+  subscribeOptions?: IClientSubscribeOptions;
 }
 
 type ReceiverCallback<T> = (payload: T, topic: string) => void;
@@ -32,15 +23,17 @@ export class ChannelReceiver<T> extends Channel {
   public static async create<T>(
     agent: TetherAgent,
     channelName: string,
-    options?: {
-      overrideTopic?: string;
-      id?: string;
-      role?: string;
-      subscribeOptions?: IClientSubscribeOptions;
-    }
+    options?: ReceiverOptions
   ) {
     const instance = new ChannelReceiver<T>(agent, channelName, options || {});
 
+    if (agent.getConfig().autoConnect === false) {
+      logger.warn(
+        "Agent had autoConnect set to FALSE; will not attempt subscription - fine for testing, bad for anything else!"
+      );
+      return instance;
+    }
+
     try {
       await instance.subscribe(options?.subscribeOptions || { qos: 1 });
       logger.info("subscribed OK to", instance.definition.topic);
@@ -125,92 +118,18 @@ export class ChannelReceiver<T> extends Channel {
   };
 }
 
-export class ChannelSender<T> extends Channel {
-  private publishOptions: IClientPublishOptions;
-
-  constructor(
-    agent: TetherAgent,
-    channelName: string,
-    options?: {
-      overrideTopic?: string;
-      id?: string;
-      publishOptions?: IClientPublishOptions;
-    }
-  ) {
-    super(agent, {
-      name: channelName,
-      topic:
-        options?.overrideTopic ||
-        buildOutputTopic(
-          channelName,
-          agent.getConfig().role,
-          options?.id || agent.getConfig().id
-        ),
-    });
-    this.publishOptions = options?.publishOptions || {
-      retain: false,
-      qos: 1,
-    };
-    if (channelName === undefined) {
-      throw Error("No name provided for Output");
-    }
-    if (agent.getConfig().autoConnect === true && !agent.getIsConnected()) {
-      throw Error("trying to create an Output before client is connected");
-    }
+const buildInputTopic = (
+  channelName: string,
+  specifyRole?: string,
+  specifyID?: string
+): string => {
+  const role = specifyRole || "+";
+  if (specifyID) {
+    return `${role}/${channelName}/${specifyID}`;
+  } else {
+    return `${role}/${channelName}/#`;
   }
-
-  /** Do NOT encode the content (assume it's already encoded), and then publish */
-  sendRaw = async (content?: Uint8Array) => {
-    if (!this.agent.getIsConnected()) {
-      throw Error(
-        "trying to send without connection; not possible until connected"
-      );
-    }
-    try {
-      logger.debug("Sending on topic", this.definition.topic, "with options", {
-        ...this.publishOptions,
-      });
-      if (content === undefined) {
-        this.agent
-          .getClient()
-          ?.publish(
-            this.definition.topic,
-            Buffer.from([]),
-            this.publishOptions
-          );
-      } else if (content instanceof Uint8Array) {
-        this.agent
-          .getClient()
-          ?.publish(
-            this.definition.topic,
-            Buffer.from(content),
-            this.publishOptions
-          );
-      } else {
-        this.agent
-          .getClient()
-          ?.publish(this.definition.topic, content, this.publishOptions);
-      }
-    } catch (e) {
-      logger.error("Error publishing message:", e);
-    }
-  };
-
-  /** Automatically encode the content as MsgPack, and publish using the ChannelSender topic */
-  send = async (content?: T) => {
-    if (!this.agent.getIsConnected()) {
-      throw Error(
-        "trying to send without connection; not possible until connected"
-      );
-    }
-    try {
-      const buffer = encode(content);
-      this.sendRaw(buffer);
-    } catch (e) {
-      throw Error(`Error encoding content: ${e}`);
-    }
-  };
-}
+};
 
 export const topicMatchesChannel = (
   channelGeneratedTopic: string,
@@ -270,36 +189,3 @@ export const topicMatchesChannel = (
   //     );
   //   }
 };
-
-const containsWildcards = (topicOrPart: string) =>
-  topicOrPart.includes("+") || topicOrPart.includes("#");
-
-const buildInputTopic = (
-  channelName: string,
-  specifyRole?: string,
-  specifyID?: string
-): string => {
-  const role = specifyRole || "+";
-  if (specifyID) {
-    return `${role}/${channelName}/${specifyID}`;
-  } else {
-    return `${role}/${channelName}/#`;
-  }
-};
-
-const buildOutputTopic = (
-  channelName: string,
-  specifyRole: string,
-  specifyID?: string
-): string => {
-  const role = specifyRole;
-  if (specifyID) {
-    return `${role}/${channelName}/${specifyID}`;
-  } else {
-    return `${role}/${channelName}`;
-  }
-};
-
-export const parseChannelName = (topic: string) => topic.split(`/`)[1];
-export const parseAgentIdOrGroup = (topic: string) => topic.split(`/`)[2];
-export const parseAgentRole = (topic: string) => topic.split(`/`)[0];
diff --git a/lib/js/src/Channel/ChannelSender.ts b/lib/js/src/Channel/ChannelSender.ts
new file mode 100644
index 0000000..fe8a017
--- /dev/null
+++ b/lib/js/src/Channel/ChannelSender.ts
@@ -0,0 +1,112 @@
+import { IClientPublishOptions } from "async-mqtt";
+import { Channel, containsWildcards } from ".";
+import {
+  encode,
+  logger,
+  parseAgentIdOrGroup,
+  parseAgentRole,
+  parseChannelName,
+  TetherAgent,
+} from "..";
+
+export interface SenderOptions {
+  overrideTopic?: string;
+  id?: string;
+  publishOptions?: IClientPublishOptions;
+}
+
+export class ChannelSender<T> extends Channel {
+  private publishOptions: IClientPublishOptions;
+
+  constructor(
+    agent: TetherAgent,
+    channelName: string,
+    options?: SenderOptions
+  ) {
+    super(agent, {
+      name: channelName,
+      topic:
+        options?.overrideTopic ||
+        buildOutputTopic(
+          channelName,
+          agent.getConfig().role,
+          options?.id || agent.getConfig().id
+        ),
+    });
+    this.publishOptions = options?.publishOptions || {
+      retain: false,
+      qos: 1,
+    };
+    if (channelName === undefined) {
+      throw Error("No name provided for Output");
+    }
+    if (agent.getConfig().autoConnect === true && !agent.getIsConnected()) {
+      throw Error("trying to create an Output before client is connected");
+    }
+  }
+
+  /** Do NOT encode the content (assume it's already encoded), and then publish */
+  sendRaw = async (content?: Uint8Array) => {
+    if (!this.agent.getIsConnected()) {
+      throw Error(
+        "trying to send without connection; not possible until connected"
+      );
+    }
+    try {
+      logger.debug("Sending on topic", this.definition.topic, "with options", {
+        ...this.publishOptions,
+      });
+      if (content === undefined) {
+        this.agent
+          .getClient()
+          ?.publish(
+            this.definition.topic,
+            Buffer.from([]),
+            this.publishOptions
+          );
+      } else if (content instanceof Uint8Array) {
+        this.agent
+          .getClient()
+          ?.publish(
+            this.definition.topic,
+            Buffer.from(content),
+            this.publishOptions
+          );
+      } else {
+        this.agent
+          .getClient()
+          ?.publish(this.definition.topic, content, this.publishOptions);
+      }
+    } catch (e) {
+      logger.error("Error publishing message:", e);
+    }
+  };
+
+  /** Automatically encode the content as MsgPack, and publish using the ChannelSender topic */
+  send = async (content?: T) => {
+    if (!this.agent.getIsConnected()) {
+      throw Error(
+        "trying to send without connection; not possible until connected"
+      );
+    }
+    try {
+      const buffer = encode(content);
+      this.sendRaw(buffer);
+    } catch (e) {
+      throw Error(`Error encoding content: ${e}`);
+    }
+  };
+}
+
+const buildOutputTopic = (
+  channelName: string,
+  specifyRole: string,
+  specifyID?: string
+): string => {
+  const role = specifyRole;
+  if (specifyID) {
+    return `${role}/${channelName}/${specifyID}`;
+  } else {
+    return `${role}/${channelName}`;
+  }
+};
diff --git a/lib/js/src/Channel/index.ts b/lib/js/src/Channel/index.ts
new file mode 100644
index 0000000..7ba48da
--- /dev/null
+++ b/lib/js/src/Channel/index.ts
@@ -0,0 +1,25 @@
+import { TetherAgent, logger } from "../";
+import { ChannelDefinition } from "../types";
+import { ChannelReceiver } from "./ChannelReceiver";
+import { ChannelSender } from "./ChannelSender";
+
+export class Channel {
+  protected definition: ChannelDefinition;
+  protected agent: TetherAgent;
+
+  constructor(agent: TetherAgent, definition: ChannelDefinition) {
+    this.agent = agent;
+
+    logger.debug("Channel super definition:", JSON.stringify(definition));
+    this.definition = definition;
+  }
+
+  public getDefinition = () => this.definition;
+}
+
+export const containsWildcards = (topicOrPart: string) =>
+  topicOrPart.includes("+") || topicOrPart.includes("#");
+
+export const parseChannelName = (topic: string) => topic.split(`/`)[1];
+export const parseAgentIdOrGroup = (topic: string) => topic.split(`/`)[2];
+export const parseAgentRole = (topic: string) => topic.split(`/`)[0];
diff --git a/lib/js/src/index.test.ts b/lib/js/src/index.test.ts
index 16eb722..ee3792a 100644
--- a/lib/js/src/index.test.ts
+++ b/lib/js/src/index.test.ts
@@ -1,5 +1,5 @@
 import { ChannelReceiver, ChannelSender, TetherAgent } from ".";
-import { topicMatchesChannel } from "./Channel";
+import { topicMatchesChannel } from "./Channel/ChannelReceiver";
 import { describe, test, expect } from "@jest/globals";
 
 describe("building topic strings", () => {
@@ -25,7 +25,7 @@ describe("building topic strings", () => {
     const output = new ChannelSender(agent, "someChannelName");
     expect(output.getDefinition().name).toEqual("someChannelName");
     expect(output.getDefinition().topic).toEqual(
-      "tester/someChannelName/specialGroup",
+      "tester/someChannelName/specialGroup"
     );
   });
 
@@ -39,7 +39,7 @@ describe("building topic strings", () => {
     });
     expect(output.getDefinition().name).toEqual("someChannelName");
     expect(output.getDefinition().topic).toEqual(
-      "tester/someChannelName/overrideOnChannelCreation",
+      "tester/someChannelName/overrideOnChannelCreation"
     );
   });
 
@@ -51,7 +51,7 @@ describe("building topic strings", () => {
     const input = await ChannelReceiver.create(agent, "someChannelName");
     expect(input.getDefinition().name).toEqual("someChannelName");
     expect(input.getDefinition().topic).toEqual(
-      "+/someChannelName/specialGroup",
+      "+/someChannelName/specialGroup"
     );
   });
 
@@ -65,11 +65,11 @@ describe("building topic strings", () => {
       "someChannelName",
       {
         id: "specialID",
-      },
+      }
     );
     expect(inputCustomID.getDefinition().name).toEqual("someChannelName");
     expect(inputCustomID.getDefinition().topic).toEqual(
-      "+/someChannelName/specialID",
+      "+/someChannelName/specialID"
     );
 
     const inputCustomRole = await ChannelReceiver.create(
@@ -77,11 +77,11 @@ describe("building topic strings", () => {
       "someChannelName",
       {
         role: "specialRole",
-      },
+      }
     );
     expect(inputCustomRole.getDefinition().name).toEqual("someChannelName");
     expect(inputCustomRole.getDefinition().topic).toEqual(
-      "specialRole/someChannelName/#",
+      "specialRole/someChannelName/#"
     );
 
     const inputCustomBoth = await ChannelReceiver.create(
@@ -90,11 +90,11 @@ describe("building topic strings", () => {
       {
         id: "id2",
         role: "role2",
-      },
+      }
     );
     expect(inputCustomBoth.getDefinition().name).toEqual("someChannelName");
     expect(inputCustomBoth.getDefinition().topic).toEqual(
-      "role2/someChannelName/id2",
+      "role2/someChannelName/id2"
     );
   });
 });
@@ -106,28 +106,28 @@ describe("matching topics to Channels", () => {
     expect(
       topicMatchesChannel(
         channelDefinedTopic,
-        "someType/someChannelName/someID",
-      ),
+        "someType/someChannelName/someID"
+      )
     ).toBeTruthy();
 
     expect(
       topicMatchesChannel(
         channelDefinedTopic,
-        "other/someChannelName/otherGroup",
-      ),
+        "other/someChannelName/otherGroup"
+      )
     ).toBeFalsy();
   });
 
   test("if ONLY Channel Name specified, match any with same ChanelName", () => {
     const channelDefinedTopic = "+/someChannelName/#";
     expect(
-      topicMatchesChannel(channelDefinedTopic, "something/someChannelName"),
+      topicMatchesChannel(channelDefinedTopic, "something/someChannelName")
     ).toBeTruthy();
     expect(
       topicMatchesChannel(
         channelDefinedTopic,
-        "something/someChannelName/something",
-      ),
+        "something/someChannelName/something"
+      )
     ).toBeTruthy();
   });
 
@@ -136,14 +136,14 @@ describe("matching topics to Channels", () => {
     expect(
       topicMatchesChannel(
         channelDefinedTopic,
-        "something/someChannelName/something",
-      ),
+        "something/someChannelName/something"
+      )
     ).toBeTruthy();
     expect(
       topicMatchesChannel(
         channelDefinedTopic,
-        "something/someOtherChannelName.something",
-      ),
+        "something/someOtherChannelName.something"
+      )
     ).toBeFalsy();
   });
 
@@ -151,35 +151,35 @@ describe("matching topics to Channels", () => {
     const channelDefinedTopic = "specificAgent/channelName/#";
 
     expect(
-      topicMatchesChannel(channelDefinedTopic, "specificAgent/channelName"),
+      topicMatchesChannel(channelDefinedTopic, "specificAgent/channelName")
     ).toBeTruthy();
     expect(
       topicMatchesChannel(
         channelDefinedTopic,
-        "specificAgent/channelName/anything",
-      ),
+        "specificAgent/channelName/anything"
+      )
     ).toBeTruthy();
     expect(
       topicMatchesChannel(
         channelDefinedTopic,
-        "specificAgent/channelName/somethingElse",
-      ),
+        "specificAgent/channelName/somethingElse"
+      )
     ).toBeTruthy();
     expect(
       topicMatchesChannel(
         channelDefinedTopic,
-        "differentAgent/channelName/anything",
-      ),
+        "differentAgent/channelName/anything"
+      )
     ).toBeFalsy();
   });
 
   test("# wildcard should match any topic", () => {
     const channelDefinedTopic = "#";
     expect(
-      topicMatchesChannel(channelDefinedTopic, "something/something/something"),
+      topicMatchesChannel(channelDefinedTopic, "something/something/something")
     ).toBeTruthy();
     expect(
-      topicMatchesChannel(channelDefinedTopic, "not/event/tether/standard"),
+      topicMatchesChannel(channelDefinedTopic, "not/event/tether/standard")
     ).toBeTruthy();
   });
 
@@ -189,20 +189,20 @@ describe("matching topics to Channels", () => {
     expect(
       topicMatchesChannel(
         channelDefinedTopic,
-        "LidarConsolidation/clusters/e933b82f-cb0d-4f91-a4a7-5625ce3ed20b",
-      ),
+        "LidarConsolidation/clusters/e933b82f-cb0d-4f91-a4a7-5625ce3ed20b"
+      )
     ).toBeFalsy();
     expect(
       topicMatchesChannel(
         channelDefinedTopic,
-        "LidarConsolidation/trackedPoints/e933b82f-cb0d-4f91-a4a7-5625ce3ed20b",
-      ),
+        "LidarConsolidation/trackedPoints/e933b82f-cb0d-4f91-a4a7-5625ce3ed20b"
+      )
     ).toBeTruthy();
     expect(
       topicMatchesChannel(
         channelDefinedTopic,
-        "SomethingElse/trackedPoints/e933b82f-cb0d-4f91-a4a7-5625ce3ed20b",
-      ),
+        "SomethingElse/trackedPoints/e933b82f-cb0d-4f91-a4a7-5625ce3ed20b"
+      )
     ).toBeFalsy();
   });
 
@@ -210,25 +210,25 @@ describe("matching topics to Channels", () => {
     const channelDefinedTopic = "+/channelName/specificGroupOrId";
 
     expect(
-      topicMatchesChannel(channelDefinedTopic, "someAgentRole/channelName"),
+      topicMatchesChannel(channelDefinedTopic, "someAgentRole/channelName")
     ).toBeFalsy();
     expect(
       topicMatchesChannel(
         channelDefinedTopic,
-        "someAgentRole/channelName/specificGroupOrId",
-      ),
+        "someAgentRole/channelName/specificGroupOrId"
+      )
     ).toBeTruthy();
     expect(
       topicMatchesChannel(
         channelDefinedTopic,
-        "anotherAgent/channelName/specificGroupOrId",
-      ),
+        "anotherAgent/channelName/specificGroupOrId"
+      )
     ).toBeTruthy();
     expect(
       topicMatchesChannel(
         channelDefinedTopic,
-        "someAgent/channelName/wrongGroup",
-      ),
+        "someAgent/channelName/wrongGroup"
+      )
     ).toBeFalsy();
   });
 
@@ -236,7 +236,7 @@ describe("matching topics to Channels", () => {
     const channelDefinedTopic = "something/something/+";
     try {
       expect(
-        topicMatchesChannel(channelDefinedTopic, "anything/anything/anything"),
+        topicMatchesChannel(channelDefinedTopic, "anything/anything/anything")
       ).toThrow();
     } catch (e) {
       //
diff --git a/lib/js/src/index.ts b/lib/js/src/index.ts
index 36f1eae..bca7548 100644
--- a/lib/js/src/index.ts
+++ b/lib/js/src/index.ts
@@ -1,9 +1,10 @@
 import { IClientOptions } from "async-mqtt";
 import { BROWSER, NODEJS } from "./defaults";
-import { ChannelReceiver, ChannelSender } from "./Channel";
 import logger from "loglevel";
 import { encode, decode } from "@msgpack/msgpack";
 import { TetherAgent } from "./Agent";
+import { ChannelReceiver } from "./Channel/ChannelReceiver";
+import { ChannelSender } from "./Channel/ChannelSender";
 export {
   parseChannelName,
   parseAgentIdOrGroup,
diff --git a/lib/rust/src/agent/mod.rs b/lib/rust/src/agent/mod.rs
index cfe6bee..ff2dd20 100644
--- a/lib/rust/src/agent/mod.rs
+++ b/lib/rust/src/agent/mod.rs
@@ -3,21 +3,39 @@ use log::{debug, error, info, trace, warn};
 use rmp_serde::to_vec_named;
 use rumqttc::tokio_rustls::rustls::ClientConfig;
 use rumqttc::{Client, Event, MqttOptions, Packet, QoS, Transport};
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use std::sync::{Arc, Mutex};
 use std::{sync::mpsc, thread, time::Duration};
 use uuid::Uuid;
 
-use crate::ChannelDefinition;
-use crate::{
-    tether_compliant_topic::{TetherCompliantTopic, TetherOrCustomTopic},
-    ChannelDefinitionCommon,
-};
+use crate::definitions::receiver_builder::ChannelReceiverBuilder;
+use crate::definitions::sender_builder::ChannelSenderBuilder;
+use crate::definitions::ChannelBuilder;
+use crate::definitions::{ChannelDefinition, ChannelReceiverDefinition, ChannelSenderDefinition};
+use crate::receiver::ChannelReceiver;
+use crate::sender::ChannelSender;
+use crate::tether_compliant_topic::{TetherCompliantTopic, TetherOrCustomTopic};
 
 const TIMEOUT_SECONDS: u64 = 3;
 const DEFAULT_USERNAME: &str = "tether";
 const DEFAULT_PASSWORD: &str = "sp_ceB0ss!";
 
+/**
+A Tether Agent struct encapsulates everything required to set up a single
+"Agent" as part of your Tether-based system. The only thing absolutely required is
+a "role" - everything else is optional and sensible defaults will be used when
+not explicitly specified.
+
+By default, the Agent will connect (automatically) to an MQTT Broker on localhost:1883
+
+It will **not** have an ID, and therefore publishing/subscribing topics will not append anything
+this into the topic string when ChannelSender and ChannelReceiver instances are created using
+this Tether Agent instance, unless explicitly provided on creation.
+
+Note that you should typically not construct a new TetherAgent instance yourself; rather
+use the provided TetherAgentBuilder to specify any options you might need, and call
+.build to get a well-configured TetherAgent.
+*/
 pub struct TetherAgent {
     role: String,
     id: Option<String>,
@@ -30,13 +48,20 @@ pub struct TetherAgent {
     mqtt_client_id: Option<String>,
     pub(crate) client: Option<Client>,
     message_sender: mpsc::Sender<(TetherOrCustomTopic, Vec<u8>)>,
-    message_receiver: mpsc::Receiver<(TetherOrCustomTopic, Vec<u8>)>,
+    pub message_receiver: mpsc::Receiver<(TetherOrCustomTopic, Vec<u8>)>,
     is_connected: Arc<Mutex<bool>>,
     auto_connect_enabled: bool,
 }
 
+/**
+Typically, you will use this to construct a well-configured TetherAgent with a combination
+of sensible defaults and custom overrides.
+
+Make a new instance of TetherAgentBuilder with `TetherAgentBuilder::new()`, chain whatever
+overrides you might need, and finally call `build()` to get the actual TetherAgent instance.
+*/
 #[derive(Clone)]
-pub struct TetherAgentOptionsBuilder {
+pub struct TetherAgentBuilder {
     role: String,
     id: Option<String>,
     protocol: Option<String>,
@@ -49,11 +74,11 @@ pub struct TetherAgentOptionsBuilder {
     mqtt_client_id: Option<String>,
 }
 
-impl TetherAgentOptionsBuilder {
+impl TetherAgentBuilder {
     /// Initialise Tether Options struct with default options; call other methods to customise.
     /// Call `build()` to get the actual TetherAgent instance (and connect automatically, by default)
     pub fn new(role: &str) -> Self {
-        TetherAgentOptionsBuilder {
+        TetherAgentBuilder {
             role: String::from(role),
             id: None,
             protocol: None,
@@ -119,11 +144,20 @@ impl TetherAgentOptionsBuilder {
         self
     }
 
+    /// Specify explicitly whether to attempt auto-connection on build;
+    /// if set to `false` you will need to connect the TetherAgent (and therefore
+    /// its underlying MQTT client) yourself after creating the instance.
     pub fn auto_connect(mut self, should_auto_connect: bool) -> Self {
         self.auto_connect = should_auto_connect;
         self
     }
 
+    /// Using a combination of sensible defaults and any overrides you might
+    /// have provided using other functions called on TetherAgentOptions, this
+    /// function returns a well-configured TetherAgent instance.
+    ///
+    /// Unless you set `.auto_connect(false)`, the TetherAgent will attempt to
+    /// connect to the MQTT broker automatically upon creation.
     pub fn build(self) -> anyhow::Result<TetherAgent> {
         let protocol = self.protocol.clone().unwrap_or("mqtt".into());
         let host = self.host.clone().unwrap_or("localhost".into());
@@ -168,7 +202,48 @@ impl TetherAgentOptionsBuilder {
     }
 }
 
-impl TetherAgent {
+impl<'a> TetherAgent {
+    /// The simplest way to create a ChannelSender.
+    ///
+    /// You provide only a Channel Name;
+    /// configuration derived from your Tether Agent instance is used to construct
+    /// the appropriate publishing topics.
+    pub fn create_sender<T: Serialize>(&self, name: &str) -> ChannelSender<T> {
+        ChannelSender::new(self, ChannelSenderBuilder::new(name).build(self))
+    }
+
+    /// Create a ChannelSender instance using a ChannelSenderDefinition already constructed
+    /// elsewhere.
+    pub fn create_sender_with_definition<T: Serialize>(
+        &self,
+        definition: ChannelSenderDefinition,
+    ) -> ChannelSender<T> {
+        ChannelSender::new(self, definition)
+    }
+
+    /// The simplest way to create a Channel Receiver.
+    ///
+    /// You provide only a Channel Name;
+    /// configuration derived from your Tether Agent instance is used to construct
+    /// the appropriate subscribing topics.
+    ///
+    /// The actual subscription is also initiated automatically.
+    pub fn create_receiver<T: Deserialize<'a>>(
+        &'a self,
+        name: &str,
+    ) -> anyhow::Result<ChannelReceiver<'a, T>> {
+        ChannelReceiver::new(self, ChannelReceiverBuilder::new(name).build())
+    }
+
+    /// Create a ChannelReceiver instance using a ChannelReceiverDefinition already constructed
+    /// elsewhere.
+    pub fn create_receiver_with_definition<T: Deserialize<'a>>(
+        &'a self,
+        definition: ChannelReceiverDefinition,
+    ) -> anyhow::Result<ChannelReceiver<'a, T>> {
+        ChannelReceiver::new(self, definition)
+    }
+
     pub fn is_connected(&self) -> bool {
         self.client.is_some()
     }
@@ -206,15 +281,25 @@ impl TetherAgent {
         )
     }
 
+    /// Change the role, even if it was set before. Be careful _when_ you call this,
+    /// as it could affect any new Channel Senders/Receivers created after that point.
     pub fn set_role(&mut self, role: &str) {
         self.role = role.into();
     }
 
+    /// Change the ID, even if it was set (or left empty) before.
+    /// Be careful _when_ you call this,
+    /// as it could affect any new Channel Senders/Receivers created after that point.
     pub fn set_id(&mut self, id: &str) {
         self.id = Some(id.into());
     }
 
-    /// Self must be mutable in order to create and assign new Client (with Connection)
+    /// Use this function yourself **only if you explicitly disallowed auto connection**.
+    /// Otherwise, this function is called automatically as part of the `.build` process.
+    ///
+    /// This function spawns a separate thread for polling the MQTT broker. Any events
+    /// and messages are relayed via mpsc channels internally; for example, you will call
+    /// `.check_messages()` to see if any messages were received and are waiting to be parsed.
     pub fn connect(&mut self) -> anyhow::Result<()> {
         info!(
             "Make new connection to the MQTT server at {}://{}:{}...",
@@ -371,7 +456,9 @@ impl TetherAgent {
         Ok(())
     }
 
-    /// If a message is waiting return ThreePartTopic, Message (String, Message)
+    /// If a message is waiting to be parsed by your application,
+    /// this function will return Topic, Message, i.e. `(TetherOrCustomTopic, Message)`
+    ///
     /// Messages received on topics that are not parseable as Tether Three Part Topics will be returned with
     /// the complete Topic string instead
     pub fn check_messages(&self) -> Option<(TetherOrCustomTopic, Vec<u8>)> {
@@ -386,68 +473,75 @@ impl TetherAgent {
         }
     }
 
-    /// Unlike .send, this function does NOT serialize the data before publishing.
+    /// Typically called via the Channel Sender itself.
     ///
-    /// Given a channel definition and a raw (u8 buffer) payload, publishes a message
-    /// using an appropriate topic and with the QOS specified in the Channel Definition
-    pub fn send_raw(
+    /// This function serializes the data (using Serde/MessagePack) automatically before publishing.
+    ///
+    /// Given a Channel Sender and serializeable data payload, publishes a message
+    /// using an appropriate topic and with the QOS specified in the Channel Definition.
+    ///
+    /// Note that this function requires that the data payload be the same type <T> as
+    /// the Channel Sender, so it will return an Error if the types do not match.
+    pub fn send<T: Serialize>(
         &self,
-        channel_definition: &ChannelDefinition,
-        payload: Option<&[u8]>,
+        channel_sender: &ChannelSender<T>,
+        data: &T,
     ) -> anyhow::Result<()> {
-        match channel_definition {
-            ChannelDefinition::ChannelReceiver(_) => {
-                panic!("You cannot publish using a Channel Receiver")
-            }
-            ChannelDefinition::ChannelSender(channel_sender_definition) => {
-                let topic = channel_sender_definition.generated_topic();
-                let qos = match channel_sender_definition.qos() {
-                    0 => QoS::AtMostOnce,
-                    1 => QoS::AtLeastOnce,
-                    2 => QoS::ExactlyOnce,
-                    _ => QoS::AtMostOnce,
-                };
-
-                if let Some(client) = &self.client {
-                    let res = client
-                        .publish(
-                            topic,
-                            qos,
-                            channel_sender_definition.retain(),
-                            payload.unwrap_or_default(),
-                        )
-                        .map_err(anyhow::Error::msg);
-                    debug!("Published OK");
-                    res
-                } else {
-                    Err(anyhow!("Client not ready for publish"))
-                }
+        match to_vec_named(&data) {
+            Ok(payload) => self.send_raw(channel_sender.definition(), Some(&payload)),
+            Err(e) => {
+                error!("Failed to encode: {e:?}");
+                Err(e.into())
             }
         }
     }
 
-    /// Serializes the data automatically before publishing.
+    /// Typically called via the Channel Sender itself.
+    ///
+    /// Unlike .send, this function does NOT serialize the data before publishing. It therefore
+    /// does no type checking of the payload.
     ///
-    /// Given a channel definition and serializeable data payload, publishes a message
+    /// Given a Channel Sender and a raw (u8 buffer) payload, publishes a message
     /// using an appropriate topic and with the QOS specified in the Channel Definition
-    pub fn send<T: Serialize>(
+    pub fn send_raw(
         &self,
-        channel_definition: &ChannelDefinition,
-        data: T,
+        channel_definition: &ChannelSenderDefinition,
+        payload: Option<&[u8]>,
     ) -> anyhow::Result<()> {
-        match to_vec_named(&data) {
-            Ok(payload) => self.send_raw(channel_definition, Some(&payload)),
-            Err(e) => {
-                error!("Failed to encode: {e:?}");
-                Err(e.into())
-            }
+        let topic = channel_definition.generated_topic();
+        let qos = match channel_definition.qos() {
+            0 => QoS::AtMostOnce,
+            1 => QoS::AtLeastOnce,
+            2 => QoS::ExactlyOnce,
+            _ => QoS::AtMostOnce,
+        };
+
+        if let Some(client) = &self.client {
+            let res = client
+                .publish(
+                    topic,
+                    qos,
+                    channel_definition.retain(),
+                    payload.unwrap_or_default(),
+                )
+                .map_err(anyhow::Error::msg);
+            debug!("Published OK");
+            res
+        } else {
+            Err(anyhow!("Client not ready for publish"))
         }
     }
 
-    pub fn send_empty(&self, channel_definition: &ChannelDefinition) -> anyhow::Result<()> {
+    pub fn send_empty(&self, channel_definition: &ChannelSenderDefinition) -> anyhow::Result<()> {
         self.send_raw(channel_definition, None)
     }
 
+    /// Publish an already-encoded payload using a provided
+    /// **full topic string** - no need for passing a ChannelSender or
+    /// ChannelSenderDefinition reference.
+    ///
+    /// **WARNING:** This is a back door to using MQTT directly, without any
+    /// guarrantees of correctedness in a Tether-based system!
     pub fn publish_raw(
         &self,
         topic: &str,
diff --git a/lib/rust/src/channels/definitions.rs b/lib/rust/src/channels/definitions.rs
deleted file mode 100644
index a45985b..0000000
--- a/lib/rust/src/channels/definitions.rs
+++ /dev/null
@@ -1,376 +0,0 @@
-use log::{debug, error, warn};
-use serde::{Deserialize, Serialize};
-
-use super::tether_compliant_topic::TetherOrCustomTopic;
-
-pub trait ChannelDefinitionCommon<'a> {
-    fn name(&'a self) -> &'a str;
-    /// Return the generated topic string actually used by the Channel
-    fn generated_topic(&'a self) -> &'a str;
-    /// Return the custom or Tether-compliant topic
-    fn topic(&'a self) -> &'a TetherOrCustomTopic;
-    fn qos(&'a self) -> i32;
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct ChannelReceiverDefinition {
-    name: String,
-    topic: TetherOrCustomTopic,
-    qos: i32,
-}
-
-impl ChannelDefinitionCommon<'_> for ChannelReceiverDefinition {
-    fn name(&self) -> &str {
-        &self.name
-    }
-
-    fn generated_topic(&self) -> &str {
-        match &self.topic {
-            TetherOrCustomTopic::Custom(s) => {
-                debug!(
-                    "Channel named \"{}\" has custom topic \"{}\"",
-                    &self.name, &s
-                );
-                s
-            }
-            TetherOrCustomTopic::Tether(t) => {
-                debug!(
-                    "Channel named \"{}\" has Tether-compliant topic \"{:?}\"",
-                    &self.name, t
-                );
-                t.topic()
-            }
-        }
-    }
-
-    fn topic(&'_ self) -> &'_ TetherOrCustomTopic {
-        &self.topic
-    }
-
-    fn qos(&self) -> i32 {
-        self.qos
-    }
-}
-
-impl ChannelReceiverDefinition {
-    pub fn new(
-        name: &str,
-        topic: TetherOrCustomTopic,
-        qos: Option<i32>,
-    ) -> ChannelReceiverDefinition {
-        ChannelReceiverDefinition {
-            name: String::from(name),
-            topic,
-            qos: qos.unwrap_or(1),
-        }
-    }
-
-    /// Use the topic of an incoming message to check against the definition of an Channel Receiver.
-    ///
-    /// Due to the use of wildcard subscriptions, multiple topic strings might match a given
-    /// Channel Receiver definition. e.g. `someRole/channelMessages` and `anotherRole/channelMessages` and `someRole/channelMessages/specificID`
-    /// should ALL match on a Channel Receiver named `channelMessages` unless more specific Role and/or ID
-    /// parts were specified in the Channel Receiver Definition.
-    ///
-    /// In the case where a Channel Receiver was defined with a completely manually-specified topic string,
-    /// this function returns a warning and marks ANY incoming message as a valid match; the end-user
-    /// developer is expected to match against topic strings themselves.
-    pub fn matches(&self, incoming_topic: &TetherOrCustomTopic) -> bool {
-        match incoming_topic {
-            TetherOrCustomTopic::Tether(incoming_three_parts) => match &self.topic {
-                TetherOrCustomTopic::Tether(my_tpt) => {
-                    let matches_role =
-                        my_tpt.role() == "+" || my_tpt.role().eq(incoming_three_parts.role());
-                    let matches_channel_name = my_tpt.channel_name() == "+"
-                        || my_tpt
-                            .channel_name()
-                            .eq(incoming_three_parts.channel_name());
-                    let matches_id = match my_tpt.id() {
-                        Some(specified_id) => match incoming_three_parts.id() {
-                            Some(incoming_id) => specified_id == incoming_id,
-                            None => false,
-                        },
-                        None => true,
-                    };
-
-                    debug!("Test match for Channel named \"{}\" with def {:?} against {:?} => matches_role? {}, matches_id? {}, matches_channel_name? {}", &self.name, &self.topic, &incoming_three_parts, matches_role, matches_id, matches_channel_name);
-                    matches_role && matches_id && matches_channel_name
-                }
-                TetherOrCustomTopic::Custom(my_custom_topic) => {
-                    debug!(
-                    "Custom/manual topic \"{}\" on Channel \"{}\" cannot be matched automatically; please filter manually for this",
-                    &my_custom_topic,
-                    self.name()
-                );
-                    my_custom_topic.as_str() == "#"
-                        || my_custom_topic.as_str() == incoming_three_parts.topic()
-                }
-            },
-            TetherOrCustomTopic::Custom(incoming_custom) => match &self.topic {
-                TetherOrCustomTopic::Custom(my_custom_topic) => {
-                    if my_custom_topic.as_str() == "#"
-                        || my_custom_topic.as_str() == incoming_custom.as_str()
-                    {
-                        true
-                    } else {
-                        warn!(
-                            "Incoming topic \"{}\" is not a Tether-Compliant topic",
-                            &incoming_custom
-                        );
-                        false
-                    }
-                }
-                TetherOrCustomTopic::Tether(_) => {
-                    error!("Incoming is NOT Tether Compliant Topic but this Channel DOES have Tether Compliant Topic; cannot decide match");
-                    false
-                }
-            },
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct ChannelSenderDefinition {
-    name: String,
-    topic: TetherOrCustomTopic,
-    qos: i32,
-    retain: bool,
-}
-
-impl ChannelDefinitionCommon<'_> for ChannelSenderDefinition {
-    fn name(&'_ self) -> &'_ str {
-        &self.name
-    }
-
-    fn generated_topic(&self) -> &str {
-        match &self.topic {
-            TetherOrCustomTopic::Custom(s) => s,
-            TetherOrCustomTopic::Tether(t) => t.topic(),
-        }
-    }
-
-    fn topic(&'_ self) -> &'_ TetherOrCustomTopic {
-        &self.topic
-    }
-
-    fn qos(&'_ self) -> i32 {
-        self.qos
-    }
-}
-
-impl ChannelSenderDefinition {
-    pub fn new(
-        name: &str,
-        topic: TetherOrCustomTopic,
-        qos: Option<i32>,
-        retain: Option<bool>,
-    ) -> ChannelSenderDefinition {
-        ChannelSenderDefinition {
-            name: String::from(name),
-            topic,
-            qos: qos.unwrap_or(1),
-            retain: retain.unwrap_or(false),
-        }
-    }
-
-    pub fn retain(&self) -> bool {
-        self.retain
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub enum ChannelDefinition {
-    ChannelReceiver(ChannelReceiverDefinition),
-    ChannelSender(ChannelSenderDefinition),
-}
-
-impl ChannelDefinition {
-    pub fn name(&self) -> &str {
-        match self {
-            ChannelDefinition::ChannelReceiver(p) => p.name(),
-            ChannelDefinition::ChannelSender(p) => p.name(),
-        }
-    }
-
-    pub fn generated_topic(&self) -> &str {
-        match self {
-            ChannelDefinition::ChannelReceiver(p) => p.generated_topic(),
-            ChannelDefinition::ChannelSender(p) => p.generated_topic(),
-        }
-    }
-
-    pub fn matches(&self, topic: &TetherOrCustomTopic) -> bool {
-        match self {
-            ChannelDefinition::ChannelReceiver(p) => p.matches(topic),
-            ChannelDefinition::ChannelSender(_) => {
-                error!("We don't check matches for Channel Senders");
-                false
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use crate::{
-        tether_compliant_topic::{parse_channel_name, TetherCompliantTopic, TetherOrCustomTopic},
-        ChannelDefinitionCommon, ChannelReceiverDefinition,
-    };
-
-    #[test]
-    fn receiver_match_tpt() {
-        let channel_def = ChannelReceiverDefinition::new(
-            "testChannel",
-            TetherOrCustomTopic::Tether(TetherCompliantTopic::new_for_subscribe(
-                "testChannel",
-                None,
-                None,
-            )),
-            None,
-        );
-
-        assert_eq!(&channel_def.name, "testChannel");
-        assert_eq!(channel_def.generated_topic(), "+/testChannel/#");
-        assert_eq!(
-            parse_channel_name("someRole/testChannel"),
-            Some("testChannel")
-        );
-        assert_eq!(
-            parse_channel_name("someRole/testChannel/something"),
-            Some("testChannel")
-        );
-        assert!(channel_def.matches(&TetherOrCustomTopic::Tether(
-            TetherCompliantTopic::new_three("dummy", "testChannel", "#")
-        )));
-        assert!(!channel_def.matches(&TetherOrCustomTopic::Tether(
-            TetherCompliantTopic::new_three("dummy", "anotherChannel", "#")
-        )));
-    }
-
-    #[test]
-    fn receiver_match_tpt_custom_role() {
-        let channel_def = ChannelReceiverDefinition::new(
-            "customChanel",
-            TetherOrCustomTopic::Tether(TetherCompliantTopic::new_for_subscribe(
-                "customChanel",
-                Some("customRole"),
-                None,
-            )),
-            None,
-        );
-
-        assert_eq!(&channel_def.name, "customChanel");
-        assert_eq!(channel_def.generated_topic(), "customRole/customChanel/#");
-        assert!(channel_def.matches(&TetherOrCustomTopic::Tether(
-            TetherCompliantTopic::new_three("customRole", "customChanel", "#")
-        )));
-        assert!(channel_def.matches(&TetherOrCustomTopic::Tether(
-            TetherCompliantTopic::new_three("customRole", "customChanel", "andAnythingElse")
-        )));
-        assert!(!channel_def.matches(&TetherOrCustomTopic::Tether(
-            TetherCompliantTopic::new_three("customRole", "notMyChannel", "#")
-        ))); // wrong incoming Channel Name
-        assert!(!channel_def.matches(&TetherOrCustomTopic::Tether(
-            TetherCompliantTopic::new_three("someOtherRole", "customChanel", "#")
-        ))); // wrong incoming Role
-    }
-
-    #[test]
-    fn receiver_match_custom_id() {
-        let channel_def = ChannelReceiverDefinition::new(
-            "customChanel",
-            TetherOrCustomTopic::Tether(TetherCompliantTopic::new_for_subscribe(
-                "customChanel",
-                None,
-                Some("specificID"),
-            )),
-            None,
-        );
-
-        assert_eq!(&channel_def.name, "customChanel");
-        assert_eq!(channel_def.generated_topic(), "+/customChanel/specificID");
-        assert!(channel_def.matches(&TetherOrCustomTopic::Tether(
-            TetherCompliantTopic::new_three("anyRole", "customChanel", "specificID",)
-        )));
-        assert!(channel_def.matches(&TetherOrCustomTopic::Tether(
-            TetherCompliantTopic::new_three("anotherRole", "customChanel", "specificID",)
-        ))); // wrong incoming Role
-        assert!(!channel_def.matches(&TetherOrCustomTopic::Tether(
-            TetherCompliantTopic::new_three("anyRole", "notMyChannel", "specificID",)
-        ))); // wrong incoming Channel Name
-        assert!(!channel_def.matches(&TetherOrCustomTopic::Tether(
-            TetherCompliantTopic::new_three("anyRole", "customChanel", "anotherID",)
-        ))); // wrong incoming ID
-    }
-
-    #[test]
-    fn receiver_match_both() {
-        let channel_def = ChannelReceiverDefinition::new(
-            "customChanel",
-            TetherOrCustomTopic::Tether(TetherCompliantTopic::new_for_subscribe(
-                "customChanel",
-                Some("specificRole"),
-                Some("specificID"),
-            )),
-            None,
-        );
-
-        assert_eq!(&channel_def.name, "customChanel");
-        assert_eq!(
-            channel_def.generated_topic(),
-            "specificRole/customChanel/specificID"
-        );
-        assert!(channel_def.matches(&TetherOrCustomTopic::Tether(
-            TetherCompliantTopic::new_three("specificRole", "customChanel", "specificID",)
-        )));
-        assert!(!channel_def.matches(&TetherOrCustomTopic::Custom(
-            "specificRole/notMyChannel/specificID".into()
-        ))); // wrong incoming Channel Name
-        assert!(!channel_def.matches(&TetherOrCustomTopic::Custom(
-            "specificRole/customChanel/anotherID".into()
-        ))); // wrong incoming ID
-        assert!(!channel_def.matches(&TetherOrCustomTopic::Custom(
-            "anotherRole/customChanel/anotherID".into()
-        ))); // wrong incoming Role
-    }
-
-    #[test]
-    fn receiver_match_custom_topic() {
-        let channel_def = ChannelReceiverDefinition::new(
-            "customChanel",
-            TetherOrCustomTopic::Custom("one/two/three/four/five".into()), // not a standard Tether Three Part Topic
-            None,
-        );
-
-        assert_eq!(channel_def.name(), "customChanel");
-        // it will match on exactly the same topic:
-        assert!(channel_def.matches(&TetherOrCustomTopic::Custom(
-            "one/two/three/four/five".into()
-        )));
-
-        // it will NOT match on anything else:
-        assert!(!channel_def.matches(&TetherOrCustomTopic::Custom("one/one/one/one/one".into())));
-    }
-
-    #[test]
-    fn receiver_match_wildcard() {
-        let channel_def = ChannelReceiverDefinition::new(
-            "everything",
-            TetherOrCustomTopic::Custom("#".into()), // fully legal, but not a standard Three Part Topic
-            None,
-        );
-
-        assert_eq!(channel_def.name(), "everything");
-
-        // Standard TPT will match
-        assert!(channel_def.matches(&TetherOrCustomTopic::Tether(
-            TetherCompliantTopic::new_three("any", "chanelName", "#")
-        )));
-
-        // Anything will match, even custom incoming
-        assert!(channel_def.matches(&TetherOrCustomTopic::Custom(
-            "one/two/three/four/five".into()
-        )));
-    }
-}
diff --git a/lib/rust/src/channels/definitions/mod.rs b/lib/rust/src/channels/definitions/mod.rs
new file mode 100644
index 0000000..4152d17
--- /dev/null
+++ b/lib/rust/src/channels/definitions/mod.rs
@@ -0,0 +1,388 @@
+use super::tether_compliant_topic::TetherOrCustomTopic;
+
+pub mod receiver_builder;
+pub mod sender_builder;
+
+pub use receiver_builder::ChannelReceiverBuilder;
+pub use sender_builder::ChannelSenderBuilder;
+
+/**
+A Channel Builder is used for creating a Channel Definition.
+*/
+pub trait ChannelBuilder {
+    fn new(name: &str) -> Self;
+    fn qos(self, qos: Option<i32>) -> Self;
+    fn role(self, role: Option<&str>) -> Self;
+    fn id(self, id: Option<&str>) -> Self;
+    fn override_name(self, override_channel_name: Option<&str>) -> Self;
+    fn override_topic(self, override_topic: Option<&str>) -> Self;
+}
+
+/**
+A Channel Definition is intended to encapsulate only the essential metadata
+and configuration needed to describe a Channel. In contrast with a Channel Sender/Receiver,
+it is **not** responsible for actually sending or receiving messages on that Channel.
+*/
+pub trait ChannelDefinition<'a> {
+    fn name(&'a self) -> &'a str;
+    /// Return the generated topic string actually used by the Channel
+    fn generated_topic(&'a self) -> &'a str;
+    /// Return the custom or Tether-compliant topic
+    fn topic(&'a self) -> &'a TetherOrCustomTopic;
+    fn qos(&'a self) -> i32;
+}
+
+#[derive(Clone)]
+pub struct ChannelSenderDefinition {
+    pub name: String,
+    pub generated_topic: String,
+    pub topic: TetherOrCustomTopic,
+    pub qos: i32,
+    pub retain: bool,
+}
+
+impl ChannelSenderDefinition {
+    pub fn retain(&self) -> bool {
+        self.retain
+    }
+}
+
+#[derive(Clone)]
+pub struct ChannelReceiverDefinition {
+    pub name: String,
+    pub generated_topic: String,
+    pub topic: TetherOrCustomTopic,
+    pub qos: i32,
+}
+
+impl<'a> ChannelDefinition<'a> for ChannelSenderDefinition {
+    fn name(&'a self) -> &'a str {
+        &self.name
+    }
+
+    fn generated_topic(&'a self) -> &'a str {
+        &self.generated_topic
+    }
+
+    fn topic(&'a self) -> &'a TetherOrCustomTopic {
+        &self.topic
+    }
+
+    fn qos(&'a self) -> i32 {
+        self.qos
+    }
+}
+
+impl<'a> ChannelDefinition<'a> for ChannelReceiverDefinition {
+    fn name(&'a self) -> &'a str {
+        &self.name
+    }
+
+    fn generated_topic(&'a self) -> &'a str {
+        &self.generated_topic
+    }
+
+    fn topic(&'a self) -> &'a TetherOrCustomTopic {
+        &self.topic
+    }
+
+    fn qos(&'a self) -> i32 {
+        self.qos
+    }
+}
+
+// #[cfg(test)]
+// mod tests {
+
+//     use crate::{ChannelOptionsBuilder, TetherAgentOptionsBuilder};
+
+//     // fn verbose_logging() {
+//     //     use env_logger::{Builder, Env};
+//     //     let mut logger_builder = Builder::from_env(Env::default().default_filter_or("debug"));
+//     //     logger_builder.init();
+//     // }
+
+//     #[test]
+//     fn default_receiver_channel() {
+//         // verbose_logging();
+//         let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
+//             .auto_connect(false)
+//             .build()
+//             .expect("sorry, these tests require working localhost Broker");
+//         let receiver = ChannelOptionsBuilder::create_receiver("one")
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(receiver.name(), "one");
+//         assert_eq!(receiver.generated_topic(), "+/one/#");
+//     }
+
+//     #[test]
+//     /// This is a fairly trivial example, but contrast with the test
+//     /// `sender_channel_default_but_agent_id_custom`: although a custom ID was set for the
+//     /// Agent, this does not affect the Topic for a Channel Receiver created without any
+//     /// explicit overrides.
+//     fn default_channel_receiver_with_agent_custom_id() {
+//         // verbose_logging();
+//         let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
+//             .auto_connect(false)
+//             .id(Some("verySpecialGroup"))
+//             .build()
+//             .expect("sorry, these tests require working localhost Broker");
+//         let receiver = ChannelOptionsBuilder::create_receiver("one")
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(receiver.name(), "one");
+//         assert_eq!(receiver.generated_topic(), "+/one/#");
+//     }
+
+//     #[test]
+//     fn default_channel_sender() {
+//         let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
+//             .auto_connect(false)
+//             .build()
+//             .expect("sorry, these tests require working localhost Broker");
+//         let channel = ChannelOptionsBuilder::create_sender("two")
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(channel.name(), "two");
+//         assert_eq!(channel.generated_topic(), "tester/two");
+//     }
+
+//     #[test]
+//     /// This is identical to the case in which a Channel Sender is created with defaults (no overrides),
+//     /// BUT the Agent had a custom ID set, which means that the final topic includes this custom
+//     /// ID/Group value.
+//     fn sender_channel_default_but_agent_id_custom() {
+//         let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
+//             .auto_connect(false)
+//             .id(Some("specialCustomGrouping"))
+//             .build()
+//             .expect("sorry, these tests require working localhost Broker");
+//         let channel = ChannelOptionsBuilder::create_sender("somethingStandard")
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(channel.name(), "somethingStandard");
+//         assert_eq!(
+//             channel.generated_topic(),
+//             "tester/somethingStandard/specialCustomGrouping"
+//         );
+//     }
+
+//     #[test]
+//     fn receiver_id_andor_role() {
+//         let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
+//             .auto_connect(false)
+//             .build()
+//             .expect("sorry, these tests require working localhost Broker");
+
+//         let receive_role_only = ChannelOptionsBuilder::create_receiver("theChannel")
+//             .role(Some("specificRole"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(receive_role_only.name(), "theChannel");
+//         assert_eq!(
+//             receive_role_only.generated_topic(),
+//             "specificRole/theChannel/#"
+//         );
+
+//         let receiver_id_only = ChannelOptionsBuilder::create_receiver("theChannel")
+//             .id(Some("specificID"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(receiver_id_only.name(), "theChannel");
+//         assert_eq!(
+//             receiver_id_only.generated_topic(),
+//             "+/theChannel/specificID"
+//         );
+
+//         let receiver_both_custom = ChannelOptionsBuilder::create_receiver("theChannel")
+//             .id(Some("specificID"))
+//             .role(Some("specificRole"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(receiver_both_custom.name(), "theChannel");
+//         assert_eq!(
+//             receiver_both_custom.generated_topic(),
+//             "specificRole/theChannel/specificID"
+//         );
+//     }
+
+//     #[test]
+//     /// If the end-user implicitly specifies the chanel name part (does not set it to Some(_)
+//     /// or None) then the ID and/or Role parts will change but the Channel Name part will
+//     /// remain the "original" / default
+//     /// Contrast with receiver_specific_id_andor_role_no_chanel_name below.
+//     fn receiver_specific_id_andor_role_with_channel_name() {
+//         let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
+//             .auto_connect(false)
+//             .build()
+//             .expect("sorry, these tests require working localhost Broker");
+
+//         let receiver_role_only = ChannelOptionsBuilder::create_receiver("theChannel")
+//             .role(Some("specificRole"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(receiver_role_only.name(), "theChannel");
+//         assert_eq!(
+//             receiver_role_only.generated_topic(),
+//             "specificRole/theChannel/#"
+//         );
+
+//         let receiver_id_only = ChannelOptionsBuilder::create_receiver("theChannel")
+//             .id(Some("specificID"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(receiver_id_only.name(), "theChannel");
+//         assert_eq!(
+//             receiver_id_only.generated_topic(),
+//             "+/theChannel/specificID"
+//         );
+
+//         let receiver_both = ChannelOptionsBuilder::create_receiver("theChannel")
+//             .id(Some("specificID"))
+//             .role(Some("specificRole"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(receiver_both.name(), "theChannel");
+//         assert_eq!(
+//             receiver_both.generated_topic(),
+//             "specificRole/theChannel/specificID"
+//         );
+//     }
+
+//     #[test]
+//     /// Unlike receiver_specific_id_andor_role_with_channel_name, this tests the situation where
+//     /// the end-user (possibly) specifies the ID and/or Role, but also explicitly
+//     /// sets the Channel Name to Some("+"), ie. "use a wildcard at this
+//     /// position instead" - and NOT the original channel name.
+//     fn receiver_specific_id_andor_role_no_channel_name() {
+//         let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
+//             .auto_connect(false)
+//             .build()
+//             .expect("sorry, these tests require working localhost Broker");
+
+//         let receiver_only_chanel_name_none = ChannelOptionsBuilder::create_receiver("theChannel")
+//             .name(Some("+"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(receiver_only_chanel_name_none.name(), "theChannel");
+//         assert_eq!(receiver_only_chanel_name_none.generated_topic(), "+/+/#");
+
+//         let receiver_role_only = ChannelOptionsBuilder::create_receiver("theChannel")
+//             .name(Some("+"))
+//             .role(Some("specificRole"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(receiver_role_only.name(), "theChannel");
+//         assert_eq!(receiver_role_only.generated_topic(), "specificRole/+/#");
+
+//         let receiver_id_only = ChannelOptionsBuilder::create_receiver("theChannel")
+//             // .name(Some("+"))
+//             .any_channel() // equivalent to Some("+")
+//             .id(Some("specificID"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(receiver_id_only.name(), "theChannel");
+//         assert_eq!(receiver_id_only.generated_topic(), "+/+/specificID");
+
+//         let receiver_both = ChannelOptionsBuilder::create_receiver("theChannel")
+//             .name(Some("+"))
+//             .id(Some("specificID"))
+//             .role(Some("specificRole"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(receiver_both.name(), "theChannel");
+//         assert_eq!(receiver_both.generated_topic(), "specificRole/+/specificID");
+//     }
+
+//     #[test]
+//     fn any_name_but_specify_role() {
+//         // Some fairly niche cases here
+
+//         let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
+//             .auto_connect(false)
+//             .build()
+//             .expect("sorry, these tests require working localhost Broker");
+
+//         let receiver_any_channel = ChannelOptionsBuilder::create_receiver("aTest")
+//             .any_channel()
+//             .build(&mut tether_agent)
+//             .unwrap();
+
+//         assert_eq!(receiver_any_channel.name(), "aTest");
+//         assert_eq!(receiver_any_channel.generated_topic(), "+/+/#");
+
+//         let receiver_specify_role = ChannelOptionsBuilder::create_receiver("aTest")
+//             .any_channel()
+//             .role(Some("brain"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+
+//         assert_eq!(receiver_specify_role.name(), "aTest");
+//         assert_eq!(receiver_specify_role.generated_topic(), "brain/+/#");
+//     }
+
+//     #[test]
+//     fn sender_custom() {
+//         let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
+//             .auto_connect(false)
+//             .build()
+//             .expect("sorry, these tests require working localhost Broker");
+
+//         let sender_custom_role = ChannelOptionsBuilder::create_sender("theChannelSender")
+//             .role(Some("customRole"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(sender_custom_role.name(), "theChannelSender");
+//         assert_eq!(
+//             sender_custom_role.generated_topic(),
+//             "customRole/theChannelSender"
+//         );
+
+//         let sender_custom_id = ChannelOptionsBuilder::create_sender("theChannelSender")
+//             .id(Some("customID"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(sender_custom_id.name(), "theChannelSender");
+//         assert_eq!(
+//             sender_custom_id.generated_topic(),
+//             "tester/theChannelSender/customID"
+//         );
+
+//         let sender_custom_both = ChannelOptionsBuilder::create_sender("theChannelSender")
+//             .role(Some("customRole"))
+//             .id(Some("customID"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(sender_custom_both.name(), "theChannelSender");
+//         assert_eq!(
+//             sender_custom_both.generated_topic(),
+//             "customRole/theChannelSender/customID"
+//         );
+//     }
+
+//     #[test]
+//     fn receiver_manual_topics() {
+//         let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
+//             .auto_connect(false)
+//             .build()
+//             .expect("sorry, these tests require working localhost Broker");
+
+//         let receiver_all = ChannelOptionsBuilder::create_receiver("everything")
+//             .topic(Some("#"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(receiver_all.name(), "everything");
+//         assert_eq!(receiver_all.generated_topic(), "#");
+
+//         let receiver_nontether = ChannelOptionsBuilder::create_receiver("weird")
+//             .topic(Some("foo/bar/baz/one/two/three"))
+//             .build(&mut tether_agent)
+//             .unwrap();
+//         assert_eq!(receiver_nontether.name(), "weird");
+//         assert_eq!(
+//             receiver_nontether.generated_topic(),
+//             "foo/bar/baz/one/two/three"
+//         );
+//     }
+// }
diff --git a/lib/rust/src/channels/definitions/receiver_builder.rs b/lib/rust/src/channels/definitions/receiver_builder.rs
new file mode 100644
index 0000000..a5cb7d0
--- /dev/null
+++ b/lib/rust/src/channels/definitions/receiver_builder.rs
@@ -0,0 +1,137 @@
+use crate::tether_compliant_topic::{TetherCompliantTopic, TetherOrCustomTopic};
+
+use log::*;
+
+use super::{ChannelBuilder, ChannelReceiverDefinition};
+
+pub struct ChannelReceiverBuilder {
+    channel_name: String,
+    qos: Option<i32>,
+    override_subscribe_role: Option<String>,
+    override_subscribe_id: Option<String>,
+    override_subscribe_channel_name: Option<String>,
+    override_topic: Option<String>,
+}
+
+impl ChannelBuilder for ChannelReceiverBuilder {
+    fn new(name: &str) -> Self {
+        ChannelReceiverBuilder {
+            channel_name: String::from(name),
+            override_subscribe_id: None,
+            override_subscribe_role: None,
+            override_subscribe_channel_name: None,
+            override_topic: None,
+            qos: None,
+        }
+    }
+
+    fn qos(self, qos: Option<i32>) -> Self {
+        ChannelReceiverBuilder { qos, ..self }
+    }
+
+    fn role(self, role: Option<&str>) -> Self {
+        if self.override_topic.is_some() {
+            error!("Override topic was also provided; this will take precedence");
+            self
+        } else {
+            let override_subscribe_role = role.map(|s| s.into());
+            ChannelReceiverBuilder {
+                override_subscribe_role,
+                ..self
+            }
+        }
+    }
+
+    fn id(self, id: Option<&str>) -> Self {
+        if self.override_topic.is_some() {
+            error!("Override topic was also provided; this will take precedence");
+            self
+        } else {
+            let override_subscribe_id = id.map(|s| s.into());
+            ChannelReceiverBuilder {
+                override_subscribe_id,
+                ..self
+            }
+        }
+    }
+
+    fn override_name(self, override_channel_name: Option<&str>) -> Self {
+        if self.override_topic.is_some() {
+            error!("Override topic was also provided; this will take precedence");
+            return self;
+        }
+        if override_channel_name.is_some() {
+            let override_subscribe_channel_name = override_channel_name.map(|s| s.into());
+            ChannelReceiverBuilder {
+                override_subscribe_channel_name,
+                ..self
+            }
+        } else {
+            debug!("Override Channel name set to None; will use original name \"{}\" given in ::create_receiver constructor", self.channel_name);
+            self
+        }
+    }
+
+    fn override_topic(self, override_topic: Option<&str>) -> Self {
+        match override_topic {
+            Some(t) => {
+                if TryInto::<TetherCompliantTopic>::try_into(t).is_ok() {
+                    info!("Custom topic passes Tether Compliant Topic validation");
+                } else if t == "#" {
+                    info!("Wildcard \"#\" custom topics are not Tether Compliant Topics but are valid");
+                } else {
+                    warn!(
+                        "Could not convert \"{}\" into Tether Compliant Topic; presumably you know what you're doing!",
+                        t
+                    );
+                }
+                ChannelReceiverBuilder {
+                    override_topic: Some(t.into()),
+                    ..self
+                }
+            }
+            None => ChannelReceiverBuilder {
+                override_topic: None,
+                ..self
+            },
+        }
+    }
+}
+
+impl ChannelReceiverBuilder {
+    pub fn any_channel(self) -> Self {
+        ChannelReceiverBuilder {
+            override_subscribe_channel_name: Some("+".into()),
+            ..self
+        }
+    }
+
+    pub fn build(self) -> ChannelReceiverDefinition {
+        let tpt: TetherOrCustomTopic = match self.override_topic {
+            Some(custom) => TetherOrCustomTopic::Custom(custom),
+            None => {
+                debug!(
+                    "Not a custom topic; provided overrides: role = {:?}, id = {:?}, name = {:?}",
+                    self.override_subscribe_role,
+                    self.override_subscribe_id,
+                    self.override_subscribe_channel_name
+                );
+
+                TetherOrCustomTopic::Tether(TetherCompliantTopic::new_for_subscribe(
+                    &self
+                        .override_subscribe_channel_name
+                        .unwrap_or(self.channel_name.clone()),
+                    self.override_subscribe_role.as_deref(),
+                    self.override_subscribe_id.as_deref(),
+                ))
+            }
+        };
+
+        ChannelReceiverDefinition {
+            name: self.channel_name,
+            generated_topic: tpt.full_topic_string(),
+            topic: tpt,
+            qos: self.qos.unwrap_or(1),
+        }
+    }
+}
diff --git a/lib/rust/src/channels/definitions/sender_builder.rs b/lib/rust/src/channels/definitions/sender_builder.rs
new file mode 100644
index 0000000..95a1715
--- /dev/null
+++ b/lib/rust/src/channels/definitions/sender_builder.rs
@@ -0,0 +1,150 @@
+use crate::{
+    tether_compliant_topic::{TetherCompliantTopic, TetherOrCustomTopic},
+    TetherAgent,
+};
+
+use log::*;
+
+use super::{ChannelBuilder, ChannelSenderDefinition};
+
+pub struct ChannelSenderBuilder {
+    channel_name: String,
+    qos: Option<i32>,
+    override_publish_role: Option<String>,
+    override_publish_id: Option<String>,
+    override_topic: Option<String>,
+    retain: Option<bool>,
+}
+
+impl ChannelBuilder for ChannelSenderBuilder {
+    fn new(name: &str) -> Self {
+        ChannelSenderBuilder {
+            channel_name: String::from(name),
+            override_publish_id: None,
+            override_publish_role: None,
+            override_topic: None,
+            retain: None,
+            qos: None,
+        }
+    }
+
+    fn qos(self, qos: Option<i32>) -> Self {
+        ChannelSenderBuilder { qos, ..self }
+    }
+
+    fn role(self, role: Option<&str>) -> Self {
+        if self.override_topic.is_some() {
+            error!("Override topic was also provided; this will take precedence");
+            self
+        } else {
+            let override_publish_role = role.map(|s| s.into());
+            ChannelSenderBuilder {
+                override_publish_role,
+                ..self
+            }
+        }
+    }
+
+    fn id(self, id: Option<&str>) -> Self {
+        if self.override_topic.is_some() {
+            error!("Override topic was also provided; this will take precedence");
+            self
+        } else {
+            let override_publish_id = id.map(|s| s.into());
+            ChannelSenderBuilder {
+                override_publish_id,
+                ..self
+            }
+        }
+    }
+
+    fn override_name(self, override_channel_name: Option<&str>) -> Self {
+        if self.override_topic.is_some() {
+            error!("Override topic was also provided; this will take precedence");
+            return self;
+        }
+        match override_channel_name {
+            Some(n) => ChannelSenderBuilder {
+                channel_name: n.into(),
+                ..self
+            },
+            None => {
+                debug!("Override Channel name set to None; will use original name \"{}\" given in ::create_receiver constructor", self.channel_name);
+                self
+            }
+        }
+    }
+
+    fn override_topic(self, override_topic: Option<&str>) -> Self {
+        match override_topic {
+            Some(t) => {
+                if TryInto::<TetherCompliantTopic>::try_into(t).is_ok() {
+                    info!("Custom topic passes Tether Compliant Topic validation");
+                } else if t == "#" {
+                    info!("Wildcard \"#\" custom topics are not Tether Compliant Topics but are valid");
+                } else {
+                    warn!(
+                        "Could not convert \"{}\" into Tether Compliant Topic; presumably you know what you're doing!",
+                        t
+                    );
+                }
+                ChannelSenderBuilder {
+                    override_topic: Some(t.into()),
+                    ..self
+                }
+            }
+            None => ChannelSenderBuilder {
+                override_topic: None,
+                ..self
+            },
+        }
+    }
+}
+
+impl ChannelSenderBuilder {
+    pub fn retain(self, should_retain: Option<bool>) -> Self {
+        ChannelSenderBuilder {
+            retain: should_retain,
+            ..self
+        }
+    }
+
+    pub fn build(self, tether_agent: &TetherAgent) -> ChannelSenderDefinition {
+        let tpt: TetherOrCustomTopic = match self.override_topic {
+            Some(custom) => {
+                warn!(
+                    "Custom topic override: \"{}\" - all other options ignored",
+                    custom
+                );
+                TetherOrCustomTopic::Custom(custom)
+            }
+            None => {
+                let optional_id_part = match self.override_publish_id {
+                    Some(id) => {
+                        debug!("Publish ID was overriden at Channel options level. The Agent ID will be ignored.");
+                        Some(id)
+                    }
+                    None => {
+                        debug!("Publish ID was not overriden at Channel options level. The Agent ID will be used instead, if specified in Agent creation.");
+                        tether_agent.id().map(String::from)
+                    }
+                };
+
+                TetherOrCustomTopic::Tether(TetherCompliantTopic::new_for_publish(
+                    tether_agent,
+                    &self.channel_name,
+                    self.override_publish_role.as_deref(),
+                    optional_id_part.as_deref(),
+                ))
+            }
+        };
+
+        ChannelSenderDefinition {
+            name: self.channel_name,
+            generated_topic: tpt.full_topic_string(),
+            topic: tpt,
+            qos: self.qos.unwrap_or(1),
+            retain: self.retain.unwrap_or(false),
+        }
+    }
+}
diff --git a/lib/rust/src/channels/mod.rs b/lib/rust/src/channels/mod.rs
index 0c14210..01f38d8 100644
--- a/lib/rust/src/channels/mod.rs
+++ b/lib/rust/src/channels/mod.rs
@@ -1,6 +1,203 @@
 pub mod definitions;
-pub mod options;
+pub mod receiver;
+pub mod sender;
 pub mod tether_compliant_topic;
 
-pub use definitions::*;
-pub use options::*;
+// pub enum TetherChannel {
+//     ChannelReceiver(ChannelReceiver),
+//     ChannelSender(ChannelSender),
+// }
+
+// impl<T> ChannelCommon< for T
+// where
+//     T: ChannelCommon,
+// {
+//     pub fn name(&self) -> &str {
+//         match self {
+//             TetherChannel::ChannelReceiver(p) => p.name(),
+//             TetherChannel::ChannelSender(p) => p.name(),
+//         }
+//     }
+
+//     pub fn generated_topic(&self) -> &str {
+//         match self {
+//             TetherChannel::ChannelReceiver(p) => p.generated_topic(),
+//             TetherChannel::ChannelSender(p) => p.generated_topic(),
+//         }
+//     }
+
+//     pub fn matches(&self, topic: &TetherOrCustomTopic) -> bool {
+//         match self {
+//             TetherChannel::ChannelReceiver(p) => p.matches(topic),
+//             TetherChannel::ChannelSender(_) => {
+//                 error!("We don't check matches for Channel Senders");
+//                 false
+//             }
+//         }
+//     }
+// }
+
+// #[cfg(test)]
+// mod tests {
+
+//     use crate::{
+//         tether_compliant_topic::{parse_channel_name, TetherCompliantTopic, TetherOrCustomTopic},
+//         ChannelCommon, ChannelReceiver,
+//     };
+
+//     #[test]
+//     fn receiver_match_tpt() {
+//         let channel_def = ChannelReceiver::new(
+//             "testChannel",
+//             TetherOrCustomTopic::Tether(TetherCompliantTopic::new_for_subscribe(
+//                 "testChannel",
+//                 None,
+//                 None,
+//             )),
+//             None,
+//         );
+
+//         assert_eq!(&channel_def.name, "testChannel");
+//         assert_eq!(channel_def.generated_topic(), "+/testChannel/#");
+//         assert_eq!(
+//             parse_channel_name("someRole/testChannel"),
+//             Some("testChannel")
+//         );
+//         assert_eq!(
+//             parse_channel_name("someRole/testChannel/something"),
+//             Some("testChannel")
+//         );
+//         assert!(channel_def.matches(&TetherOrCustomTopic::Tether(
+//             TetherCompliantTopic::new_three("dummy", "testChannel", "#")
+//         )));
+//         assert!(!channel_def.matches(&TetherOrCustomTopic::Tether(
+//             TetherCompliantTopic::new_three("dummy", "anotherChannel", "#")
+//         )));
+//     }
+
+//     #[test]
+//     fn receiver_match_tpt_custom_role() {
+//         let channel_def = ChannelReceiver::new(
+//             "customChanel",
+//             TetherOrCustomTopic::Tether(TetherCompliantTopic::new_for_subscribe(
+//                 "customChanel",
+//                 Some("customRole"),
+//                 None,
+//             )),
+//             None,
+//         );
+
+//         assert_eq!(&channel_def.name, "customChanel");
+//         assert_eq!(channel_def.generated_topic(), "customRole/customChanel/#");
+//         assert!(channel_def.matches(&TetherOrCustomTopic::Tether(
+//             TetherCompliantTopic::new_three("customRole", "customChanel", "#")
+//         )));
+//         assert!(channel_def.matches(&TetherOrCustomTopic::Tether(
+//             TetherCompliantTopic::new_three("customRole", "customChanel", "andAnythingElse")
+//         )));
+//         assert!(!channel_def.matches(&TetherOrCustomTopic::Tether(
+//             TetherCompliantTopic::new_three("customRole", "notMyChannel", "#")
+//         ))); // wrong incoming Channel Name
+//         assert!(!channel_def.matches(&TetherOrCustomTopic::Tether(
+//             TetherCompliantTopic::new_three("someOtherRole", "customChanel", "#")
+//         ))); // wrong incoming Role
+//     }
+
+//     #[test]
+//     fn receiver_match_custom_id() {
+//         let channel_def = ChannelReceiver::new(
+//             "customChanel",
+//             TetherOrCustomTopic::Tether(TetherCompliantTopic::new_for_subscribe(
+//                 "customChanel",
+//                 None,
+//                 Some("specificID"),
+//             )),
+//             None,
+//         );
+
+//         assert_eq!(&channel_def.name, "customChanel");
+//         assert_eq!(channel_def.generated_topic(), "+/customChanel/specificID");
+//         assert!(channel_def.matches(&TetherOrCustomTopic::Tether(
+//             TetherCompliantTopic::new_three("anyRole", "customChanel", "specificID",)
+//         )));
+//         assert!(channel_def.matches(&TetherOrCustomTopic::Tether(
+//             TetherCompliantTopic::new_three("anotherRole", "customChanel", "specificID",)
+//         ))); // wrong incoming Role
+//         assert!(!channel_def.matches(&TetherOrCustomTopic::Tether(
+//             TetherCompliantTopic::new_three("anyRole", "notMyChannel", "specificID",)
+//         ))); // wrong incoming Channel Name
+//         assert!(!channel_def.matches(&TetherOrCustomTopic::Tether(
+//             TetherCompliantTopic::new_three("anyRole", "customChanel", "anotherID",)
+//         ))); // wrong incoming ID
+//     }
+
+//     #[test]
+//     fn receiver_match_both() {
+//         let channel_def = ChannelReceiver::new(
+//             "customChanel",
+//             TetherOrCustomTopic::Tether(TetherCompliantTopic::new_for_subscribe(
+//                 "customChanel",
+//                 Some("specificRole"),
+//                 Some("specificID"),
+//             )),
+//             None,
+//         );
+
+//         assert_eq!(&channel_def.name, "customChanel");
+//         assert_eq!(
+//             channel_def.generated_topic(),
+//             "specificRole/customChanel/specificID"
+//         );
+//         assert!(channel_def.matches(&TetherOrCustomTopic::Tether(
+//             TetherCompliantTopic::new_three("specificRole", "customChanel", "specificID",)
+//         )));
+//         assert!(!channel_def.matches(&TetherOrCustomTopic::Custom(
+//             "specificRole/notMyChannel/specificID".into()
+//         ))); // wrong incoming Channel Name
+//         assert!(!channel_def.matches(&TetherOrCustomTopic::Custom(
+//             "specificRole/customChanel/anotherID".into()
+//         ))); // wrong incoming ID
+//         assert!(!channel_def.matches(&TetherOrCustomTopic::Custom(
+//             "anotherRole/customChanel/anotherID".into()
+//         ))); // wrong incoming Role
+//     }
+
+//     #[test]
+//     fn receiver_match_custom_topic() {
+//         let channel_def = ChannelReceiver::new(
+//             "customChanel",
+//             TetherOrCustomTopic::Custom("one/two/three/four/five".into()), // not a standard Tether Three Part Topic
+//             None,
+//         );
+
+//         assert_eq!(channel_def.name(), "customChanel");
+//         // it will match on exactly the same topic:
+//         assert!(channel_def.matches(&TetherOrCustomTopic::Custom(
+//             "one/two/three/four/five".into()
+//         )));
+
+//         // it will NOT match on anything else:
+//         assert!(!channel_def.matches(&TetherOrCustomTopic::Custom("one/one/one/one/one".into())));
+//     }
+
+//     #[test]
+//     fn receiver_match_wildcard() {
+//         let channel_def = ChannelReceiver::new(
+//             "everything",
+//             TetherOrCustomTopic::Custom("#".into()), // fully legal, but not a standard Three Part Topic
+//             None,
+//         );
+
+//         assert_eq!(channel_def.name(), "everything");
+
+//         // Standard TPT will match
+//         assert!(channel_def.matches(&TetherOrCustomTopic::Tether(
+//             TetherCompliantTopic::new_three("any", "chanelName", "#")
+//         )));
+
+//         // Anything will match, even custom incoming
+//         assert!(channel_def.matches(&TetherOrCustomTopic::Custom(
+//             "one/two/three/four/five".into()
+//         )));
+//     }
+// }
diff --git a/lib/rust/src/channels/options.rs b/lib/rust/src/channels/options.rs
deleted file mode 100644
index e779b11..0000000
--- a/lib/rust/src/channels/options.rs
+++ /dev/null
@@ -1,622 +0,0 @@
-use anyhow::anyhow;
-use log::{debug, error, info, warn};
-
-use crate::{
-    definitions::ChannelDefinitionCommon, tether_compliant_topic::TetherCompliantTopic,
-    ChannelDefinition, TetherAgent,
-};
-
-use super::{
-    tether_compliant_topic::TetherOrCustomTopic, ChannelReceiverDefinition, ChannelSenderDefinition,
-};
-
-pub struct ChannelReceiverOptions {
-    channel_name: String,
-    qos: Option<i32>,
-    override_subscribe_role: Option<String>,
-    override_subscribe_id: Option<String>,
-    override_subscribe_channel_name: Option<String>,
-    override_topic: Option<String>,
-}
-
-pub struct ChannelSenderOptions {
-    channel_name: String,
-    qos: Option<i32>,
-    override_publish_role: Option<String>,
-    override_publish_id: Option<String>,
-    override_topic: Option<String>,
-    retain: Option<bool>,
-}
-
-/// This is the definition of a Channel Receiver or Sender.
-///
-/// You typically don't use an instance of this directly; call `.build()` at the
-/// end of the chain to get a usable **ChannelDefinition**
-pub enum ChannelOptionsBuilder {
-    ChannelReceiver(ChannelReceiverOptions),
-    ChannelSender(ChannelSenderOptions),
-}
-
-impl ChannelOptionsBuilder {
-    pub fn create_receiver(name: &str) -> ChannelOptionsBuilder {
-        ChannelOptionsBuilder::ChannelReceiver(ChannelReceiverOptions {
-            channel_name: String::from(name),
-            override_subscribe_id: None,
-            override_subscribe_role: None,
-            override_subscribe_channel_name: None,
-            override_topic: None,
-            qos: None,
-        })
-    }
-
-    pub fn create_sender(name: &str) -> ChannelOptionsBuilder {
-        ChannelOptionsBuilder::ChannelSender(ChannelSenderOptions {
-            channel_name: String::from(name),
-            override_publish_id: None,
-            override_publish_role: None,
-            override_topic: None,
-            qos: None,
-            retain: None,
-        })
-    }
-
-    pub fn qos(mut self, qos: Option<i32>) -> Self {
-        match &mut self {
-            ChannelOptionsBuilder::ChannelReceiver(s) => s.qos = qos,
-            ChannelOptionsBuilder::ChannelSender(s) => s.qos = qos,
-        };
-        self
-    }
-
-    /**
-    Override the "role" part of the topic that gets generated for this Channel.
-    - For Channel Receivers, this means you want to be specific about the Role part
-      of the topic, instead of using the default wildcard `+` at this location
-    - For Channel Senders, this means you want to override the Role part instead
-      of using your Agent's "own" Role with which you created the Tether Agent
-
-    If you override the entire topic using `.topic` this will be ignored.
-    */
-    pub fn role(mut self, role: Option<&str>) -> Self {
-        match &mut self {
-            ChannelOptionsBuilder::ChannelReceiver(s) => {
-                if s.override_topic.is_some() {
-                    error!("Override topic was also provided; this will take precedence");
-                } else {
-                    s.override_subscribe_role = role.map(|s| s.into());
-                }
-            }
-            ChannelOptionsBuilder::ChannelSender(s) => {
-                if s.override_topic.is_some() {
-                    error!("Override topic was also provided; this will take precedence");
-                } else {
-                    s.override_publish_role = role.map(|s| s.into());
-                }
-            }
-        };
-        self
-    }
-
-    /**
-    Override the "id" part of the topic that gets generated for this Channel.
-    - For Channel Receivers, this means you want to be specific about the ID part
-      of the topic, instead of using the default wildcard `+` at this location
-    - For Channel Senders, this means you want to override the ID part instead
-      of using your Agent's "own" ID which you specified (or left blank, i.e. "any")
-      when creating the Tether Agent
-
-    If you override the entire topic using `.topic` this will be ignored.
-    */
-    pub fn id(mut self, id: Option<&str>) -> Self {
-        match &mut self {
-            ChannelOptionsBuilder::ChannelReceiver(s) => {
-                if s.override_topic.is_some() {
-                    error!("Override topic was also provided; this will take precedence");
-                } else {
-                    s.override_subscribe_id = id.map(|s| s.into());
-                }
-            }
-            ChannelOptionsBuilder::ChannelSender(s) => {
-                if s.override_topic.is_some() {
-                    error!("Override topic was also provided; this will take precedence");
-                } else {
-                    s.override_publish_id = id.map(|s| s.into());
-                }
-            }
-        };
-        self
-    }
-
-    /// Override the "name" part of the topic that gets generated for this Channel.
-    /// This is mainly to facilitate wildcard subscriptions such as
-    /// `someRole/+` instead of `someRole/originalChannelName`.
-    ///
-    /// In the case of Receiver Topics, a wildcard `+` can be used to substitute
-    /// the last part of the topic as in `role/id/+`
-    ///
-    /// Channel Senders will ignore (with an error) any attempt to change the name after
-    /// instantiation.
-    pub fn name(mut self, override_channel_name: Option<&str>) -> Self {
-        match &mut self {
-            ChannelOptionsBuilder::ChannelReceiver(opt) => {
-                if opt.override_topic.is_some() {
-                    error!("Override topic was also provided; this will take precedence");
-                }
-                if override_channel_name.is_some() {
-                    opt.override_subscribe_channel_name = override_channel_name.map(|s| s.into());
-                } else {
-                    debug!("Override Channel name set to None; will use original name \"{}\" given in ::create_receiver constructor", opt.channel_name);
-                }
-            }
-            ChannelOptionsBuilder::ChannelSender(_) => {
-                error!(
-                    "Channel Senders cannot change their name part after ::create_sender constructor"
-                );
-            }
-        };
-        self
-    }
-
-    /// Call this if you would like your Channel Receiver to match **any channel**.
-    /// This is equivalent to `.name(Some("+"))` but is provided for convenience
-    /// since it does not require you to remember the wildcard string.
-    ///
-    /// This also does not prevent you from further restricting the topic
-    /// subscription match by Role and/or ID. So, for example, if you are
-    /// interested in **all messages** from an Agent with the role `"brain"`,
-    /// it is valid to create a channel with `.role("brain").any_channel()` and this
-    /// will subscribe to `"brain/+/#"` as expected.
-    pub fn any_channel(mut self) -> Self {
-        match &mut self {
-            ChannelOptionsBuilder::ChannelReceiver(opt) => {
-                opt.override_subscribe_channel_name = Some("+".into());
-            }
-            ChannelOptionsBuilder::ChannelSender(_) => {
-                error!(
-                    "Channel Senders cannot change their name part after ::create_sender constructor"
-                );
-            }
-        }
-        self
-    }
-
-    /// Override the final topic to use for publishing or subscribing. The provided topic **will** be checked
-    /// against the Tether Compliant Topic (TCT) convention, but the function **will not** reject topic strings - just
-    /// produce a warning. It's therefore valid to use a wildcard such as "#", for Receivers (subscribing).
-    ///
-    /// Any customisations specified using `.role(...)` or `.id(...)` will be ignored if this function is called
-    /// after these.
-    ///
-    /// By default, the override_topic is None, but you can specify None explicitly using this function.
-    pub fn topic(mut self, override_topic: Option<&str>) -> Self {
-        match override_topic {
-            Some(t) => {
-                if TryInto::<TetherCompliantTopic>::try_into(t).is_ok() {
-                    info!("Custom topic passes Tether Compliant Topic validation");
-                } else if t == "#" {
-                    info!("Wildcard \"#\" custom topics are not Tether Compliant Topics but are valid");
-                } else {
-                    warn!(
-                        "Could not convert \"{}\" into Tether Compliant Topic; presumably you know what you're doing!",
-                        t
-                    );
-                }
-                match &mut self {
-                    ChannelOptionsBuilder::ChannelReceiver(s) => s.override_topic = Some(t.into()),
-                    ChannelOptionsBuilder::ChannelSender(s) => s.override_topic = Some(t.into()),
-                };
-            }
-            None => {
-                match &mut self {
-                    ChannelOptionsBuilder::ChannelReceiver(s) => s.override_topic = None,
-                    ChannelOptionsBuilder::ChannelSender(s) => s.override_topic = None,
-                };
-            }
-        }
-        self
-    }
-
-    pub fn retain(mut self, should_retain: Option<bool>) -> Self {
-        match &mut self {
-            Self::ChannelReceiver(_) => {
-                error!("Cannot set retain flag on Receiver / subscription");
-            }
-            Self::ChannelSender(s) => {
-                s.retain = should_retain;
-            }
-        }
-        self
-    }
-
-    /// Finalise the options (substituting suitable defaults if no custom values have been
-    /// provided) and return a valid ChannelDefinition that you can actually use.
-    pub fn build(self, tether_agent: &mut TetherAgent) -> anyhow::Result<ChannelDefinition> {
-        match self {
-            Self::ChannelReceiver(channel_options) => {
-                let tpt: TetherOrCustomTopic = match channel_options.override_topic {
-                    Some(custom) => TetherOrCustomTopic::Custom(custom),
-                    None => {
-                        debug!("Not a custom topic; provided overrides: role = {:?}, id = {:?}, name = {:?}", channel_options.override_subscribe_role, channel_options.override_subscribe_id, channel_options.override_subscribe_channel_name);
-
-                        TetherOrCustomTopic::Tether(TetherCompliantTopic::new_for_subscribe(
-                            &channel_options
-                                .override_subscribe_channel_name
-                                .unwrap_or(channel_options.channel_name.clone()),
-                            channel_options.override_subscribe_role.as_deref(),
-                            channel_options.override_subscribe_id.as_deref(),
-                        ))
-                    }
-                };
-                let channel_definition = ChannelReceiverDefinition::new(
-                    &channel_options.channel_name,
-                    tpt,
-                    channel_options.qos,
-                );
-
-                // This is really only useful for testing purposes.
-                if !tether_agent.auto_connect_enabled() {
-                    warn!("Auto-connect is disabled, skipping subscription");
-                    return Ok(ChannelDefinition::ChannelReceiver(channel_definition));
-                }
-
-                if let Some(client) = &tether_agent.client {
-                    match client.subscribe(
-                        channel_definition.generated_topic(),
-                        match channel_definition.qos() {
-                            0 => rumqttc::QoS::AtMostOnce,
-                            1 => rumqttc::QoS::AtLeastOnce,
-                            2 => rumqttc::QoS::ExactlyOnce,
-                            _ => rumqttc::QoS::AtLeastOnce,
-                        },
-                    ) {
-                        Ok(res) => {
-                            debug!(
-                                "This topic was fine: \"{}\"",
-                                channel_definition.generated_topic()
-                            );
-                            debug!("Server respond OK for subscribe: {res:?}");
-                            Ok(ChannelDefinition::ChannelReceiver(channel_definition))
-                        }
-                        Err(_e) => Err(anyhow!("ClientError")),
-                    }
-                } else {
-                    Err(anyhow!("Client not available for subscription"))
-                }
-            }
-            Self::ChannelSender(channel_options) => {
-                let tpt: TetherOrCustomTopic = match channel_options.override_topic {
-                    Some(custom) => {
-                        warn!(
-                            "Custom topic override: \"{}\" - all other options ignored",
-                            custom
-                        );
-                        TetherOrCustomTopic::Custom(custom)
-                    }
-                    None => {
-                        let optional_id_part = match channel_options.override_publish_id {
-                            Some(id) => {
-                                debug!("Publish ID was overriden at Channel options level. The Agent ID will be ignored.");
-                                Some(id)
-                            }
-                            None => {
-                                debug!("Publish ID was not overriden at Channel options level. The Agent ID will be used instead, if specified in Agent creation.");
-                                tether_agent.id().map(String::from)
-                            }
-                        };
-
-                        TetherOrCustomTopic::Tether(TetherCompliantTopic::new_for_publish(
-                            tether_agent,
-                            &channel_options.channel_name,
-                            channel_options.override_publish_role.as_deref(),
-                            optional_id_part.as_deref(),
-                        ))
-                    }
-                };
-
-                let channel_definition = ChannelSenderDefinition::new(
-                    &channel_options.channel_name,
-                    tpt,
-                    channel_options.qos,
-                    channel_options.retain,
-                );
-                Ok(ChannelDefinition::ChannelSender(channel_definition))
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use crate::{ChannelOptionsBuilder, TetherAgentOptionsBuilder};
-
-    // fn verbose_logging() {
-    //     use env_logger::{Builder, Env};
-    //     let mut logger_builder = Builder::from_env(Env::default().default_filter_or("debug"));
-    //     logger_builder.init();
-    // }
-
-    #[test]
-    fn default_receiver_channel() {
-        // verbose_logging();
-        let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
-            .auto_connect(false)
-            .build()
-            .expect("sorry, these tests require working localhost Broker");
-        let receiver = ChannelOptionsBuilder::create_receiver("one")
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(receiver.name(), "one");
-        assert_eq!(receiver.generated_topic(), "+/one/#");
-    }
-
-    #[test]
-    /// This is a fairly trivial example, but contrast with the test
-    /// `sender_channel_default_but_agent_id_custom`: although a custom ID was set for the
-    /// Agent, this does not affect the Topic for a Channel Receiver created without any
-    /// explicit overrides.
-    fn default_channel_receiver_with_agent_custom_id() {
-        // verbose_logging();
-        let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
-            .auto_connect(false)
-            .id(Some("verySpecialGroup"))
-            .build()
-            .expect("sorry, these tests require working localhost Broker");
-        let receiver = ChannelOptionsBuilder::create_receiver("one")
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(receiver.name(), "one");
-        assert_eq!(receiver.generated_topic(), "+/one/#");
-    }
-
-    #[test]
-    fn default_channel_sender() {
-        let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
-            .auto_connect(false)
-            .build()
-            .expect("sorry, these tests require working localhost Broker");
-        let channel = ChannelOptionsBuilder::create_sender("two")
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(channel.name(), "two");
-        assert_eq!(channel.generated_topic(), "tester/two");
-    }
-
-    #[test]
-    /// This is identical to the case in which a Channel Sender is created with defaults (no overrides),
-    /// BUT the Agent had a custom ID set, which means that the final topic includes this custom
-    /// ID/Group value.
-    fn sender_channel_default_but_agent_id_custom() {
-        let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
-            .auto_connect(false)
-            .id(Some("specialCustomGrouping"))
-            .build()
-            .expect("sorry, these tests require working localhost Broker");
-        let channel = ChannelOptionsBuilder::create_sender("somethingStandard")
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(channel.name(), "somethingStandard");
-        assert_eq!(
-            channel.generated_topic(),
-            "tester/somethingStandard/specialCustomGrouping"
-        );
-    }
-
-    #[test]
-    fn receiver_id_andor_role() {
-        let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
-            .auto_connect(false)
-            .build()
-            .expect("sorry, these tests require working localhost Broker");
-
-        let receive_role_only = ChannelOptionsBuilder::create_receiver("theChannel")
-            .role(Some("specificRole"))
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(receive_role_only.name(), "theChannel");
-        assert_eq!(
-            receive_role_only.generated_topic(),
-            "specificRole/theChannel/#"
-        );
-
-        let receiver_id_only = ChannelOptionsBuilder::create_receiver("theChannel")
-            .id(Some("specificID"))
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(receiver_id_only.name(), "theChannel");
-        assert_eq!(
-            receiver_id_only.generated_topic(),
-            "+/theChannel/specificID"
-        );
-
-        let receiver_both_custom = ChannelOptionsBuilder::create_receiver("theChannel")
-            .id(Some("specificID"))
-            .role(Some("specificRole"))
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(receiver_both_custom.name(), "theChannel");
-        assert_eq!(
-            receiver_both_custom.generated_topic(),
-            "specificRole/theChannel/specificID"
-        );
-    }
-
-    #[test]
-    /// If the end-user implicitly specifies the chanel name part (does not set it to Some(_)
-    /// or None) then the ID and/or Role parts will change but the Channel Name part will
-    /// remain the "original" / default
-    /// Contrast with receiver_specific_id_andor_role_no_chanel_name below.
-    fn receiver_specific_id_andor_role_with_channel_name() {
-        let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
-            .auto_connect(false)
-            .build()
-            .expect("sorry, these tests require working localhost Broker");
-
-        let receiver_role_only = ChannelOptionsBuilder::create_receiver("theChannel")
-            .role(Some("specificRole"))
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(receiver_role_only.name(), "theChannel");
-        assert_eq!(
-            receiver_role_only.generated_topic(),
-            "specificRole/theChannel/#"
-        );
-
-        let receiver_id_only = ChannelOptionsBuilder::create_receiver("theChannel")
-            .id(Some("specificID"))
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(receiver_id_only.name(), "theChannel");
-        assert_eq!(
-            receiver_id_only.generated_topic(),
-            "+/theChannel/specificID"
-        );
-
-        let receiver_both = ChannelOptionsBuilder::create_receiver("theChannel")
-            .id(Some("specificID"))
-            .role(Some("specificRole"))
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(receiver_both.name(), "theChannel");
-        assert_eq!(
-            receiver_both.generated_topic(),
-            "specificRole/theChannel/specificID"
-        );
-    }
-
-    #[test]
-    /// Unlike receiver_specific_id_andor_role_with_channel_name, this tests the situation where
-    /// the end-user (possibly) specifies the ID and/or Role, but also explicitly
-    /// sets the Channel Name to Some("+"), ie. "use a wildcard at this
-    /// position instead" - and NOT the original channel name.
-    fn receiver_specific_id_andor_role_no_channel_name() {
-        let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
-            .auto_connect(false)
-            .build()
-            .expect("sorry, these tests require working localhost Broker");
-
-        let receiver_only_chanel_name_none = ChannelOptionsBuilder::create_receiver("theChannel")
-            .name(Some("+"))
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(receiver_only_chanel_name_none.name(), "theChannel");
-        assert_eq!(receiver_only_chanel_name_none.generated_topic(), "+/+/#");
-
-        let receiver_role_only = ChannelOptionsBuilder::create_receiver("theChannel")
-            .name(Some("+"))
-            .role(Some("specificRole"))
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(receiver_role_only.name(), "theChannel");
-        assert_eq!(receiver_role_only.generated_topic(), "specificRole/+/#");
-
-        let receiver_id_only = ChannelOptionsBuilder::create_receiver("theChannel")
-            // .name(Some("+"))
-            .any_channel() // equivalent to Some("+")
-            .id(Some("specificID"))
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(receiver_id_only.name(), "theChannel");
-        assert_eq!(receiver_id_only.generated_topic(), "+/+/specificID");
-
-        let receiver_both = ChannelOptionsBuilder::create_receiver("theChannel")
-            .name(Some("+"))
-            .id(Some("specificID"))
-            .role(Some("specificRole"))
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(receiver_both.name(), "theChannel");
-        assert_eq!(receiver_both.generated_topic(), "specificRole/+/specificID");
-    }
-
-    #[test]
-    fn any_name_but_specify_role() {
-        // Some fairly niche cases here
-
-        let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
-            .auto_connect(false)
-            .build()
-            .expect("sorry, these tests require working localhost Broker");
-
-        let receiver_any_channel = ChannelOptionsBuilder::create_receiver("aTest")
-            .any_channel()
-            .build(&mut tether_agent)
-            .unwrap();
-
-        assert_eq!(receiver_any_channel.name(), "aTest");
-        assert_eq!(receiver_any_channel.generated_topic(), "+/+/#");
-
-        let receiver_specify_role = ChannelOptionsBuilder::create_receiver("aTest")
-            .any_channel()
-            .role(Some("brain"))
-            .build(&mut tether_agent)
-            .unwrap();
-
-        assert_eq!(receiver_specify_role.name(), "aTest");
-        assert_eq!(receiver_specify_role.generated_topic(), "brain/+/#");
-    }
-
-    #[test]
-    fn sender_custom() {
-        let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
-            .auto_connect(false)
-            .build()
-            .expect("sorry, these tests require working localhost Broker");
-
-        let sender_custom_role = ChannelOptionsBuilder::create_sender("theChannelSender")
-            .role(Some("customRole"))
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(sender_custom_role.name(), "theChannelSender");
-        assert_eq!(
-            sender_custom_role.generated_topic(),
-            "customRole/theChannelSender"
-        );
-
-        let sender_custom_id = ChannelOptionsBuilder::create_sender("theChannelSender")
-            .id(Some("customID"))
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(sender_custom_id.name(), "theChannelSender");
-        assert_eq!(
-            sender_custom_id.generated_topic(),
-            "tester/theChannelSender/customID"
-        );
-
-        let sender_custom_both = ChannelOptionsBuilder::create_sender("theChannelSender")
-            .role(Some("customRole"))
-            .id(Some("customID"))
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(sender_custom_both.name(), "theChannelSender");
-        assert_eq!(
-            sender_custom_both.generated_topic(),
-            "customRole/theChannelSender/customID"
-        );
-    }
-
-    #[test]
-    fn receiver_manual_topics() {
-        let mut tether_agent = TetherAgentOptionsBuilder::new("tester")
-            .auto_connect(false)
-            .build()
-            .expect("sorry, these tests require working localhost Broker");
-
-        let receiver_all = ChannelOptionsBuilder::create_receiver("everything")
-            .topic(Some("#"))
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(receiver_all.name(), "everything");
-        assert_eq!(receiver_all.generated_topic(), "#");
-
-        let receiver_nontether = ChannelOptionsBuilder::create_receiver("weird")
-            .topic(Some("foo/bar/baz/one/two/three"))
-            .build(&mut tether_agent)
-            .unwrap();
-        assert_eq!(receiver_nontether.name(), "weird");
-        assert_eq!(
-            receiver_nontether.generated_topic(),
-            "foo/bar/baz/one/two/three"
-        );
-    }
-}
diff --git a/lib/rust/src/channels/receiver.rs b/lib/rust/src/channels/receiver.rs
new file mode 100644
index 0000000..fc4f99c
--- /dev/null
+++ b/lib/rust/src/channels/receiver.rs
@@ -0,0 +1,145 @@
+use anyhow::anyhow;
+use log::*;
+use rmp_serde::from_slice;
+use serde::Deserialize;
+
+use crate::TetherAgent;
+
+use super::{
+    definitions::{ChannelDefinition, ChannelReceiverDefinition},
+    tether_compliant_topic::TetherOrCustomTopic,
+};
+
+pub struct ChannelReceiver<'a, T: Deserialize<'a>> {
+    definition: ChannelReceiverDefinition,
+    marker: std::marker::PhantomData<&'a T>,
+}
+
+impl<'a, T: Deserialize<'a>> ChannelReceiver<'a, T> {
+    pub fn new(
+        tether_agent: &'a TetherAgent,
+        definition: ChannelReceiverDefinition,
+    ) -> anyhow::Result<ChannelReceiver<'a, T>> {
+        let topic_string = definition.topic().full_topic_string();
+
+        let channel = ChannelReceiver {
+            definition: definition.clone(),
+            marker: std::marker::PhantomData,
+        };
+
+        // This is really only useful for testing purposes.
+        if !tether_agent.auto_connect_enabled() {
+            warn!("Auto-connect is disabled, skipping subscription");
+            return Ok(channel);
+        }
+
+        if let Some(client) = &tether_agent.client {
+            match client.subscribe(&topic_string, {
+                match definition.qos() {
+                    0 => rumqttc::QoS::AtMostOnce,
+                    1 => rumqttc::QoS::AtLeastOnce,
+                    2 => rumqttc::QoS::ExactlyOnce,
+                    _ => rumqttc::QoS::AtLeastOnce,
+                }
+            }) {
+                Ok(res) => {
+                    debug!("This topic was fine: \"{}\"", &topic_string);
+                    debug!("Server respond OK for subscribe: {res:?}");
+                    Ok(channel)
+                }
+                Err(_e) => Err(anyhow!("ClientError")),
+            }
+        } else {
+            Err(anyhow!("Client not available for subscription"))
+        }
+    }
+
+    pub fn definition(&self) -> &ChannelReceiverDefinition {
+        &self.definition
+    }
+
+    /// Typically, you do not need to call this function yourself - rather use `.parse` which will
+    /// both check if the message belongs this channel AND, if so, decode it as well.
+    ///
+    /// Uses the topic of an incoming message to check against the definition of an Channel Receiver.
+    ///
+    /// Due to the use of wildcard subscriptions, multiple topic strings might match a given
+    /// Channel Receiver definition. e.g. `someRole/channelMessages` and `anotherRole/channelMessages` and `someRole/channelMessages/specificID`
+    /// should ALL match on a Channel Receiver named `channelMessages` unless more specific Role and/or ID
+    /// parts were specified in the Channel Receiver Definition.
+    ///
+    /// In the case where a Channel Receiver was defined with a completely manually-specified topic string,
+    /// this function returns a warning and marks ANY incoming message as a valid match; the end-user
+    /// developer is expected to match against topic strings themselves.
+    pub fn matches(&self, incoming_topic: &TetherOrCustomTopic) -> bool {
+        match incoming_topic {
+            TetherOrCustomTopic::Tether(incoming_three_parts) => match &self.definition().topic() {
+                TetherOrCustomTopic::Tether(my_tpt) => {
+                    let matches_role =
+                        my_tpt.role() == "+" || my_tpt.role().eq(incoming_three_parts.role());
+                    let matches_channel_name = my_tpt.channel_name() == "+"
+                        || my_tpt
+                            .channel_name()
+                            .eq(incoming_three_parts.channel_name());
+                    let matches_id = match my_tpt.id() {
+                        Some(specified_id) => match incoming_three_parts.id() {
+                            Some(incoming_id) => specified_id == incoming_id,
+                            None => false,
+                        },
+                        None => true,
+                    };
+
+                    debug!("Test match for Channel named \"{}\" with def {:?} against {:?} => matches_role? {}, matches_id? {}, matches_channel_name? {}",
+                        &self.definition().name(), &self.definition().topic(),
+                        &incoming_three_parts, matches_role, matches_id, matches_channel_name);
+                    matches_role && matches_id && matches_channel_name
+                }
+                TetherOrCustomTopic::Custom(my_custom_topic) => {
+                    debug!(
+                    "Custom/manual topic \"{}\" cannot be matched automatically; please filter manually for this",
+                    &my_custom_topic,
+                );
+                    my_custom_topic.as_str() == "#"
+                        || my_custom_topic.as_str() == incoming_three_parts.topic()
+                }
+            },
+            TetherOrCustomTopic::Custom(incoming_custom) => match &self.definition().topic {
+                TetherOrCustomTopic::Custom(my_custom_topic) => {
+                    if my_custom_topic.as_str() == "#"
+                        || my_custom_topic.as_str() == incoming_custom.as_str()
+                    {
+                        true
+                    } else {
+                        warn!(
+                            "Incoming topic \"{}\" is not a Tether-Compliant topic",
+                            &incoming_custom
+                        );
+                        false
+                    }
+                }
+                TetherOrCustomTopic::Tether(_) => {
+                    error!("Incoming is NOT Tether Compliant Topic but this Channel DOES have Tether Compliant Topic; cannot decide match");
+                    false
+                }
+            },
+        }
+    }
+
+    pub fn parse(&self, incoming_topic: &TetherOrCustomTopic, payload: &'a [u8]) -> Option<T> {
+        if self.matches(incoming_topic) {
+            match from_slice::<T>(payload) {
+                Ok(msg) => Some(msg),
+                Err(e) => {
+                    error!(
+                        "Failed to parse message on channel \"{}\": {}",
+                        &self.definition().name,
+                        e
+                    );
+                    None
+                }
+            }
+        } else {
+            None
+        }
+    }
+}
diff --git a/lib/rust/src/channels/sender.rs b/lib/rust/src/channels/sender.rs
new file mode 100644
index 0000000..c5008f7
--- /dev/null
+++ b/lib/rust/src/channels/sender.rs
@@ -0,0 +1,35 @@
+use crate::TetherAgent;
+use serde::Serialize;
+
+use super::definitions::ChannelSenderDefinition;
+
+pub struct ChannelSender<'a, T: Serialize> {
+    definition: ChannelSenderDefinition,
+    tether_agent: &'a TetherAgent,
+    marker: std::marker::PhantomData<T>,
+}
+
+impl<'a, T: Serialize> ChannelSender<'a, T> {
+    pub fn new(
+        tether_agent: &'a TetherAgent,
+        definition: ChannelSenderDefinition,
+    ) -> ChannelSender<'a, T> {
+        ChannelSender {
+            definition,
+            tether_agent,
+            marker: std::marker::PhantomData,
+        }
+    }
+
+    pub fn definition(&self) -> &ChannelSenderDefinition {
+        &self.definition
+    }
+
+    pub fn send(&self, payload: &T) -> anyhow::Result<()> {
+        self.tether_agent.send(self, payload)
+    }
+
+    pub fn send_raw(&self, payload: &[u8]) -> anyhow::Result<()> {
+        self.tether_agent.send_raw(self.definition(), Some(payload))
+    }
+}
diff --git a/lib/rust/src/channels/tether_compliant_topic.rs b/lib/rust/src/channels/tether_compliant_topic.rs
index aabcf1b..36f24c5 100644
--- a/lib/rust/src/channels/tether_compliant_topic.rs
+++ b/lib/rust/src/channels/tether_compliant_topic.rs
@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::TetherAgent;
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Clone, Serialize, Deserialize, Debug)]
 pub struct TetherCompliantTopic {
     role: String,
     id: Option<String>,
@@ -12,7 +12,7 @@ pub struct TetherCompliantTopic {
     full_topic: String,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Clone, Serialize, Deserialize, Debug)]
 pub enum TetherOrCustomTopic {
     Tether(TetherCompliantTopic),
     Custom(String),
@@ -189,7 +189,7 @@ pub fn parse_agent_role(topic: &str) -> Option<&str> {
 mod tests {
     use crate::{
         tether_compliant_topic::{parse_agent_id, parse_agent_role, parse_channel_name},
-        TetherAgentOptionsBuilder,
+        TetherAgentBuilder,
     };
 
     use super::TetherCompliantTopic;
@@ -204,7 +204,7 @@ mod tests {
 
     #[test]
     fn build_full_topic() {
-        let agent = TetherAgentOptionsBuilder::new("testingRole")
+        let agent = TetherAgentBuilder::new("testingRole")
             .auto_connect(false)
             .build()
             .expect("failed to construct agent");
diff --git a/lib/rust/src/lib.rs b/lib/rust/src/lib.rs
index 3ef37ad..5b8686c 100644
--- a/lib/rust/src/lib.rs
+++ b/lib/rust/src/lib.rs
@@ -2,5 +2,6 @@ pub mod agent;
 pub mod channels;
 
 pub use agent::*;
+pub use channels::definitions::*;
 pub use channels::*;
 pub use rumqttc as mqtt;
diff --git a/tether-utils/Cargo.toml b/tether-utils/Cargo.toml
index a17dbce..18cf334 100644
--- a/tether-utils/Cargo.toml
+++ b/tether-utils/Cargo.toml
@@ -2,7 +2,7 @@
 name = "tether-utils"
 description = "Utilities for Tether Systems"
 version = "1.0.3-alpha"
-edition = "2021"
+edition = "2024"
 license = "MIT"
 repository = "https://github.com/RandomStudio/tether"
 homepage = "https://github.com/RandomStudio/tether"