diff --git a/src/common.rs b/src/common.rs
index 0fb568e0e0130902ec79312bc44e7c6ff941faaf..a88c490ca88c28c09e848f86a9d7ede72dd2a5c0 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -32,11 +32,10 @@ pub type ConnectorId = u32;
 
 /// Used in conjunction with the `ConnectorId` type to create identifiers for ports and components
 pub type U32Suffix = u32;
-#[derive(
-    Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd, serde::Serialize, serde::Deserialize,
-)]
+#[derive(Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd)]
 
 /// Generalization of a port/component identifier
+#[derive(serde::Serialize, serde::Deserialize)]
 #[repr(C)]
 pub struct Id {
     pub(crate) connector_id: ConnectorId,
@@ -48,34 +47,27 @@ pub struct U32Stream {
 }
 
 /// Identifier of a component in a session
-#[derive(
-    Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd, serde::Serialize, serde::Deserialize,
-)]
+#[derive(Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd, serde::Serialize, serde::Deserialize)]
 pub struct ComponentId(Id); // PUB because it can be returned by errors
 
 /// Identifier of a port in a session
-#[derive(
-    Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd, serde::Serialize, serde::Deserialize,
-)]
+#[derive(Copy, Clone, Eq, PartialEq, Ord, Hash, PartialOrd, serde::Serialize, serde::Deserialize)]
 #[repr(transparent)]
 pub struct PortId(Id);
 
 /// A safely aliasable heap-allocated payload of message bytes
 #[derive(Default, Eq, PartialEq, Clone, Ord, PartialOrd)]
 pub struct Payload(Arc<Vec<u8>>);
-#[derive(
-    Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd, serde::Serialize, serde::Deserialize,
-)]
+#[derive(Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd)]
 
 /// "Orientation" of a port, determining whether they can send or receive messages with `put` and `get` respectively.
 #[repr(C)]
+#[derive(serde::Serialize, serde::Deserialize)]
 pub enum Polarity {
     Putter, // output port (from the perspective of the component)
     Getter, // input port (from the perspective of the component)
 }
-#[derive(
-    Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd, serde::Serialize, serde::Deserialize,
-)]
+#[derive(Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd)]
 
 /// "Orientation" of a transport-layer network endpoint, dictating how it's connection procedure should
 /// be conducted. Corresponds with connect() / accept() familiar to TCP socket programming.
diff --git a/src/protocol/arena.rs b/src/protocol/arena.rs
index c2e9ed75708ea1a3c05c1fdd8940e3ab952a9b7d..df2d5ce1cd2ce9d45e97f3d4260f835a6fe7009a 100644
--- a/src/protocol/arena.rs
+++ b/src/protocol/arena.rs
@@ -2,7 +2,6 @@ use crate::common::*;
 use core::hash::Hash;
 use core::marker::PhantomData;
 
-#[derive(serde::Serialize, serde::Deserialize)]
 pub struct Id<T> {
     pub(crate) index: u32,
     _phantom: PhantomData<T>,
@@ -14,7 +13,7 @@ impl<T> Id<T> {
     }
 }
 
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Debug)]
 pub(crate) struct Arena<T> {
     store: Vec<T>,
 }
