diff --git a/src/protocol/ast.rs b/src/protocol/ast.rs
index 366783b053ed6c8a85674f91b0b58c275f14d058..6b94de786baa4d6499717d8cb2949e119babfe62 100644
--- a/src/protocol/ast.rs
+++ b/src/protocol/ast.rs
@@ -6,19 +6,19 @@ use super::arena::{Arena, Id};
 
 use crate::protocol::inputsource::*;
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct RootId(Id<Root>);
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct PragmaId(Id<Pragma>);
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ImportId(Id<Import>);
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct IdentifierId(Id<Identifier>);
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct SourceIdentifierId(IdentifierId);
 
 impl SourceIdentifierId {
@@ -27,7 +27,7 @@ impl SourceIdentifierId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct ExternalIdentifierId(IdentifierId);
 
 impl ExternalIdentifierId {
@@ -36,13 +36,13 @@ impl ExternalIdentifierId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct TypeAnnotationId(Id<TypeAnnotation>);
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct VariableId(Id<Variable>);
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct ParameterId(VariableId);
 
 impl ParameterId {
@@ -51,7 +51,7 @@ impl ParameterId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct LocalId(VariableId);
 
 impl LocalId {
@@ -63,7 +63,7 @@ impl LocalId {
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct DefinitionId(Id<Definition>);
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ComponentId(DefinitionId);
 
 impl ComponentId {
@@ -72,7 +72,7 @@ impl ComponentId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct FunctionId(DefinitionId);
 
 impl FunctionId {
@@ -81,7 +81,7 @@ impl FunctionId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct CompositeId(ComponentId);
 
 impl CompositeId {
@@ -90,7 +90,7 @@ impl CompositeId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct PrimitiveId(ComponentId);
 
 impl PrimitiveId {
@@ -102,7 +102,7 @@ impl PrimitiveId {
 #[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct StatementId(Id<Statement>);
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct BlockStatementId(StatementId);
 
 impl BlockStatementId {
@@ -111,7 +111,7 @@ impl BlockStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct LocalStatementId(StatementId);
 
 impl LocalStatementId {
@@ -120,7 +120,7 @@ impl LocalStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct MemoryStatementId(LocalStatementId);
 
 impl MemoryStatementId {
@@ -129,7 +129,7 @@ impl MemoryStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ChannelStatementId(LocalStatementId);
 
 impl ChannelStatementId {
@@ -138,7 +138,7 @@ impl ChannelStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct SkipStatementId(StatementId);
 
 impl SkipStatementId {
@@ -147,7 +147,7 @@ impl SkipStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct LabeledStatementId(StatementId);
 
 impl LabeledStatementId {
@@ -156,7 +156,7 @@ impl LabeledStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct IfStatementId(StatementId);
 
 impl IfStatementId {
@@ -165,7 +165,7 @@ impl IfStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct EndIfStatementId(StatementId);
 
 impl EndIfStatementId {
@@ -174,7 +174,7 @@ impl EndIfStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct WhileStatementId(StatementId);
 
 impl WhileStatementId {
@@ -183,7 +183,7 @@ impl WhileStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct EndWhileStatementId(StatementId);
 
 impl EndWhileStatementId {
@@ -192,7 +192,7 @@ impl EndWhileStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct BreakStatementId(StatementId);
 
 impl BreakStatementId {
@@ -201,7 +201,7 @@ impl BreakStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ContinueStatementId(StatementId);
 
 impl ContinueStatementId {
@@ -210,7 +210,7 @@ impl ContinueStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct SynchronousStatementId(StatementId);
 
 impl SynchronousStatementId {
@@ -219,7 +219,7 @@ impl SynchronousStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct EndSynchronousStatementId(StatementId);
 
 impl EndSynchronousStatementId {
@@ -228,7 +228,7 @@ impl EndSynchronousStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ReturnStatementId(StatementId);
 
 impl ReturnStatementId {
@@ -237,7 +237,7 @@ impl ReturnStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct AssertStatementId(StatementId);
 
 impl AssertStatementId {
@@ -246,7 +246,7 @@ impl AssertStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct GotoStatementId(StatementId);
 
 impl GotoStatementId {
@@ -255,7 +255,7 @@ impl GotoStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct NewStatementId(StatementId);
 
 impl NewStatementId {
@@ -264,7 +264,7 @@ impl NewStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct PutStatementId(StatementId);
 
 impl PutStatementId {
@@ -273,7 +273,7 @@ impl PutStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ExpressionStatementId(StatementId);
 
 impl ExpressionStatementId {
@@ -282,10 +282,10 @@ impl ExpressionStatementId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ExpressionId(Id<Expression>);
 
-#[derive(Debug, Clone, Copy, serde::Serialize)]
+#[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 pub struct AssignmentExpressionId(ExpressionId);
 
 impl AssignmentExpressionId {
@@ -294,7 +294,7 @@ impl AssignmentExpressionId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ConditionalExpressionId(ExpressionId);
 
 impl ConditionalExpressionId {
@@ -303,7 +303,7 @@ impl ConditionalExpressionId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct BinaryExpressionId(ExpressionId);
 
 impl BinaryExpressionId {
@@ -312,7 +312,7 @@ impl BinaryExpressionId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct UnaryExpressionId(ExpressionId);
 
 impl UnaryExpressionId {
@@ -321,7 +321,7 @@ impl UnaryExpressionId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct IndexingExpressionId(ExpressionId);
 
 impl IndexingExpressionId {
@@ -330,7 +330,7 @@ impl IndexingExpressionId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct SlicingExpressionId(ExpressionId);
 
 impl SlicingExpressionId {
@@ -339,7 +339,7 @@ impl SlicingExpressionId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct SelectExpressionId(ExpressionId);
 
 impl SelectExpressionId {
@@ -348,7 +348,7 @@ impl SelectExpressionId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ArrayExpressionId(ExpressionId);
 
 impl ArrayExpressionId {
@@ -357,7 +357,7 @@ impl ArrayExpressionId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ConstantExpressionId(ExpressionId);
 
 impl ConstantExpressionId {
@@ -366,7 +366,7 @@ impl ConstantExpressionId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct CallExpressionId(ExpressionId);
 
 impl CallExpressionId {
@@ -375,7 +375,7 @@ impl CallExpressionId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct VariableExpressionId(ExpressionId);
 
 impl VariableExpressionId {
@@ -384,10 +384,10 @@ impl VariableExpressionId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct DeclarationId(Id<Declaration>);
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct DefinedDeclarationId(DeclarationId);
 
 impl DefinedDeclarationId {
@@ -396,7 +396,7 @@ impl DefinedDeclarationId {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ImportedDeclarationId(DeclarationId);
 
 impl ImportedDeclarationId {
@@ -405,7 +405,7 @@ impl ImportedDeclarationId {
     }
 }
 
-#[derive(serde::Serialize)]
+#[derive(serde::Serialize, serde::Deserialize)]
 pub struct Heap {
     // Phase 0: allocation
     protocol_descriptions: Arena<Root>,
@@ -1200,7 +1200,7 @@ impl Index<DeclarationId> for Heap {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Root {
     pub this: RootId,
     // Phase 1: parser
@@ -1245,7 +1245,7 @@ impl SyntaxElement for Root {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Pragma {
     pub this: PragmaId,
     // Phase 1: parser
@@ -1259,7 +1259,7 @@ impl SyntaxElement for Pragma {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Import {
     pub this: ImportId,
     // Phase 1: parser
@@ -1273,7 +1273,7 @@ impl SyntaxElement for Import {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Identifier {
     External(ExternalIdentifier),
     Source(SourceIdentifier),
@@ -1325,7 +1325,7 @@ impl PartialEq<SourceIdentifier> for Identifier {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ExternalIdentifier {
     pub this: ExternalIdentifierId,
     // Phase 1: parser
@@ -1345,7 +1345,7 @@ impl Display for ExternalIdentifier {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct SourceIdentifier {
     pub this: SourceIdentifierId,
     // Phase 1: parser
@@ -1386,7 +1386,7 @@ impl PartialEq<SourceIdentifier> for SourceIdentifier {
 
 type TypeData = Vec<u8>;
 
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum PrimitiveType {
     Input,
     Output,
@@ -1399,7 +1399,7 @@ pub enum PrimitiveType {
     Symbolic(TypeData),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct Type {
     pub primitive: PrimitiveType,
     pub array: bool,
@@ -1466,7 +1466,7 @@ impl Display for Type {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct TypeAnnotation {
     pub this: TypeAnnotationId,
     // Phase 1: parser
@@ -1483,7 +1483,7 @@ impl SyntaxElement for TypeAnnotation {
 type CharacterData = Vec<u8>;
 type IntegerData = Vec<u8>;
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Constant {
     Null, // message
     True,
@@ -1492,7 +1492,7 @@ pub enum Constant {
     Integer(IntegerData),
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Method {
     Get,
     Fires,
@@ -1500,7 +1500,7 @@ pub enum Method {
     Symbolic(SourceIdentifierId),
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Field {
     Length,
     Symbolic(SourceIdentifierId),
@@ -1514,7 +1514,7 @@ impl Field {
     }
 }
 
-#[derive(Debug, Clone, Copy, serde::Serialize)]
+#[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 pub enum Scope {
     Definition(DefinitionId),
     Block(BlockStatementId),
@@ -1552,7 +1552,7 @@ impl VariableScope for Scope {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Variable {
     Parameter(Parameter),
     Local(Local),
@@ -1600,7 +1600,7 @@ impl SyntaxElement for Variable {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Parameter {
     pub this: ParameterId,
     // Phase 1: parser
@@ -1615,7 +1615,7 @@ impl SyntaxElement for Parameter {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Local {
     pub this: LocalId,
     // Phase 1: parser
@@ -1629,7 +1629,7 @@ impl SyntaxElement for Local {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Definition {
     Component(Component),
     Function(Function),
@@ -1703,7 +1703,7 @@ impl VariableScope for Definition {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Component {
     Composite(Composite),
     Primitive(Primitive),
@@ -1757,7 +1757,7 @@ impl SyntaxElement for Component {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Composite {
     pub this: CompositeId,
     // Phase 1: parser
@@ -1773,7 +1773,7 @@ impl SyntaxElement for Composite {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Primitive {
     pub this: PrimitiveId,
     // Phase 1: parser
@@ -1789,7 +1789,7 @@ impl SyntaxElement for Primitive {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Function {
     pub this: FunctionId,
     // Phase 1: parser
@@ -1806,7 +1806,7 @@ impl SyntaxElement for Function {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Declaration {
     Defined(DefinedDeclaration),
     Imported(ImportedDeclaration),
@@ -1836,7 +1836,7 @@ impl Declaration {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct DefinedDeclaration {
     pub this: DefinedDeclarationId,
     // Phase 2: linker
@@ -1844,7 +1844,7 @@ pub struct DefinedDeclaration {
     pub signature: Signature,
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ImportedDeclaration {
     pub this: ImportedDeclarationId,
     // Phase 2: linker
@@ -1852,7 +1852,7 @@ pub struct ImportedDeclaration {
     pub signature: Signature,
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Signature {
     Component(ComponentSignature),
     Function(FunctionSignature),
@@ -1899,20 +1899,20 @@ impl Signature {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ComponentSignature {
     pub identifier: IdentifierId,
     pub arity: Vec<Type>,
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct FunctionSignature {
     pub return_type: Type,
     pub identifier: IdentifierId,
     pub arity: Vec<Type>,
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Statement {
     Block(BlockStatement),
     Local(LocalStatement),
@@ -2149,7 +2149,7 @@ impl SyntaxElement for Statement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct BlockStatement {
     pub this: BlockStatementId,
     // Phase 1: parser
@@ -2210,7 +2210,7 @@ impl VariableScope for BlockStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum LocalStatement {
     Memory(MemoryStatement),
     Channel(ChannelStatement),
@@ -2252,7 +2252,7 @@ impl SyntaxElement for LocalStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct MemoryStatement {
     pub this: MemoryStatementId,
     // Phase 1: parser
@@ -2269,7 +2269,7 @@ impl SyntaxElement for MemoryStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ChannelStatement {
     pub this: ChannelStatementId,
     // Phase 1: parser
@@ -2286,7 +2286,7 @@ impl SyntaxElement for ChannelStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct SkipStatement {
     pub this: SkipStatementId,
     // Phase 1: parser
@@ -2301,7 +2301,7 @@ impl SyntaxElement for SkipStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct LabeledStatement {
     pub this: LabeledStatementId,
     // Phase 1: parser
@@ -2318,7 +2318,7 @@ impl SyntaxElement for LabeledStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct IfStatement {
     pub this: IfStatementId,
     // Phase 1: parser
@@ -2334,7 +2334,7 @@ impl SyntaxElement for IfStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct EndIfStatement {
     pub this: EndIfStatementId,
     // Phase 2: linker
@@ -2348,7 +2348,7 @@ impl SyntaxElement for EndIfStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct WhileStatement {
     pub this: WhileStatementId,
     // Phase 1: parser
@@ -2366,7 +2366,7 @@ impl SyntaxElement for WhileStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct EndWhileStatement {
     pub this: EndWhileStatementId,
     // Phase 2: linker
@@ -2380,7 +2380,7 @@ impl SyntaxElement for EndWhileStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct BreakStatement {
     pub this: BreakStatementId,
     // Phase 1: parser
@@ -2396,7 +2396,7 @@ impl SyntaxElement for BreakStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ContinueStatement {
     pub this: ContinueStatementId,
     // Phase 1: parser
@@ -2412,7 +2412,7 @@ impl SyntaxElement for ContinueStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct SynchronousStatement {
     pub this: SynchronousStatementId,
     // Phase 1: parser
@@ -2443,7 +2443,7 @@ impl VariableScope for SynchronousStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct EndSynchronousStatement {
     pub this: EndSynchronousStatementId,
     // Phase 2: linker
@@ -2457,7 +2457,7 @@ impl SyntaxElement for EndSynchronousStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ReturnStatement {
     pub this: ReturnStatementId,
     // Phase 1: parser
@@ -2471,7 +2471,7 @@ impl SyntaxElement for ReturnStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct AssertStatement {
     pub this: AssertStatementId,
     // Phase 1: parser
@@ -2487,7 +2487,7 @@ impl SyntaxElement for AssertStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct GotoStatement {
     pub this: GotoStatementId,
     // Phase 1: parser
@@ -2503,7 +2503,7 @@ impl SyntaxElement for GotoStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct NewStatement {
     pub this: NewStatementId,
     // Phase 1: parser
@@ -2519,7 +2519,7 @@ impl SyntaxElement for NewStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct PutStatement {
     pub this: PutStatementId,
     // Phase 1: parser
@@ -2536,7 +2536,7 @@ impl SyntaxElement for PutStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ExpressionStatement {
     pub this: ExpressionStatementId,
     // Phase 1: parser
@@ -2552,7 +2552,7 @@ impl SyntaxElement for ExpressionStatement {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Expression {
     Assignment(AssignmentExpression),
     Conditional(ConditionalExpression),
@@ -2666,7 +2666,7 @@ impl SyntaxElement for Expression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum AssignmentOperator {
     Set,
     Multiplied,
@@ -2681,7 +2681,7 @@ pub enum AssignmentOperator {
     BitwiseOred,
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct AssignmentExpression {
     pub this: AssignmentExpressionId,
     // Phase 1: parser
@@ -2697,7 +2697,7 @@ impl SyntaxElement for AssignmentExpression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ConditionalExpression {
     pub this: ConditionalExpressionId,
     // Phase 1: parser
@@ -2713,7 +2713,7 @@ impl SyntaxElement for ConditionalExpression {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum BinaryOperator {
     Concatenate,
     LogicalOr,
@@ -2736,7 +2736,7 @@ pub enum BinaryOperator {
     Remainder,
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct BinaryExpression {
     pub this: BinaryExpressionId,
     // Phase 1: parser
@@ -2752,7 +2752,7 @@ impl SyntaxElement for BinaryExpression {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub enum UnaryOperation {
     Positive,
     Negative,
@@ -2764,7 +2764,7 @@ pub enum UnaryOperation {
     PostDecrement,
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct UnaryExpression {
     pub this: UnaryExpressionId,
     // Phase 1: parser
@@ -2779,7 +2779,7 @@ impl SyntaxElement for UnaryExpression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct IndexingExpression {
     pub this: IndexingExpressionId,
     // Phase 1: parser
@@ -2794,7 +2794,7 @@ impl SyntaxElement for IndexingExpression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct SlicingExpression {
     pub this: SlicingExpressionId,
     // Phase 1: parser
@@ -2810,7 +2810,7 @@ impl SyntaxElement for SlicingExpression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct SelectExpression {
     pub this: SelectExpressionId,
     // Phase 1: parser
@@ -2825,7 +2825,7 @@ impl SyntaxElement for SelectExpression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ArrayExpression {
     pub this: ArrayExpressionId,
     // Phase 1: parser
@@ -2839,7 +2839,7 @@ impl SyntaxElement for ArrayExpression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct CallExpression {
     pub this: CallExpressionId,
     // Phase 1: parser
@@ -2856,7 +2856,7 @@ impl SyntaxElement for CallExpression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ConstantExpression {
     pub this: ConstantExpressionId,
     // Phase 1: parser
@@ -2870,7 +2870,7 @@ impl SyntaxElement for ConstantExpression {
     }
 }
 
-#[derive(Debug, Clone, serde::Serialize)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct VariableExpression {
     pub this: VariableExpressionId,
     // Phase 1: parser
diff --git a/src/protocol/inputsource.rs b/src/protocol/inputsource.rs
index b8765bdaa60f6683987229590074972e5a8d0dd6..8f1801d8b74e282ca0e8db7d5fde44b3462d9d56 100644
--- a/src/protocol/inputsource.rs
+++ b/src/protocol/inputsource.rs
@@ -5,7 +5,7 @@ use std::path::Path;
 
 use backtrace::Backtrace;
 
-#[derive(Clone, serde::Serialize)]
+#[derive(Clone, serde::Serialize, serde::Deserialize)]
 pub struct InputSource {
     filename: String,
     input: Vec<u8>,
@@ -120,7 +120,7 @@ impl fmt::Display for InputSource {
     }
 }
 
-#[derive(Debug, Clone, Copy, Default, serde::Serialize)]
+#[derive(Debug, Clone, Copy, Default, serde::Serialize, serde::Deserialize)]
 pub struct InputPosition {
     line: usize,
     column: usize,
diff --git a/src/protocol/mod.rs b/src/protocol/mod.rs
index b07b410ed8904d46c4b368c3901aebedaa340698..053695195dcba4e66bf3115f31c25a8118ba0572 100644
--- a/src/protocol/mod.rs
+++ b/src/protocol/mod.rs
@@ -12,7 +12,7 @@ use crate::protocol::eval::*;
 use crate::protocol::inputsource::*;
 use crate::protocol::parser::*;
 
-#[derive(serde::Serialize)]
+#[derive(serde::Serialize, serde::Deserialize)]
 pub struct ProtocolDescriptionImpl {
     heap: Heap,
     source: InputSource,
@@ -82,6 +82,7 @@ impl ProtocolDescription for ProtocolDescriptionImpl {
         }
         Ok(result)
     }
+    // expects port polarities to be correct
     fn new_main_component(&self, identifier: &[u8], ports: &[Port]) -> ComponentStateImpl {
         let mut args = Vec::new();
         for (&x, y) in ports.iter().zip(self.component_polarities(identifier).unwrap()) {
diff --git a/src/runtime/experimental/mod.rs b/src/runtime/experimental/mod.rs
index b0a0a8a00dce44f7f0a4a67c11859b9bdbe49c15..b7882ebf608663b00d91a7f37c681971f1e5b9e4 100644
--- a/src/runtime/experimental/mod.rs
+++ b/src/runtime/experimental/mod.rs
@@ -1,3 +1,4 @@
-mod api;
-mod bits;
-mod vec_storage;
+// mod api;
+// mod bits;
+mod pdl;
+// mod vec_storage;
diff --git a/src/runtime/experimental/pdl.rs b/src/runtime/experimental/pdl.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0f2d07cbbc6af35251da6794fd5fb9b624c58b2c
--- /dev/null
+++ b/src/runtime/experimental/pdl.rs
@@ -0,0 +1,46 @@
+use crate::common::Port;
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+struct Pdl {
+    ops: Vec<Op>,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+enum Op {
+    JumpIfEq,  //
+    SyncStart, //
+    SyncEnd,   //
+    Exit,      //
+    Firing,    // pop port A. push bool B.
+    Put,       // pop port A. pop payload B.
+    Get,       // pop port A. push payload B.
+    //
+    PushConst(Value),
+    Store, // pop unslong A. pop B. store[A] := B.
+    Load,  // pop unslong A. push store[A].
+    Dup,   // pop A. push A. push A.
+    //
+    Lt,  // pop A. pop B. push bool C.
+    Eq,  // pop A. pop B. push bool C.
+    Add, // pop integer A. pop integer B. push A+B
+    Neg, // pop signed integer A. push -A.
+    //
+    Nand, // pop bool A. pop bool B. push nand(A,B)
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+struct State {
+    op_index: usize,
+    store: Vec<Value>, // TODO multiple frames
+    stack: Vec<Value>,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+enum Value {
+    Null,
+    Int(i32),
+    Bool(bool),
+    UnsLong(u64),
+    Payload(Vec<u8>),
+    Port(Port),
+}
diff --git a/src/runtime/mod.rs b/src/runtime/mod.rs
index 5fb8c4dfa236e3250a0bec7bf883888c283913c0..e33c900e34e8c07738ec7b82234d58841469ba2f 100644
--- a/src/runtime/mod.rs
+++ b/src/runtime/mod.rs
@@ -6,9 +6,9 @@ pub(crate) mod communication;
 pub(crate) mod connector;
 pub(crate) mod endpoint;
 pub mod errors;
-// pub mod experimental;
 mod serde;
 pub(crate) mod setup;
+// mod v2;
 
 pub(crate) type ProtocolD = crate::protocol::ProtocolDescriptionImpl;
 pub(crate) type ProtocolS = crate::protocol::ComponentStateImpl;
@@ -42,7 +42,7 @@ struct SyncBatch {
 pub enum Connector {
     Unconfigured(Unconfigured),
     Configured(Configured),
-    Connected(Connected), // TODO consider boxing. currently takes up a lot of stack real estate
+    Connected(Connected), // TODO consider boxing. currently takes up a lot of stack space
 }
 #[derive(Debug)]
 pub struct Unconfigured {
diff --git a/src/runtime/v2.rs b/src/runtime/v2.rs
new file mode 100644
index 0000000000000000000000000000000000000000..610036ae0e4477f6581fade79ea3e32775880d80
--- /dev/null
+++ b/src/runtime/v2.rs
@@ -0,0 +1,262 @@
+use crate::common::*;
+use crate::runtime::endpoint::Endpoint;
+use crate::runtime::endpoint::Msg;
+use crate::runtime::ProtocolD;
+use crate::runtime::ProtocolS;
+use std::io::Write;
+
+#[derive(Default)]
+struct IntStream {
+    next: u32,
+}
+struct IdManager {
+    controller_id: ControllerId,
+    port_suffix_stream: IntStream,
+}
+
+struct ProtoComponent {
+    state: ProtocolS,
+    ports: HashSet<PortId>,
+}
+enum InpRoute {
+    NativeComponent,
+    ProtoComponent { index: usize },
+    Endpoint { index: usize },
+}
+trait Logger {
+    fn line_writer(&mut self) -> &mut dyn Write;
+}
+#[derive(Clone)]
+struct EndpointSetup {
+    polarity: Polarity,
+    sock_addr: SocketAddr,
+    is_active: bool,
+}
+struct EndpointExt {
+    net_endpoint: Endpoint,
+    // data-messages emerging from this endpoint are destined for this inp
+    inp: Port,
+}
+struct Neighborhood {
+    parent: Option<usize>,
+    children: Vec<usize>, // ordered, deduplicated
+}
+struct MemInMsg {
+    inp: Port,
+    msg: Payload,
+}
+struct EndpointPoller {
+    poll: Poll,
+    events: Events,
+    undrained_endpoints: HashSet<usize>,
+    delayed_inp_messages: Vec<(Port, Msg)>,
+}
+struct Connector {
+    logger: Box<dyn Logger>,
+    proto_description: Arc<ProtocolD>,
+    id_manager: IdManager,
+    native_ports: HashSet<PortId>,
+    proto_components: Vec<ProtoComponent>,
+    outp_to_inp: HashMap<PortId, PortId>,
+    inp_to_route: HashMap<PortId, InpRoute>,
+    phased: ConnectorPhased,
+}
+enum ConnectorPhased {
+    Setup {
+        endpoint_setups: Vec<(PortId, EndpointSetup)>,
+        surplus_sockets: u16,
+    },
+    Communication {
+        endpoint_poller: EndpointPoller,
+        endpoint_exts: Vec<EndpointExt>,
+        neighborhood: Neighborhood,
+        mem_inbox: Vec<MemInMsg>,
+    },
+}
+/////////////////////////////
+impl IntStream {
+    fn next(&mut self) -> u32 {
+        if self.next == u32::MAX {
+            panic!("NO NEXT!")
+        }
+        self.next += 1;
+        self.next - 1
+    }
+}
+impl IdManager {
+    fn next_port(&mut self) -> PortId {
+        let port_suffix = self.port_suffix_stream.next();
+        let controller_id = self.controller_id;
+        PortId { controller_id, port_index: port_suffix }
+    }
+    fn new(controller_id: ControllerId) -> Self {
+        Self { controller_id, port_suffix_stream: Default::default() }
+    }
+}
+impl Connector {
+    pub fn new(
+        logger: Box<dyn Logger>,
+        proto_description: Arc<ProtocolD>,
+        controller_id: ControllerId,
+        surplus_sockets: u16,
+    ) -> Self {
+        Self {
+            logger,
+            proto_description,
+            id_manager: IdManager::new(controller_id),
+            native_ports: Default::default(),
+            proto_components: Default::default(),
+            outp_to_inp: Default::default(),
+            inp_to_route: Default::default(),
+            phased: ConnectorPhased::Setup { endpoint_setups: Default::default(), surplus_sockets },
+        }
+    }
+    pub fn add_port_pair(&mut self) -> [PortId; 2] {
+        let o = self.id_manager.next_port();
+        let i = self.id_manager.next_port();
+        self.outp_to_inp.insert(o, i);
+        self.native_ports.insert(o);
+        self.native_ports.insert(i);
+        [o, i]
+    }
+    pub fn add_net_port(&mut self, endpoint_setup: EndpointSetup) -> Result<PortId, ()> {
+        match &mut self.phased {
+            ConnectorPhased::Setup { endpoint_setups, .. } => {
+                let p = self.id_manager.next_port();
+                endpoint_setups.push((p, endpoint_setup));
+                Ok(p)
+            }
+            ConnectorPhased::Communication { .. } => Err(()),
+        }
+    }
+    fn check_polarity(&self, port: &PortId) -> Polarity {
+        if self.outp_to_inp.contains_key(port) {
+            Polarity::Putter
+        } else {
+            assert!(self.inp_to_route.contains_key(port));
+            Polarity::Getter
+        }
+    }
+    pub fn add_proto_component(&mut self, identifier: &[u8], ports: &[PortId]) -> Result<(), ()> {
+        let polarities = self.proto_description.component_polarities(identifier).map_err(drop)?;
+        if polarities.len() != ports.len() {
+            return Err(());
+        }
+        for (&expected_polarity, port) in polarities.iter().zip(ports.iter()) {
+            if !self.native_ports.contains(port) {
+                return Err(());
+            }
+            if expected_polarity != self.check_polarity(port) {
+                return Err(());
+            }
+        }
+        // ok!
+        let state = self.proto_description.new_main_component(identifier, ports);
+        let proto_component = ProtoComponent { ports: ports.iter().copied().collect(), state };
+        let proto_component_index = self.proto_components.len();
+        self.proto_components.push(proto_component);
+        for port in ports.iter() {
+            if let Polarity::Getter = self.check_polarity(port) {
+                self.inp_to_route
+                    .insert(*port, InpRoute::ProtoComponent { index: proto_component_index });
+            }
+        }
+        Ok(())
+    }
+    pub fn connect(&mut self, timeout: Duration) -> Result<(), ()> {
+        match &mut self.phased {
+            ConnectorPhased::Communication { .. } => Err(()),
+            ConnectorPhased::Setup { endpoint_setups, surplus_sockets } => {
+                // connect all endpoints in parallel; send and receive peer ids through ports
+                let (mut endpoint_exts, mut endpoint_poller) =
+                    init_endpoints(endpoint_setups, timeout)?;
+                write!(
+                    self.logger.line_writer(),
+                    "hello! I am controller_id:{}",
+                    self.id_manager.controller_id
+                );
+                // leader election and tree construction
+                let neighborhood = init_neighborhood(&mut endpoint_exts, &mut endpoint_poller)?;
+                // TODO session optimization goes here
+                self.phased = ConnectorPhased::Communication {
+                    endpoint_poller,
+                    endpoint_exts,
+                    neighborhood,
+                    mem_inbox: Default::default(),
+                };
+                Ok(())
+            }
+        }
+    }
+}
+
+fn init_endpoints(
+    endpoint_setups: &[(PortId, EndpointSetup)],
+    timeout: Duration,
+) -> Result<(Vec<EndpointExt>, EndpointPoller), ()> {
+    let mut endpoint_poller = EndpointPoller {
+        poll: Poll::new().map_err(drop)?,
+        events: Events::with_capacity(64),
+        undrained_endpoints: Default::default(),
+        delayed_inp_messages: Default::default(),
+    };
+    const PORT_ID_LEN: usize = std::mem::size_of::<PortId>();
+    enum MaybeRecvPort {
+        Complete(Port),
+        Partial { buf: [u8; PORT_ID_LEN], read: u8 },
+    }
+    struct Todo {
+        endpoint: TodoEndpoint,
+        polarity: Polarity,
+        local_port: Port,
+        sent_local_port: bool,
+        recv_peer_port: MaybeRecvPort,
+    }
+    enum TodoEndpoint {
+        Listener(mio::net::TcpListener),
+        Stream(mio::net::TcpStream),
+    }
+    const BOTH: mio::Interest = mio::Interest::READABLE.add(mio::Interest::WRITABLE);
+    fn init(
+        token: Token,
+        local_port: Port,
+        endpoint_setup: &EndpointSetup,
+        poll: &mut Poll,
+    ) -> Result<Todo, ()> {
+        let endpoint = if endpoint_setup.is_active {
+            let mut stream =
+                mio::net::TcpStream::connect(&endpoint_setup.sock_addr).map_err(drop)?;
+            poll.registry().register(&mut stream, token, BOTH).unwrap();
+            TodoEndpoint::Stream(stream)
+        } else {
+            let mut listener =
+                mio::net::TcpListener::bind(&endpoint_setup.sock_addr).map_err(drop)?;
+            poll.registry().register(&mut listener, token, BOTH).unwrap();
+            TodoEndpoint::Listener(listener)
+        };
+        Ok(Todo {
+            endpoint,
+            endpoint_setup: endpoint_setup.clone(),
+            local_port,
+            sent_local_port: false,
+            recv_peer_port: MaybeRecvPort::Partial { buf: [0; 8], read: 0 },
+        })
+    };
+
+    let todos = endpoint_setups
+        .iter()
+        .enumerate()
+        .map(|(index, (local_port, endpoint_setup))| {
+            init(Token(index), local_port, endpoint_setup, &mut endpoint_poller.poll)
+        })
+        .collect::<Result<Vec<Todo>, _>>()?;
+    let endpoint_exts = vec![];
+    Ok((endpoint_exts, endpoint_poller))
+}
+
+fn init_neighborhood(
+    endpoint_exts: &mut [EndpointExt],
+    endpoint_poller: &mut EndpointPoller,
+) -> Result<Neighborhood, ()> {
+    todo!()
+}