diff --git a/src/protocol/ast.rs b/src/protocol/ast.rs
index 366d6ae9754350dcf51fcd71f0d21fe614a6dc25..579e804fe917139cf8717191e9ab5f1b4ebf89b8 100644
--- a/src/protocol/ast.rs
+++ b/src/protocol/ast.rs
@@ -60,7 +60,7 @@ macro_rules! define_aliased_ast_id {
 macro_rules! define_new_ast_id {
     // Variant where we just defined the new type, without any indexing
     ($name:ident, $parent:ty) => {
-        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
         pub struct $name (pub(crate) $parent);
 
         impl $name {
@@ -167,7 +167,7 @@ define_new_ast_id!(CallExpressionId, ExpressionId, index(CallExpression, Express
 define_new_ast_id!(VariableExpressionId, ExpressionId, index(VariableExpression, Expression::Variable, expressions), alloc(alloc_variable_expression));
 
 // TODO: @cleanup - pub qualifiers can be removed once done
-#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Debug)]
 pub struct Heap {
     // Root arena, contains the entry point for different modules. Each root
     // contains lists of IDs that correspond to the other arenas.
@@ -234,7 +234,7 @@ impl Index<ChannelStatementId> for Heap {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct Root {
     pub this: RootId,
     // Phase 1: parser
@@ -261,13 +261,13 @@ impl SyntaxElement for Root {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum Pragma {
     Version(PragmaVersion),
     Module(PragmaModule)
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct PragmaVersion {
     pub this: PragmaId,
     // Phase 1: parser
@@ -275,7 +275,7 @@ pub struct PragmaVersion {
     pub version: u64,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct PragmaModule {
     pub this: PragmaId,
     // Phase 1: parser
@@ -283,7 +283,7 @@ pub struct PragmaModule {
     pub value: Vec<u8>,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct PragmaOld {
     pub this: PragmaId,
     // Phase 1: parser
@@ -297,7 +297,7 @@ impl SyntaxElement for PragmaOld {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum Import {
     Module(ImportModule),
     Symbols(ImportSymbols)
@@ -327,7 +327,7 @@ impl SyntaxElement for Import {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct ImportModule {
     pub this: ImportId,
     // Phase 1: parser
@@ -338,7 +338,7 @@ pub struct ImportModule {
     pub module_id: Option<RootId>,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct AliasedSymbol {
     // Phase 1: parser
     pub position: InputPosition,
@@ -348,7 +348,7 @@ pub struct AliasedSymbol {
     pub definition_id: Option<DefinitionId>,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct ImportSymbols {
     pub this: ImportId,
     // Phase 1: parser
@@ -363,7 +363,7 @@ pub struct ImportSymbols {
     pub symbols: Vec<AliasedSymbol>,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct Identifier {
     pub position: InputPosition,
     pub value: Vec<u8>
@@ -382,7 +382,7 @@ impl Display for Identifier {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum NamespacedIdentifierPart {
     // Regular identifier
     Identifier{start: u16, end: u16},
@@ -423,7 +423,7 @@ impl NamespacedIdentifierPart {
 /// implementation we can only have valid namespaced identifier that contain one
 /// set of polymorphic arguments at the appropriate position.
 /// TODO: @tokens Reimplement/rename once we have a tokenizer
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct NamespacedIdentifier {
     pub position: InputPosition,
     pub value: Vec<u8>, // Full name as it resides in the input source
@@ -610,7 +610,7 @@ impl<'a> NamespacedIdentifierIter<'a> {
 }
 
 /// TODO: @types Remove the Message -> Byte hack at some point...
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum ParserTypeVariant {
     // Basic builtin
     Message,
@@ -644,7 +644,7 @@ impl ParserTypeVariant {
 /// linker/validator phase of the compilation process. These types may be
 /// (partially) inferred or represent literals (e.g. a integer whose bytesize is
 /// not yet determined).
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct ParserType {
     pub this: ParserTypeId,
     pub pos: InputPosition,
@@ -656,7 +656,7 @@ pub struct ParserType {
 /// validation phase we will determine whether it refers to a user-defined type,
 /// or a polymorphic argument. After the validation phase it may still be the
 /// case that the resulting `variant` will not pass the typechecker.
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct SymbolicParserType {
     // Phase 1: parser
     pub identifier: NamespacedIdentifier,
@@ -669,7 +669,7 @@ pub struct SymbolicParserType {
 /// Specifies whether the symbolic type points to an actual user-defined type,
 /// or whether it points to a polymorphic argument within the definition (e.g.
 /// a defined variable `T var` within a function `int func<T>()`
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum SymbolicParserTypeVariant {
     Definition(DefinitionId),
     // TODO: figure out if I need the DefinitionId here
@@ -678,7 +678,7 @@ pub enum SymbolicParserTypeVariant {
 
 /// ConcreteType is the representation of a type after resolving symbolic types
 /// and performing type inference
-#[derive(Debug, Clone, Copy, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub enum ConcreteTypePart {
     // Markers for the use of polymorphic types within a procedure's body that
     // refer to polymorphic variables on the procedure's definition. Different
@@ -703,7 +703,7 @@ pub enum ConcreteTypePart {
     Instance(DefinitionId, usize),
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct ConcreteType {
     pub(crate) parts: Vec<ConcreteTypePart>
 }
@@ -725,7 +725,7 @@ impl ConcreteType {
 }
 
 // TODO: Remove at some point
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum PrimitiveType {
     Unassigned,
     Input,
@@ -738,7 +738,7 @@ pub enum PrimitiveType {
     Long,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Type {
     pub primitive: PrimitiveType,
     pub array: bool,
@@ -806,7 +806,7 @@ impl Display for Type {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum Field {
     Length,
     Symbolic(FieldSymbolic),
@@ -827,7 +827,7 @@ impl Field {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct FieldSymbolic {
     // Phase 1: Parser
     pub(crate) identifier: Identifier,
@@ -836,7 +836,7 @@ pub struct FieldSymbolic {
     pub(crate) field_idx: usize,
 }
 
-#[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, Copy)]
 pub enum Scope {
     Definition(DefinitionId),
     Regular(BlockStatementId),
@@ -882,7 +882,7 @@ impl VariableScope for Scope {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum Variable {
     Parameter(Parameter),
     Local(Local),
@@ -932,7 +932,7 @@ impl SyntaxElement for Variable {
 
 /// TODO: Remove distinction between parameter/local and add an enum to indicate
 ///     the distinction between the two
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct Parameter {
     pub this: ParameterId,
     // Phase 1: parser
@@ -947,7 +947,7 @@ impl SyntaxElement for Parameter {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct Local {
     pub this: LocalId,
     // Phase 1: parser
@@ -963,7 +963,7 @@ impl SyntaxElement for Local {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum Definition {
     Struct(StructDefinition),
     Enum(EnumDefinition),
@@ -1088,14 +1088,14 @@ impl VariableScope for Definition {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct StructFieldDefinition {
     pub position: InputPosition,
     pub field: Identifier,
     pub parser_type: ParserTypeId,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct StructDefinition {
     pub this: StructId,
     // Phase 1: parser
@@ -1105,20 +1105,20 @@ pub struct StructDefinition {
     pub fields: Vec<StructFieldDefinition>
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum EnumVariantValue {
     None,
     Integer(i64),
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct EnumVariantDefinition {
     pub position: InputPosition,
     pub identifier: Identifier,
     pub value: EnumVariantValue,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct EnumDefinition {
     pub this: EnumId,
     // Phase 1: parser
@@ -1128,20 +1128,20 @@ pub struct EnumDefinition {
     pub variants: Vec<EnumVariantDefinition>,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum UnionVariantValue {
     None,
     Embedded(Vec<ParserTypeId>),
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct UnionVariantDefinition {
     pub position: InputPosition,
     pub identifier: Identifier,
     pub value: UnionVariantValue,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct UnionDefinition {
     pub this: UnionId,
     // Phase 1: parser
@@ -1151,13 +1151,13 @@ pub struct UnionDefinition {
     pub variants: Vec<UnionVariantDefinition>,
 }
 
-#[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, Copy)]
 pub enum ComponentVariant {
     Primitive,
     Composite,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct Component {
     pub this: ComponentId,
     // Phase 1: parser
@@ -1175,7 +1175,7 @@ impl SyntaxElement for Component {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct Function {
     pub this: FunctionId,
     // Phase 1: parser
@@ -1193,7 +1193,7 @@ impl SyntaxElement for Function {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum Statement {
     Block(BlockStatement),
     Local(LocalStatement),
@@ -1427,7 +1427,7 @@ impl SyntaxElement for Statement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct BlockStatement {
     pub this: BlockStatementId,
     // Phase 1: parser
@@ -1490,7 +1490,7 @@ impl VariableScope for BlockStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum LocalStatement {
     Memory(MemoryStatement),
     Channel(ChannelStatement),
@@ -1532,7 +1532,7 @@ impl SyntaxElement for LocalStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct MemoryStatement {
     pub this: MemoryStatementId,
     // Phase 1: parser
@@ -1553,7 +1553,7 @@ impl SyntaxElement for MemoryStatement {
 /// point of view of the component. So an output port is something that a
 /// component uses to send data over (i.e. it is the "input end" of the
 /// channel), and vice versa.
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct ChannelStatement {
     pub this: ChannelStatementId,
     // Phase 1: parser
@@ -1571,7 +1571,7 @@ impl SyntaxElement for ChannelStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct SkipStatement {
     pub this: SkipStatementId,
     // Phase 1: parser
@@ -1586,7 +1586,7 @@ impl SyntaxElement for SkipStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct LabeledStatement {
     pub this: LabeledStatementId,
     // Phase 1: parser
@@ -1604,7 +1604,7 @@ impl SyntaxElement for LabeledStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct IfStatement {
     pub this: IfStatementId,
     // Phase 1: parser
@@ -1622,7 +1622,7 @@ impl SyntaxElement for IfStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct EndIfStatement {
     pub this: EndIfStatementId,
     // Phase 2: linker
@@ -1637,7 +1637,7 @@ impl SyntaxElement for EndIfStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct WhileStatement {
     pub this: WhileStatementId,
     // Phase 1: parser
@@ -1655,7 +1655,7 @@ impl SyntaxElement for WhileStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct EndWhileStatement {
     pub this: EndWhileStatementId,
     // Phase 2: linker
@@ -1670,7 +1670,7 @@ impl SyntaxElement for EndWhileStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct BreakStatement {
     pub this: BreakStatementId,
     // Phase 1: parser
@@ -1686,7 +1686,7 @@ impl SyntaxElement for BreakStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct ContinueStatement {
     pub this: ContinueStatementId,
     // Phase 1: parser
@@ -1702,7 +1702,7 @@ impl SyntaxElement for ContinueStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct SynchronousStatement {
     pub this: SynchronousStatementId,
     // Phase 1: parser
@@ -1736,7 +1736,7 @@ impl VariableScope for SynchronousStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct EndSynchronousStatement {
     pub this: EndSynchronousStatementId,
     // Phase 2: linker
@@ -1751,7 +1751,7 @@ impl SyntaxElement for EndSynchronousStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct ReturnStatement {
     pub this: ReturnStatementId,
     // Phase 1: parser
@@ -1765,7 +1765,7 @@ impl SyntaxElement for ReturnStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct AssertStatement {
     pub this: AssertStatementId,
     // Phase 1: parser
@@ -1781,7 +1781,7 @@ impl SyntaxElement for AssertStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct GotoStatement {
     pub this: GotoStatementId,
     // Phase 1: parser
@@ -1797,7 +1797,7 @@ impl SyntaxElement for GotoStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct NewStatement {
     pub this: NewStatementId,
     // Phase 1: parser
@@ -1813,7 +1813,7 @@ impl SyntaxElement for NewStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct ExpressionStatement {
     pub this: ExpressionStatementId,
     // Phase 1: parser
@@ -1829,7 +1829,7 @@ impl SyntaxElement for ExpressionStatement {
     }
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum ExpressionParent {
     None, // only set during initial parsing
     If(IfStatementId),
@@ -1841,7 +1841,7 @@ pub enum ExpressionParent {
     Expression(ExpressionId, u32) // index within expression (e.g LHS or RHS of expression)
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum Expression {
     Assignment(AssignmentExpression),
     Binding(BindingExpression),
@@ -2033,7 +2033,7 @@ impl SyntaxElement for Expression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum AssignmentOperator {
     Set,
     Multiplied,
@@ -2048,7 +2048,7 @@ pub enum AssignmentOperator {
     BitwiseOred,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct AssignmentExpression {
     pub this: AssignmentExpressionId,
     // Phase 1: parser
@@ -2068,7 +2068,7 @@ impl SyntaxElement for AssignmentExpression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct BindingExpression {
     pub this: BindingExpressionId,
     // Phase 1: parser
@@ -2081,7 +2081,7 @@ pub struct BindingExpression {
     pub concrete_type: ConcreteType,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct ConditionalExpression {
     pub this: ConditionalExpressionId,
     // Phase 1: parser
@@ -2101,7 +2101,7 @@ impl SyntaxElement for ConditionalExpression {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum BinaryOperator {
     Concatenate,
     LogicalOr,
@@ -2124,7 +2124,7 @@ pub enum BinaryOperator {
     Remainder,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct BinaryExpression {
     pub this: BinaryExpressionId,
     // Phase 1: parser
@@ -2144,7 +2144,7 @@ impl SyntaxElement for BinaryExpression {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum UnaryOperation {
     Positive,
     Negative,
@@ -2156,7 +2156,7 @@ pub enum UnaryOperation {
     PostDecrement,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct UnaryExpression {
     pub this: UnaryExpressionId,
     // Phase 1: parser
@@ -2175,7 +2175,7 @@ impl SyntaxElement for UnaryExpression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct IndexingExpression {
     pub this: IndexingExpressionId,
     // Phase 1: parser
@@ -2194,7 +2194,7 @@ impl SyntaxElement for IndexingExpression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct SlicingExpression {
     pub this: SlicingExpressionId,
     // Phase 1: parser
@@ -2214,7 +2214,7 @@ impl SyntaxElement for SlicingExpression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct SelectExpression {
     pub this: SelectExpressionId,
     // Phase 1: parser
@@ -2233,7 +2233,7 @@ impl SyntaxElement for SelectExpression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct ArrayExpression {
     pub this: ArrayExpressionId,
     // Phase 1: parser
@@ -2255,7 +2255,7 @@ impl SyntaxElement for ArrayExpression {
 //  that accept embedded values (although the polymorphic arguments are placed
 //  differently). To prevent double work we parse as CallExpression, and during
 //  validation we may transform the expression into a union literal.
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct CallExpression {
     pub this: CallExpressionId,
     // Phase 1: parser
@@ -2275,7 +2275,7 @@ impl SyntaxElement for CallExpression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum Method {
     Get,
     Put,
@@ -2284,13 +2284,13 @@ pub enum Method {
     Symbolic(MethodSymbolic)
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct MethodSymbolic {
     pub(crate) identifier: NamespacedIdentifier,
     pub(crate) definition: Option<DefinitionId>
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct LiteralExpression {
     pub this: LiteralExpressionId,
     // Phase 1: parser
@@ -2311,7 +2311,7 @@ impl SyntaxElement for LiteralExpression {
 type LiteralCharacter = Vec<u8>;
 type LiteralInteger = i64; // TODO: @int_literal
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum Literal {
     Null, // message
     True,
@@ -2357,7 +2357,7 @@ impl Literal {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct LiteralStructField {
     // Phase 1: parser
     pub(crate) identifier: Identifier,
@@ -2366,7 +2366,7 @@ pub struct LiteralStructField {
     pub(crate) field_idx: usize, // in struct definition
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct LiteralStruct {
     // Phase 1: parser
     pub(crate) identifier: NamespacedIdentifier,
@@ -2380,7 +2380,7 @@ pub struct LiteralStruct {
 //  accept embedded values. To prevent double work for now we parse as a 
 //  LiteralEnum, and during validation we may transform the expression into a 
 //  union literal.
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct LiteralEnum {
     // Phase 1: parser
     pub(crate) identifier: NamespacedIdentifier,
@@ -2390,7 +2390,7 @@ pub struct LiteralEnum {
     pub(crate) variant_idx: usize, // as present in the type table
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct LiteralUnion {
     // Phase 1: parser
     pub(crate) identifier: NamespacedIdentifier,
@@ -2401,7 +2401,7 @@ pub struct LiteralUnion {
     pub(crate) variant_idx: usize, // as present in type table
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct VariableExpression {
     pub this: VariableExpressionId,
     // Phase 1: parser
diff --git a/src/protocol/eval.rs b/src/protocol/eval.rs
index dd398b4891def402aa7973b5e31997f4cde19e4b..5412525d59afbe05d47e0cb0ea8e6c8dbd0bb414 100644
--- a/src/protocol/eval.rs
+++ b/src/protocol/eval.rs
@@ -30,7 +30,7 @@ trait ValueImpl {
     fn is_type_compatible_hack(h: &Heap, t: &ParserType) -> bool;
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub enum Value {
     Unassigned,
     Input(InputValue),
@@ -897,7 +897,7 @@ impl Display for Value {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct InputValue(pub PortId);
 
 impl Display for InputValue {
@@ -919,7 +919,7 @@ impl ValueImpl for InputValue {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct OutputValue(pub PortId);
 
 impl Display for OutputValue {
@@ -941,7 +941,7 @@ impl ValueImpl for OutputValue {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct MessageValue(pub Option<Payload>);
 
 impl Display for MessageValue {
@@ -973,7 +973,7 @@ impl ValueImpl for MessageValue {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct BooleanValue(bool);
 
 impl Display for BooleanValue {
@@ -995,7 +995,7 @@ impl ValueImpl for BooleanValue {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct ByteValue(i8);
 
 impl Display for ByteValue {
@@ -1017,7 +1017,7 @@ impl ValueImpl for ByteValue {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct ShortValue(i16);
 
 impl Display for ShortValue {
@@ -1039,7 +1039,7 @@ impl ValueImpl for ShortValue {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct IntValue(i32);
 
 impl Display for IntValue {
@@ -1061,7 +1061,7 @@ impl ValueImpl for IntValue {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct LongValue(i64);
 
 impl Display for LongValue {
@@ -1090,7 +1090,7 @@ fn get_array_inner(t: &ParserType) -> Option<ParserTypeId> {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct InputArrayValue(Vec<InputValue>);
 
 impl Display for InputArrayValue {
@@ -1119,7 +1119,7 @@ impl ValueImpl for InputArrayValue {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct OutputArrayValue(Vec<OutputValue>);
 
 impl Display for OutputArrayValue {
@@ -1148,7 +1148,7 @@ impl ValueImpl for OutputArrayValue {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct MessageArrayValue(Vec<MessageValue>);
 
 impl Display for MessageArrayValue {
@@ -1177,7 +1177,7 @@ impl ValueImpl for MessageArrayValue {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct BooleanArrayValue(Vec<BooleanValue>);
 
 impl Display for BooleanArrayValue {
@@ -1206,7 +1206,7 @@ impl ValueImpl for BooleanArrayValue {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct ByteArrayValue(Vec<ByteValue>);
 
 impl Display for ByteArrayValue {
@@ -1235,7 +1235,7 @@ impl ValueImpl for ByteArrayValue {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct ShortArrayValue(Vec<ShortValue>);
 
 impl Display for ShortArrayValue {
@@ -1264,7 +1264,7 @@ impl ValueImpl for ShortArrayValue {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct IntArrayValue(Vec<IntValue>);
 
 impl Display for IntArrayValue {
@@ -1293,7 +1293,7 @@ impl ValueImpl for IntArrayValue {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct LongArrayValue(Vec<LongValue>);
 
 impl Display for LongArrayValue {
@@ -1322,7 +1322,7 @@ impl ValueImpl for LongArrayValue {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 struct Store {
     map: HashMap<VariableId, Value>,
 }
@@ -1577,7 +1577,7 @@ pub enum EvalContinuation {
     Put(Value, Value),
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub(crate) struct Prompt {
     definition: DefinitionId,
     store: Store,
diff --git a/src/protocol/inputsource.rs b/src/protocol/inputsource.rs
index 48519ee2f26fb974a5ba92c63197b69d041d50a1..106b6d76c9ac813bdc99bff0158ca7be8a3c7eec 100644
--- a/src/protocol/inputsource.rs
+++ b/src/protocol/inputsource.rs
@@ -5,7 +5,7 @@ use std::path::Path;
 
 use backtrace::Backtrace;
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub struct InputSource {
     pub(crate) filename: String,
     pub(crate) input: Vec<u8>,
@@ -144,7 +144,7 @@ impl fmt::Display for InputSource {
     }
 }
 
-#[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, Copy)]
 pub struct InputPosition {
     line: usize,
     column: usize,
diff --git a/src/protocol/mod.rs b/src/protocol/mod.rs
index bd0b669313f8225717076c7356ca92bb4ab53483..876376e589b9d46bbf539143a5e296ea51307cea 100644
--- a/src/protocol/mod.rs
+++ b/src/protocol/mod.rs
@@ -28,15 +28,13 @@ use crate::protocol::inputsource::*;
 use crate::protocol::parser::*;
 
 /// Description of a protocol object, used to configure new connectors.
-/// (De)serializable.
-#[derive(serde::Serialize, serde::Deserialize)]
 #[repr(C)]
 pub struct ProtocolDescription {
     heap: Heap,
     source: InputSource,
     root: RootId,
 }
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone)]
 pub(crate) struct ComponentState {
     prompt: Prompt,
 }
diff --git a/src/runtime/mod.rs b/src/runtime/mod.rs
index 7f9122e289fe4b875480eb968394b8ca5aa0e7a4..2cebca9b308e8d556f4b84a1385d90d50715f8a5 100644
--- a/src/runtime/mod.rs
+++ b/src/runtime/mod.rs
@@ -108,7 +108,7 @@ struct VecSet<T: std::cmp::Ord> {
 // owns their destination port. `LocalComponent` corresponds with messages for components
 // managed by the connector itself (hinting for it to look it up in a local structure),
 // whereas the other variants direct the connector to forward the messages over the network.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
 enum Route {
     LocalComponent,
     NetEndpoint { index: usize },
@@ -137,25 +137,8 @@ enum SetupMsg {
     LeaderWave { wave_leader: ConnectorId },
     LeaderAnnounce { tree_leader: ConnectorId },
     YouAreMyParent,
-    SessionGather { unoptimized_map: HashMap<ConnectorId, SessionInfo> },
-    SessionScatter { optimized_map: HashMap<ConnectorId, SessionInfo> },
 }
 
-// A data structure encoding the state of a connector, passed around
-// during the session optimization procedure.
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
-struct SessionInfo {
-    serde_proto_description: SerdeProtocolDescription,
-    port_info: PortInfoMap,
-    endpoint_incoming_to_getter: Vec<PortId>,
-    proto_components: HashMap<ComponentId, ComponentState>,
-}
-
-// Newtype wrapper for an Arc<ProtocolDescription>,
-// such that it can be (de)serialized for transmission over the network.
-#[derive(Debug, Clone)]
-struct SerdeProtocolDescription(Arc<ProtocolDescription>);
-
 // Control message particular to the communication phase.
 // as such, it's annotated with a round_index
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -296,7 +279,7 @@ struct EndpointStore<T> {
 }
 
 // The information associated with a port identifier, designed for local storage.
-#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug)]
 struct PortInfo {
     owner: ComponentId,
     peer: Option<PortId>,
@@ -314,7 +297,7 @@ struct MyPortInfo {
 
 // Newtype around port info map, allowing the implementation of some
 // useful methods
-#[derive(Default, Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[derive(Default, Debug, Clone)]
 struct PortInfoMap {
     // invariant: self.invariant_preserved()
     // `owned` is redundant information, allowing for fast lookup
@@ -378,7 +361,7 @@ struct Predicate {
 // from the solutions of its children. Those children are either locally-managed components,
 // (which are leaves in the solution tree), or other connectors reachable through the given
 // network endpoint (which are internal nodes in the solution tree).
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
 enum SubtreeId {
     LocalComponent(ComponentId),
     NetEndpoint { index: usize },
@@ -868,24 +851,6 @@ impl Debug for Predicate {
         f.debug_set().entries(self.assigned.iter().map(Assignment)).finish()
     }
 }
-impl serde::Serialize for SerdeProtocolDescription {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let inner: &ProtocolDescription = &self.0;
-        inner.serialize(serializer)
-    }
-}
-impl<'de> serde::Deserialize<'de> for SerdeProtocolDescription {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let inner: ProtocolDescription = ProtocolDescription::deserialize(deserializer)?;
-        Ok(Self(Arc::new(inner)))
-    }
-}
 impl IdParts for SpecVar {
     fn id_parts(self) -> (ConnectorId, U32Suffix) {
         self.0.id_parts()
diff --git a/src/runtime/setup.rs b/src/runtime/setup.rs
index 07cba79e56c09ed8f7f1444854abf2fb3296a4ae..596c6e14d5343322de78c2c95eec4eda548bd4d5 100644
--- a/src/runtime/setup.rs
+++ b/src/runtime/setup.rs
@@ -278,18 +278,13 @@ impl Connector {
             )?;
             log!(cu.logger, "Successfully created neighborhood {:?}", &neighborhood);
             // Put it all together with an initial round index of zero.
-            let mut comm = ConnectorCommunication {
+            let comm = ConnectorCommunication {
                 round_index: 0,
                 endpoint_manager,
                 neighborhood,
                 native_batches: vec![Default::default()],
                 round_result: Ok(None), // no previous round yet
             };
-            if cfg!(feature = "session_optimization") {
-                // Perform the session optimization procedure, which may modify the
-                // internals of the connector, rerouting ports, moving around connectors etc.
-                session_optimize(&mut cu, &mut comm, &deadline)?;
-            }
             log!(cu.logger, "connect() finished. setup phase complete");
             Ok(comm)
         };
@@ -808,9 +803,7 @@ fn init_neighborhood(
                     log!(logger, "Endpont {:?} sent unexpected msg! {:?}", recv_index, &msg);
                     return Err(Ce::SetupAlgMisbehavior);
                 }
-                msg @ S(Sm::SessionScatter { .. })
-                | msg @ S(Sm::SessionGather { .. })
-                | msg @ Msg::CommMsg { .. } => {
+                msg @ Msg::CommMsg { .. } => {
                     log!(logger, "delaying msg {:?} during election algorithm", msg);
                     em.delayed_messages.push((recv_index, msg));
                 }
@@ -871,9 +864,7 @@ fn init_neighborhood(
             msg @ S(Sm::MyPortInfo(_)) | msg @ S(Sm::LeaderWave { .. }) => {
                 log!(logger, "discarding old message {:?} during election", msg);
             }
-            msg @ S(Sm::SessionScatter { .. })
-            | msg @ S(Sm::SessionGather { .. })
-            | msg @ Msg::CommMsg { .. } => {
+            msg @ Msg::CommMsg { .. } => {
                 log!(logger, "delaying msg {:?} during election", msg);
                 em.delayed_messages.push((recv_index, msg));
             }
@@ -886,188 +877,3 @@ fn init_neighborhood(
     log!(logger, "Neighborhood constructed {:?}", &neighborhood);
     Ok(neighborhood)
 }
-
-// Connectors collect a map of type ConnectorId=>SessionInfo,
-// representing a global view of the session's state at the leader.
-// The leader rewrites its contents however they like (currently: nothing happens)
-// and the map is again broadcasted, for each peer to make their local changes to
-// reflect the results of the rewrite.
-fn session_optimize(
-    cu: &mut ConnectorUnphased,
-    comm: &mut ConnectorCommunication,
-    deadline: &Option<Instant>,
-) -> Result<(), ConnectError> {
-    use {ConnectError as Ce, Msg::SetupMsg as S, SetupMsg as Sm};
-    log!(cu.logger, "Beginning session optimization");
-    // populate session_info_map from a message per child
-    let mut unoptimized_map: HashMap<ConnectorId, SessionInfo> = Default::default();
-    let mut awaiting: HashSet<usize> = comm.neighborhood.children.iter().copied().collect();
-    comm.endpoint_manager.undelay_all();
-    while !awaiting.is_empty() {
-        log!(
-            cu.logger,
-            "Session gather loop. awaiting info from children {:?}...",
-            awaiting.iter()
-        );
-        let (recv_index, msg) =
-            comm.endpoint_manager.try_recv_any_setup(&mut *cu.logger, deadline)?;
-        log!(cu.logger, "Received from index {:?} msg {:?}", &recv_index, &msg);
-        match msg {
-            S(Sm::SessionGather { unoptimized_map: child_unoptimized_map }) => {
-                if !awaiting.remove(&recv_index) {
-                    log!(
-                        cu.logger,
-                        "Wasn't expecting session info from {:?}. Got {:?}",
-                        recv_index,
-                        &child_unoptimized_map
-                    );
-                    return Err(Ce::SetupAlgMisbehavior);
-                }
-                unoptimized_map.extend(child_unoptimized_map.into_iter());
-            }
-            msg @ S(Sm::YouAreMyParent)
-            | msg @ S(Sm::MyPortInfo(..))
-            | msg @ S(Sm::LeaderAnnounce { .. })
-            | msg @ S(Sm::LeaderWave { .. }) => {
-                log!(cu.logger, "discarding old message {:?} during election", msg);
-            }
-            msg @ S(Sm::SessionScatter { .. }) => {
-                log!(
-                    cu.logger,
-                    "Endpoint {:?} sent unexpected scatter! {:?} I've not contributed yet!",
-                    recv_index,
-                    &msg
-                );
-                return Err(Ce::SetupAlgMisbehavior);
-            }
-            msg @ Msg::CommMsg(..) => {
-                log!(cu.logger, "delaying msg {:?} during session optimization", msg);
-                comm.endpoint_manager.delayed_messages.push((recv_index, msg));
-            }
-        }
-    }
-    log!(
-        cu.logger,
-        "Gathered all children's maps. ConnectorId set is... {:?}",
-        unoptimized_map.keys()
-    );
-    // add my own session info to the map
-    let my_session_info = SessionInfo {
-        port_info: cu.ips.port_info.clone(),
-        proto_components: cu.proto_components.clone(),
-        serde_proto_description: SerdeProtocolDescription(cu.proto_description.clone()),
-        endpoint_incoming_to_getter: comm
-            .endpoint_manager
-            .net_endpoint_store
-            .endpoint_exts
-            .iter()
-            .map(|ee| ee.getter_for_incoming)
-            .collect(),
-    };
-    unoptimized_map.insert(cu.ips.id_manager.connector_id, my_session_info);
-    log!(cu.logger, "Inserting my own info. Unoptimized subtree map is {:?}", &unoptimized_map);
-    // acquire the optimized info...
-    let optimized_map = if let Some(parent) = comm.neighborhood.parent {
-        // ... as a message from my parent
-        log!(cu.logger, "Forwarding gathered info to parent {:?}", parent);
-        let msg = S(Sm::SessionGather { unoptimized_map });
-        comm.endpoint_manager.send_to_setup(parent, &msg)?;
-        'scatter_loop: loop {
-            log!(
-                cu.logger,
-                "Session scatter recv loop. awaiting info from children {:?}...",
-                awaiting.iter()
-            );
-            let (recv_index, msg) =
-                comm.endpoint_manager.try_recv_any_setup(&mut *cu.logger, deadline)?;
-            log!(cu.logger, "Received from index {:?} msg {:?}", &recv_index, &msg);
-            match msg {
-                S(Sm::SessionScatter { optimized_map }) => {
-                    if recv_index != parent {
-                        log!(cu.logger, "I expected the scatter from my parent only!");
-                        return Err(Ce::SetupAlgMisbehavior);
-                    }
-                    break 'scatter_loop optimized_map;
-                }
-                msg @ Msg::CommMsg { .. } => {
-                    log!(cu.logger, "delaying msg {:?} during scatter recv", msg);
-                    comm.endpoint_manager.delayed_messages.push((recv_index, msg));
-                }
-                msg @ S(Sm::SessionGather { .. })
-                | msg @ S(Sm::YouAreMyParent)
-                | msg @ S(Sm::MyPortInfo(..))
-                | msg @ S(Sm::LeaderAnnounce { .. })
-                | msg @ S(Sm::LeaderWave { .. }) => {
-                    log!(cu.logger, "discarding old message {:?} during election", msg);
-                }
-            }
-        }
-    } else {
-        // by computing it myself
-        log!(cu.logger, "I am the leader! I will optimize this session");
-        leader_session_map_optimize(&mut *cu.logger, unoptimized_map)?
-    };
-    log!(
-        cu.logger,
-        "Optimized info map is {:?}. Sending to children {:?}",
-        &optimized_map,
-        comm.neighborhood.children.iter()
-    );
-    log!(cu.logger, "All session info dumped!: {:#?}", &optimized_map);
-    // extract my own ConnectorId's entry
-    let optimized_info =
-        optimized_map.get(&cu.ips.id_manager.connector_id).expect("HEY NO INFO FOR ME?").clone();
-    // broadcast the optimized session info to my children
-    let msg = S(Sm::SessionScatter { optimized_map });
-    for &child in comm.neighborhood.children.iter() {
-        comm.endpoint_manager.send_to_setup(child, &msg)?;
-    }
-    // apply local optimizations
-    apply_my_optimizations(cu, comm, optimized_info)?;
-    log!(cu.logger, "Session optimizations applied");
-    Ok(())
-}
-
-// Defines the optimization function, consuming an optimized map,
-// and returning an optimized map.
-fn leader_session_map_optimize(
-    logger: &mut dyn Logger,
-    m: HashMap<ConnectorId, SessionInfo>,
-) -> Result<HashMap<ConnectorId, SessionInfo>, ConnectError> {
-    log!(logger, "Session map optimize START");
-    // currently, it's the identity function
-    log!(logger, "Session map optimize END");
-    Ok(m)
-}
-
-// Modify the given connector's internals to reflect
-// the given session info
-fn apply_my_optimizations(
-    cu: &mut ConnectorUnphased,
-    comm: &mut ConnectorCommunication,
-    session_info: SessionInfo,
-) -> Result<(), ConnectError> {
-    let SessionInfo {
-        proto_components,
-        port_info,
-        serde_proto_description,
-        endpoint_incoming_to_getter,
-    } = session_info;
-    // simply overwrite the contents
-    println!("BEFORE: {:#?}\n{:#?}", cu, comm);
-    cu.ips.port_info = port_info;
-    assert!(cu.ips.port_info.invariant_preserved());
-    cu.proto_components = proto_components;
-    cu.proto_description = serde_proto_description.0;
-    for (ee, getter) in comm
-        .endpoint_manager
-        .net_endpoint_store
-        .endpoint_exts
-        .iter_mut()
-        .zip(endpoint_incoming_to_getter)
-    {
-        ee.getter_for_incoming = getter;
-    }
-    // println!("AFTER: {:#?}\n{:#?}", cu, comm);
-    Ok(())
-}