diff --git a/service/api/service.go b/service/api/service.go
index e489518e..8ab7eb26 100644
--- a/service/api/service.go
+++ b/service/api/service.go
@@ -98,7 +98,7 @@ func (s *service) createDocument(w http.ResponseWriter, req *http.Request) {
 		query = req.URL.Query()
 		text  = query.Get("text")
 	)
-	timeoutCtx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	timeoutCtx, cancel := context.WithTimeout(context.Background(), time.Second*30)
 	treeId, err := s.documentService.CreateDocument(timeoutCtx, fmt.Sprintf("created document with id: %s", text))
 	cancel()
 	if err != nil {
@@ -114,7 +114,7 @@ func (s *service) appendDocument(w http.ResponseWriter, req *http.Request) {
 		text   = query.Get("text")
 		treeId = query.Get("treeId")
 	)
-	timeoutCtx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	timeoutCtx, cancel := context.WithTimeout(context.Background(), time.Second*30)
 	err := s.documentService.UpdateDocument(timeoutCtx, treeId, text)
 	cancel()
 	if err != nil {
diff --git a/service/net/pool/message.go b/service/net/pool/message.go
index bc067a12..e6cb38fe 100644
--- a/service/net/pool/message.go
+++ b/service/net/pool/message.go
@@ -3,6 +3,7 @@ package pool
 import (
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/peer"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/syncproto"
+	"go.uber.org/zap"
 	"gopkg.in/mgo.v2/bson"
 )
 
@@ -43,6 +44,7 @@ func (m *Message) Ack() (err error) {
 		},
 		Data: data,
 	}
+	log.With(zap.String("header", rep.Header.String())).Info("sending ack to peer")
 	return m.peer.Send(rep)
 }
 
diff --git a/service/net/pool/pool.go b/service/net/pool/pool.go
index fe57e16c..f4aa266f 100644
--- a/service/net/pool/pool.go
+++ b/service/net/pool/pool.go
@@ -15,7 +15,10 @@ import (
 	"sync/atomic"
 )
 
-const CName = "sync/peerPool"
+const (
+	CName                              = "sync/peerPool"
+	maxSimultaneousOperationsPerStream = 10
+)
 
 var log = logger.NewNamed("peerPool")
 
@@ -45,7 +48,7 @@ type Pool interface {
 
 type pool struct {
 	peersById       map[string]*peerEntry
-	waiters         waiters
+	waiters         *waiters
 	handlers        map[syncproto.MessageType][]Handler
 	peersIdsByGroup map[string][]string
 
@@ -60,7 +63,7 @@ func (p *pool) Init(ctx context.Context, a *app.App) (err error) {
 	p.peersById = map[string]*peerEntry{}
 	p.handlers = map[syncproto.MessageType][]Handler{}
 	p.peersIdsByGroup = map[string][]string{}
-	p.waiters = waiters{waiters: map[uint64]*waiter{}}
+	p.waiters = &waiters{waiters: map[uint64]*waiter{}}
 	p.dialer = a.MustComponent(dialer.CName).(dialer.Dialer)
 	p.wg = &sync.WaitGroup{}
 	return nil
@@ -160,6 +163,7 @@ func (p *pool) SendAndWait(ctx context.Context, peerId string, msg *syncproto.Me
 	repId := p.waiters.NewReplyId()
 	msg.GetHeader().RequestId = repId
 	ch := make(chan Reply, 1)
+	log.With(zap.Uint64("reply id", repId)).Debug("adding waiter for reply id")
 	p.waiters.Add(repId, &waiter{ch: ch})
 	defer p.waiters.Remove(repId)
 	if err = peer.peer.Send(msg); err != nil {
@@ -172,24 +176,41 @@ func (p *pool) SendAndWait(ctx context.Context, peerId string, msg *syncproto.Me
 		}
 		return nil
 	case <-ctx.Done():
+		log.Debug("context error happened in send and wait")
 		return ctx.Err()
 	}
 }
 
 func (p *pool) Broadcast(ctx context.Context, groupId string, msg *syncproto.Message) (err error) {
+
 	//TODO implement me
 	panic("implement me")
 }
 
 func (p *pool) readPeerLoop(peer peer.Peer) (err error) {
 	defer p.wg.Done()
+	limiter := make(chan struct{}, maxSimultaneousOperationsPerStream)
+	for i := 0; i < maxSimultaneousOperationsPerStream; i++ {
+		limiter <- struct{}{}
+	}
+Loop:
 	for {
 		msg, err := peer.Recv()
 		if err != nil {
 			log.Debug("peer receive error", zap.Error(err), zap.String("peerId", peer.Id()))
 			break
 		}
-		p.handleMessage(peer, msg)
+		select {
+		case <-limiter:
+		case <-peer.Context().Done():
+			break Loop
+		}
+		go func() {
+			defer func() {
+				limiter <- struct{}{}
+			}()
+			p.handleMessage(peer, msg)
+		}()
 	}
 	if err = p.removePeer(peer.Id()); err != nil {
 		log.Error("remove peer error", zap.String("peerId", peer.Id()))
@@ -209,7 +230,8 @@ func (p *pool) removePeer(peerId string) (err error) {
 }
 
 func (p *pool) handleMessage(peer peer.Peer, msg *syncproto.Message) {
-	log.With(zap.String("peerId", peer.Id())).Debug("received message from peer")
+	log.With(zap.String("peerId", peer.Id()), zap.String("header", msg.GetHeader().String())).
+		Debug("received message from peer")
 	replyId := msg.GetHeader().GetReplyId()
 	if replyId != 0 {
 		if !p.waiters.Send(replyId, Reply{
@@ -219,7 +241,7 @@ func (p *pool) handleMessage(peer peer.Peer, msg *syncproto.Message) {
 				peer:    peer,
 			},
 		}) {
-			log.Debug("received reply with unknown (or expired) replyId", zap.Uint64("replyId", replyId))
+			log.Debug("received reply with unknown (or expired) replyId", zap.Uint64("replyId", replyId), zap.String("header", msg.GetHeader().String()))
 		}
 		return
 	}
@@ -262,7 +284,7 @@ type waiters struct {
 	mu       sync.Mutex
 }
 
-func (w waiters) Send(replyId uint64, r Reply) (ok bool) {
+func (w *waiters) Send(replyId uint64, r Reply) (ok bool) {
 	w.mu.Lock()
 	wait := w.waiters[replyId]
 	if wait == nil {
@@ -282,13 +304,13 @@ func (w waiters) Send(replyId uint64, r Reply) (ok bool) {
 	return true
 }
 
-func (w waiters) Add(replyId uint64, wait *waiter) {
+func (w *waiters) Add(replyId uint64, wait *waiter) {
 	w.mu.Lock()
 	w.waiters[replyId] = wait
 	w.mu.Unlock()
 }
 
-func (w waiters) Remove(id uint64) error {
+func (w *waiters) Remove(id uint64) error {
 	w.mu.Lock()
 	defer w.mu.Unlock()
 	if _, ok := w.waiters[id]; ok {
@@ -298,7 +320,7 @@ func (w waiters) Remove(id uint64) error {
 	return fmt.Errorf("waiter not found")
 }
 
-func (w waiters) NewReplyId() uint64 {
+func (w *waiters) NewReplyId() uint64 {
 	res := atomic.AddUint64(&w.replySeq, 1)
 	if res == 0 {
 		return w.NewReplyId()
diff --git a/service/sync/message/service.go b/service/sync/message/service.go
index 12c3a844..44e7e68c 100644
--- a/service/sync/message/service.go
+++ b/service/sync/message/service.go
@@ -63,6 +63,9 @@ func (s *service) HandleMessage(ctx context.Context, msg *pool.Message) (err err
 	if err != nil {
 		log.With(zap.String("peerId", msg.Peer().Id()), zap.Error(err)).
 			Error("could not ack message")
+	} else {
+		log.With(zap.String("peerId", msg.Peer().Id()), zap.Int("type", int(msg.Header.Type))).
+			Debug("ack returned")
 	}
 	syncMsg := &syncproto.Sync{}
 	err = proto.Unmarshal(msg.Data, syncMsg)
@@ -70,7 +73,7 @@ func (s *service) HandleMessage(ctx context.Context, msg *pool.Message) (err err
 		return err
 	}
 
-	timeoutCtx, cancel := context.WithTimeout(ctx, time.Second*5)
+	timeoutCtx, cancel := context.WithTimeout(ctx, time.Second*30)
 	defer cancel()
 	return s.requestHandler.HandleSyncMessage(timeoutCtx, msg.Peer().Id(), syncMsg)
 }
@@ -95,50 +98,26 @@ func (s *service) SendMessage(ctx context.Context, peerId string, msg *syncproto
 		Header: &syncproto.Header{Type: syncproto.MessageType_MessageTypeSync},
 		Data:   marshalled,
 	})
+
 	if err != nil {
 		log.With(
 			zap.String("peerId", peerId),
 			zap.String("message", msgType(msg)),
 			zap.Error(err)).
-			Error("failed to send message to peer")
+			Debug("failed to send message to peer")
+	} else {
+		log.With(
+			zap.String("peerId", peerId),
+			zap.String("message", msgType(msg))).
+			Debug("message send to peer completed")
 	}
 	return err
 }
 
 func (s *service) SendToSpace(ctx context.Context, spaceId string, msg *syncproto.Sync) error {
-	// dial manually to all peers
 	for _, rp := range s.nodes {
-		if er := s.pool.DialAndAddPeer(context.Background(), rp.PeerId); er != nil {
-			log.Info("can't dial to peer", zap.Error(er))
-		} else {
-			log.Info("connected with peer", zap.String("peerId", rp.PeerId))
-		}
+		s.SendMessage(ctx, rp.PeerId, msg)
 	}
-
-	marshalled, err := proto.Marshal(msg)
-	if err != nil {
-		return err
-	}
-
-	// TODO: use Broadcast method here when it is ready
-	for _, n := range s.nodes {
-		log.With(
-			zap.String("peerId", n.PeerId),
-			zap.String("message", msgType(msg))).
-			Debug("sending message to peer")
-		err := s.pool.SendAndWait(ctx, n.PeerId, &syncproto.Message{
-			Header: &syncproto.Header{Type: syncproto.MessageType_MessageTypeSync},
-			Data:   marshalled,
-		})
-		if err != nil {
-			log.With(
-				zap.String("peerId", n.PeerId),
-				zap.String("message", msgType(msg)),
-				zap.Error(err)).
-				Error("failed to send message to peer")
-		}
-	}
-
 	return nil
 }
 
diff --git a/service/sync/requesthandler/requesthandler.go b/service/sync/requesthandler/requesthandler.go
index 0c1bad55..cce5ab0b 100644
--- a/service/sync/requesthandler/requesthandler.go
+++ b/service/sync/requesthandler/requesthandler.go
@@ -164,7 +164,7 @@ func (r *requestHandler) HandleFullSyncRequest(ctx context.Context, senderId str
 		TreeId:       request.TreeId,
 		TreeHeader:   request.TreeHeader,
 	}
-	return r.messageService.SendToSpace(ctx, "", syncproto.WrapHeadUpdate(newUpdate))
+	return r.messageService.SendToSpace(ctx, "def", syncproto.WrapHeadUpdate(newUpdate))
 }
 
 func (r *requestHandler) HandleFullSyncResponse(ctx context.Context, senderId string, response *syncproto.SyncFullResponse) (err error) {
diff --git a/service/treecache/service.go b/service/treecache/service.go
index 14a011a9..687300f0 100644
--- a/service/treecache/service.go
+++ b/service/treecache/service.go
@@ -15,6 +15,7 @@ import (
 
 const CName = "treecache"
 
+// TODO: add context
 type ACLTreeFunc = func(tree acltree.ACLTree) error
 type ChangeBuildFunc = func(builder acltree.ChangeBuilder) error
 
diff --git a/syncproto/proto/sync.proto b/syncproto/proto/sync.proto
index 1aa39e1a..284d6a34 100644
--- a/syncproto/proto/sync.proto
+++ b/syncproto/proto/sync.proto
@@ -15,6 +15,7 @@ message Header {
     uint64 requestId = 2;
     uint64 replyId = 3;
     MessageType type = 4;
+    string debugInfo = 5;
 }
 
 enum MessageType {
diff --git a/syncproto/sync.pb.go b/syncproto/sync.pb.go
index a002c37d..64ce8676 100644
--- a/syncproto/sync.pb.go
+++ b/syncproto/sync.pb.go
@@ -134,6 +134,7 @@ type Header struct {
 	RequestId uint64      `protobuf:"varint,2,opt,name=requestId,proto3" json:"requestId,omitempty"`
 	ReplyId   uint64      `protobuf:"varint,3,opt,name=replyId,proto3" json:"replyId,omitempty"`
 	Type      MessageType `protobuf:"varint,4,opt,name=type,proto3,enum=anytype.MessageType" json:"type,omitempty"`
+	DebugInfo string      `protobuf:"bytes,5,opt,name=debugInfo,proto3" json:"debugInfo,omitempty"`
 }
 
 func (m *Header) Reset()         { *m = Header{} }
@@ -197,6 +198,13 @@ func (m *Header) GetType() MessageType {
 	return MessageType_MessageTypeSystem
 }
 
+func (m *Header) GetDebugInfo() string {
+	if m != nil {
+		return m.DebugInfo
+	}
+	return ""
+}
+
 type System struct {
 	Handshake *SystemHandshake `protobuf:"bytes,1,opt,name=handshake,proto3" json:"handshake,omitempty"`
 	Ping      *SystemPing      `protobuf:"bytes,2,opt,name=ping,proto3" json:"ping,omitempty"`
@@ -1020,61 +1028,62 @@ func init() {
 func init() { proto.RegisterFile("syncproto/proto/sync.proto", fileDescriptor_4b28dfdd48a89166) }
 
 var fileDescriptor_4b28dfdd48a89166 = []byte{
-	// 851 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0x41, 0x8f, 0xdb, 0x44,
-	0x14, 0xb6, 0x13, 0x27, 0x6e, 0x5e, 0xa2, 0xac, 0x99, 0xb6, 0x60, 0xdc, 0x2a, 0x8a, 0xac, 0x02,
-	0x51, 0xa9, 0xbc, 0x55, 0xa0, 0x42, 0xe2, 0xd6, 0x2e, 0xbb, 0x4a, 0x44, 0x49, 0xa2, 0x49, 0xb2,
-	0x48, 0x5c, 0xaa, 0x59, 0x7b, 0x48, 0xa2, 0x78, 0xc7, 0xc6, 0xe3, 0x00, 0xb9, 0x73, 0xe2, 0xd4,
-	0x1f, 0x83, 0x04, 0xe2, 0x17, 0x70, 0xec, 0x91, 0x23, 0xda, 0x95, 0xf8, 0x11, 0x70, 0xa9, 0x66,
-	0xc6, 0x4e, 0xbc, 0x6e, 0xfa, 0x03, 0x7a, 0xd8, 0xcd, 0xbc, 0xef, 0x7d, 0xdf, 0x9b, 0xef, 0x8d,
-	0x3d, 0x2f, 0x01, 0x87, 0x6f, 0x99, 0x1f, 0x27, 0x51, 0x1a, 0x1d, 0xab, 0xff, 0x22, 0xf6, 0xe4,
-	0x12, 0x99, 0x84, 0x6d, 0xd3, 0x6d, 0x4c, 0x9d, 0xc7, 0xf1, 0x7a, 0x71, 0x4c, 0xfc, 0x50, 0xfc,
-	0xf9, 0x4b, 0xc2, 0x16, 0x94, 0x8b, 0x65, 0x7c, 0xa1, 0x34, 0xbc, 0x80, 0x2b, 0xa9, 0xf3, 0x28,
-	0x57, 0xa4, 0x09, 0xa5, 0x3c, 0x8d, 0x12, 0xb2, 0xa0, 0x72, 0xbd, 0xd7, 0x88, 0x48, 0xb1, 0xdd,
-	0x33, 0x30, 0xbf, 0xa1, 0x9c, 0x93, 0x05, 0x45, 0x9f, 0x40, 0x7d, 0x49, 0x49, 0x40, 0x13, 0x5b,
-	0xef, 0xea, 0xbd, 0x66, 0xff, 0xc8, 0xcb, 0x4c, 0x78, 0x03, 0x09, 0xe3, 0x2c, 0x8d, 0x10, 0x18,
-	0x01, 0x49, 0x89, 0x5d, 0xe9, 0xea, 0xbd, 0x16, 0x96, 0x6b, 0xf7, 0x17, 0x1d, 0xea, 0x8a, 0x86,
-	0x6c, 0x30, 0xd3, 0x84, 0xf8, 0x74, 0x18, 0xc8, 0x42, 0x2d, 0x9c, 0x87, 0xe8, 0x3e, 0x34, 0x12,
-	0xfa, 0xc3, 0x86, 0xf2, 0x74, 0x18, 0x48, 0xb5, 0x81, 0xf7, 0x80, 0xd0, 0x25, 0x34, 0x0e, 0xb7,
-	0xc3, 0xc0, 0xae, 0xca, 0x5c, 0x1e, 0xa2, 0x1e, 0x18, 0xc2, 0x87, 0x6d, 0x74, 0xf5, 0x5e, 0xbb,
-	0x7f, 0x67, 0xe7, 0x2b, 0x73, 0x3e, 0xdb, 0xc6, 0x14, 0x4b, 0x86, 0xfb, 0x5b, 0x15, 0xea, 0xd3,
-	0x2d, 0x4f, 0xe9, 0x25, 0xfa, 0x02, 0x1a, 0x4b, 0xc2, 0x02, 0xbe, 0x24, 0x6b, 0x9a, 0x75, 0xf4,
-	0xe1, 0x4e, 0xa9, 0x38, 0xde, 0x20, 0x27, 0xe0, 0x3d, 0x57, 0xec, 0x16, 0xaf, 0xd8, 0x42, 0x1a,
-	0x6c, 0x16, 0x76, 0xcb, 0x34, 0x93, 0x15, 0x5b, 0x60, 0xc9, 0x40, 0x1f, 0x41, 0x95, 0xf8, 0x6b,
-	0xe9, 0xb6, 0xd9, 0xbf, 0x5d, 0x26, 0x3e, 0xf5, 0xd7, 0x58, 0xe4, 0x9d, 0x27, 0xd0, 0x18, 0x14,
-	0xaa, 0x1f, 0xc9, 0x93, 0xf7, 0xa3, 0xf0, 0x9c, 0x26, 0x7c, 0x15, 0x31, 0x69, 0xae, 0x81, 0xcb,
-	0xb0, 0xe3, 0x82, 0x21, 0xf6, 0x42, 0x0e, 0xdc, 0xda, 0xb0, 0xd5, 0xcf, 0xb3, 0xd5, 0xa5, 0xea,
-	0xc3, 0xc0, 0xbb, 0xd8, 0xe9, 0x43, 0xf5, 0xa9, 0xbf, 0x46, 0x9f, 0x42, 0x8d, 0x26, 0x49, 0x94,
-	0x64, 0x9e, 0xef, 0x96, 0xad, 0x9c, 0x8a, 0x24, 0x56, 0x1c, 0xe7, 0xa5, 0x0e, 0x35, 0x09, 0x20,
-	0x0f, 0x0c, 0x3f, 0x0a, 0x54, 0xd5, 0x76, 0xdf, 0x39, 0xa8, 0xf2, 0x4e, 0xa2, 0x80, 0x62, 0xc9,
-	0x43, 0x5d, 0x68, 0x06, 0x94, 0xfb, 0xc9, 0x2a, 0x4e, 0x85, 0xef, 0x8a, 0xf4, 0x5d, 0x84, 0xdc,
-	0x27, 0x60, 0x08, 0x3e, 0x6a, 0x82, 0x39, 0x1f, 0x7d, 0x3d, 0x1a, 0x7f, 0x3b, 0xb2, 0x34, 0xd4,
-	0x85, 0xfb, 0xf3, 0xd1, 0x74, 0x3e, 0x99, 0x8c, 0xf1, 0xec, 0xf4, 0xab, 0x17, 0x13, 0x3c, 0x9e,
-	0x8d, 0x4f, 0xc6, 0xcf, 0x5f, 0x9c, 0x9f, 0xe2, 0xe9, 0x70, 0x3c, 0xb2, 0xc0, 0xfd, 0xb5, 0x02,
-	0xad, 0xe9, 0xe6, 0x62, 0x57, 0x07, 0x3d, 0x87, 0x36, 0x57, 0xf1, 0x05, 0x9d, 0xc6, 0xc4, 0xcf,
-	0x9f, 0xe0, 0x83, 0xbd, 0xc7, 0x02, 0x3d, 0x0f, 0x32, 0x2e, 0x2e, 0x69, 0x11, 0x06, 0x6b, 0xc3,
-	0x4a, 0xf5, 0xd4, 0x49, 0x7d, 0x7c, 0xb8, 0xde, 0xbc, 0xc4, 0xc6, 0x6f, 0xe8, 0x9d, 0x87, 0xd0,
-	0xbe, 0xb9, 0xab, 0x78, 0x7f, 0x79, 0xbc, 0x7f, 0xef, 0x1b, 0x38, 0x0f, 0x9d, 0x47, 0x60, 0x95,
-	0x2b, 0xbe, 0x9d, 0xed, 0xfe, 0x57, 0x07, 0x63, 0xba, 0x65, 0xfe, 0xdb, 0x29, 0xe8, 0x73, 0x30,
-	0x2f, 0xd5, 0xbb, 0x9f, 0xf5, 0x51, 0x7c, 0x76, 0xcc, 0xf7, 0x4e, 0x22, 0x96, 0x52, 0x96, 0x9e,
-	0x93, 0x70, 0x43, 0x71, 0x4e, 0x75, 0xfe, 0xd5, 0xa1, 0x55, 0xcc, 0xa0, 0x2f, 0x01, 0xc4, 0x95,
-	0x9e, 0xc7, 0x01, 0x49, 0xf3, 0x13, 0xb6, 0x6f, 0x56, 0x1a, 0xec, 0xf2, 0x03, 0x0d, 0x17, 0xd8,
-	0xe8, 0x0c, 0x8e, 0xbe, 0xdf, 0x84, 0xa1, 0x20, 0x61, 0x75, 0x85, 0x0f, 0x5b, 0x39, 0xdb, 0x84,
-	0xa1, 0x97, 0x31, 0x06, 0x1a, 0x2e, 0x8b, 0xd0, 0x10, 0xac, 0x3d, 0xc4, 0xe3, 0x88, 0x71, 0x9a,
-	0x5d, 0xa8, 0x7b, 0x07, 0x0b, 0x29, 0xca, 0x40, 0xc3, 0x6f, 0xc8, 0x9e, 0x99, 0x50, 0xfb, 0x51,
-	0xf4, 0xe5, 0xfc, 0xa9, 0x03, 0xec, 0x8d, 0xa3, 0x3b, 0x50, 0x13, 0xc6, 0xb9, 0xad, 0x77, 0xab,
-	0xbd, 0x06, 0x56, 0x01, 0xea, 0x81, 0x99, 0x0d, 0x4e, 0xbb, 0xd2, 0xad, 0xf6, 0x9a, 0xfd, 0xb6,
-	0x47, 0xfc, 0xd0, 0xc3, 0xe4, 0xa7, 0x13, 0x09, 0xe3, 0x3c, 0x8d, 0xde, 0x87, 0xba, 0x98, 0x98,
-	0xd9, 0x5c, 0x6a, 0xe0, 0x2c, 0x42, 0x2e, 0xb4, 0x38, 0x23, 0x31, 0x5f, 0x46, 0xe9, 0x84, 0xa4,
-	0x4b, 0xdb, 0x90, 0xe5, 0x6f, 0x60, 0xe8, 0x31, 0x80, 0x60, 0xab, 0xd1, 0x68, 0xd7, 0x64, 0x63,
-	0x96, 0x27, 0x07, 0xf0, 0x6c, 0x87, 0xe3, 0x02, 0xc7, 0xf9, 0xbf, 0x02, 0x86, 0xe8, 0xd5, 0xf9,
-	0x5d, 0x07, 0x33, 0x3f, 0xa5, 0x77, 0xab, 0x85, 0x3f, 0x74, 0xb8, 0x95, 0x3f, 0x95, 0x77, 0xcb,
-	0xfa, 0xc3, 0x73, 0x68, 0x16, 0xbe, 0x55, 0xd0, 0x5d, 0x78, 0xaf, 0x10, 0xaa, 0xb9, 0x68, 0x69,
-	0xe8, 0x1e, 0x7c, 0x50, 0x84, 0x0b, 0xa3, 0xc3, 0xd2, 0xd1, 0x6d, 0x38, 0xba, 0xa1, 0x61, 0xbe,
-	0x55, 0x79, 0xf6, 0xe0, 0xaf, 0xab, 0x8e, 0xfe, 0xea, 0xaa, 0xa3, 0xff, 0x73, 0xd5, 0xd1, 0x5f,
-	0x5e, 0x77, 0xb4, 0x57, 0xd7, 0x1d, 0xed, 0xef, 0xeb, 0x8e, 0xf6, 0x1d, 0x1c, 0xef, 0x7e, 0x07,
-	0x5c, 0xd4, 0xe5, 0xc7, 0x67, 0xaf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x41, 0xe9, 0x79, 0xe5, 0x1b,
-	0x08, 0x00, 0x00,
+	// 868 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0xd1, 0x8e, 0xda, 0x46,
+	0x14, 0x65, 0xc0, 0x40, 0xb8, 0x20, 0xd6, 0x9d, 0x24, 0xad, 0xeb, 0x44, 0x08, 0xa1, 0xb4, 0x45,
+	0x69, 0xe4, 0x8d, 0x68, 0xa3, 0x4a, 0x7d, 0x4b, 0xb6, 0xbb, 0x02, 0x35, 0x05, 0x34, 0xc0, 0x56,
+	0xea, 0x4b, 0x34, 0xd8, 0x13, 0x40, 0x78, 0xc7, 0xae, 0xc7, 0xb4, 0xe5, 0x17, 0xfa, 0x94, 0x6f,
+	0xe8, 0x37, 0x54, 0x6a, 0xd5, 0x2f, 0xe8, 0x63, 0x1e, 0xfb, 0x58, 0xed, 0x4a, 0xfd, 0x88, 0xf6,
+	0xa5, 0x9a, 0x19, 0x1b, 0x7b, 0x9d, 0xcd, 0x07, 0xe4, 0x01, 0x98, 0x7b, 0xee, 0x39, 0xd7, 0xe7,
+	0xce, 0x30, 0x17, 0xc0, 0x16, 0x7b, 0xee, 0x86, 0x51, 0x10, 0x07, 0xc7, 0xfa, 0x5d, 0xc6, 0x8e,
+	0x5a, 0xe2, 0x3a, 0xe5, 0xfb, 0x78, 0x1f, 0x32, 0xfb, 0x71, 0xb8, 0x5d, 0x1d, 0x53, 0xd7, 0x97,
+	0x2f, 0x77, 0x4d, 0xf9, 0x8a, 0x09, 0xb9, 0x0c, 0x97, 0x5a, 0x23, 0x72, 0xb8, 0x96, 0xda, 0x8f,
+	0x52, 0x45, 0x1c, 0x31, 0x26, 0xe2, 0x20, 0xa2, 0x2b, 0xa6, 0xd6, 0x99, 0x46, 0x46, 0x9a, 0xdd,
+	0x3b, 0x83, 0xfa, 0x37, 0x4c, 0x08, 0xba, 0x62, 0xf8, 0x13, 0xa8, 0xad, 0x19, 0xf5, 0x58, 0x64,
+	0xa1, 0x2e, 0xea, 0x37, 0x07, 0x47, 0x4e, 0x62, 0xc2, 0x19, 0x2a, 0x98, 0x24, 0x69, 0x8c, 0xc1,
+	0xf0, 0x68, 0x4c, 0xad, 0x72, 0x17, 0xf5, 0x5b, 0x44, 0xad, 0x7b, 0xbf, 0x20, 0xa8, 0x69, 0x1a,
+	0xb6, 0xa0, 0x1e, 0x47, 0xd4, 0x65, 0x23, 0x4f, 0x15, 0x6a, 0x91, 0x34, 0xc4, 0xf7, 0xa1, 0x11,
+	0xb1, 0xef, 0x77, 0x4c, 0xc4, 0x23, 0x4f, 0xa9, 0x0d, 0x92, 0x01, 0x52, 0x17, 0xb1, 0xd0, 0xdf,
+	0x8f, 0x3c, 0xab, 0xa2, 0x72, 0x69, 0x88, 0xfb, 0x60, 0x48, 0x1f, 0x96, 0xd1, 0x45, 0xfd, 0xf6,
+	0xe0, 0xce, 0xc1, 0x57, 0xe2, 0x7c, 0xbe, 0x0f, 0x19, 0x51, 0x0c, 0xf9, 0x04, 0x8f, 0x2d, 0x77,
+	0xab, 0x11, 0x7f, 0x19, 0x58, 0xd5, 0x2e, 0xea, 0x37, 0x48, 0x06, 0xf4, 0x7e, 0xad, 0x40, 0x6d,
+	0xb6, 0x17, 0x31, 0xbb, 0xc0, 0x5f, 0x40, 0x63, 0x4d, 0xb9, 0x27, 0xd6, 0x74, 0xcb, 0x92, 0x7e,
+	0x3f, 0x3c, 0xd4, 0xd5, 0x1c, 0x67, 0x98, 0x12, 0x48, 0xc6, 0x95, 0x5e, 0xc2, 0x0d, 0x5f, 0x29,
+	0xfb, 0xcd, 0x9c, 0x97, 0x44, 0x33, 0xdd, 0xf0, 0x15, 0x51, 0x0c, 0xfc, 0x11, 0x54, 0xa8, 0xbb,
+	0x55, 0xbd, 0x34, 0x07, 0xb7, 0x8b, 0xc4, 0xa7, 0xee, 0x96, 0xc8, 0xbc, 0xfd, 0x04, 0x1a, 0xc3,
+	0x5c, 0xf5, 0x23, 0x75, 0x2e, 0x6e, 0xe0, 0x9f, 0xb3, 0x48, 0x6c, 0x02, 0xae, 0xcc, 0x35, 0x48,
+	0x11, 0xb6, 0x7b, 0x60, 0xc8, 0x67, 0x61, 0x1b, 0x6e, 0xed, 0xf8, 0xe6, 0xa7, 0xf9, 0xe6, 0x42,
+	0xf7, 0x61, 0x90, 0x43, 0x6c, 0x0f, 0xa0, 0xf2, 0xd4, 0xdd, 0xe2, 0x4f, 0xa1, 0xca, 0xa2, 0x28,
+	0x88, 0x12, 0xcf, 0x77, 0x8b, 0x56, 0x4e, 0x65, 0x92, 0x68, 0x8e, 0xfd, 0x0a, 0x41, 0x55, 0x01,
+	0xd8, 0x01, 0xc3, 0x0d, 0x3c, 0x5d, 0xb5, 0x3d, 0xb0, 0x6f, 0x54, 0x39, 0x27, 0x81, 0xc7, 0x88,
+	0xe2, 0xe1, 0x2e, 0x34, 0x3d, 0x26, 0xdc, 0x68, 0x13, 0xc6, 0xd2, 0x77, 0x59, 0xf9, 0xce, 0x43,
+	0xbd, 0x27, 0x60, 0x48, 0x3e, 0x6e, 0x42, 0x7d, 0x31, 0xfe, 0x7a, 0x3c, 0xf9, 0x76, 0x6c, 0x96,
+	0x70, 0x17, 0xee, 0x2f, 0xc6, 0xb3, 0xc5, 0x74, 0x3a, 0x21, 0xf3, 0xd3, 0xaf, 0x5e, 0x4c, 0xc9,
+	0x64, 0x3e, 0x39, 0x99, 0x3c, 0x7f, 0x71, 0x7e, 0x4a, 0x66, 0xa3, 0xc9, 0xd8, 0x84, 0xde, 0xcf,
+	0x65, 0x68, 0xcd, 0x76, 0xcb, 0x43, 0x1d, 0xfc, 0x1c, 0xda, 0x42, 0xc7, 0x4b, 0x36, 0x0b, 0xa9,
+	0x9b, 0x9e, 0xe0, 0x83, 0xcc, 0x63, 0x8e, 0x9e, 0x06, 0x09, 0x97, 0x14, 0xb4, 0x98, 0x80, 0xb9,
+	0xe3, 0x85, 0x7a, 0x7a, 0xa7, 0x3e, 0xbe, 0xb9, 0xde, 0xa2, 0xc0, 0x26, 0x6f, 0xe8, 0xed, 0x87,
+	0xd0, 0xbe, 0xfe, 0x54, 0xf9, 0xed, 0x16, 0x61, 0x76, 0x2b, 0x1a, 0x24, 0x0d, 0xed, 0x47, 0x60,
+	0x16, 0x2b, 0xbe, 0x9d, 0xdd, 0xfb, 0xb7, 0x06, 0xc6, 0x6c, 0xcf, 0xdd, 0xb7, 0x53, 0xf0, 0xe7,
+	0x50, 0xbf, 0xd0, 0x37, 0x23, 0xe9, 0x23, 0x7f, 0x76, 0xdc, 0x75, 0x4e, 0x02, 0x1e, 0x33, 0x1e,
+	0x9f, 0x53, 0x7f, 0xc7, 0x48, 0x4a, 0xb5, 0xff, 0x41, 0xd0, 0xca, 0x67, 0xf0, 0x97, 0x00, 0xf2,
+	0xc2, 0x2f, 0x42, 0x8f, 0xc6, 0xe9, 0x0e, 0x5b, 0xd7, 0x2b, 0x0d, 0x0f, 0xf9, 0x61, 0x89, 0xe4,
+	0xd8, 0xf8, 0x0c, 0x8e, 0x5e, 0xee, 0x7c, 0x5f, 0x92, 0x88, 0xbe, 0xe0, 0x37, 0x5b, 0x39, 0xdb,
+	0xf9, 0xbe, 0x93, 0x30, 0x86, 0x25, 0x52, 0x14, 0xe1, 0x11, 0x98, 0x19, 0x24, 0xc2, 0x80, 0x0b,
+	0x96, 0x5c, 0xa8, 0x7b, 0x37, 0x16, 0xd2, 0x94, 0x61, 0x89, 0xbc, 0x21, 0x7b, 0x56, 0x87, 0xea,
+	0x0f, 0xb2, 0x2f, 0xfb, 0x0f, 0x04, 0x90, 0x19, 0xc7, 0x77, 0xa0, 0x2a, 0x8d, 0x0b, 0x0b, 0x75,
+	0x2b, 0xfd, 0x06, 0xd1, 0x01, 0xee, 0x43, 0x3d, 0x19, 0xab, 0x56, 0xb9, 0x5b, 0xe9, 0x37, 0x07,
+	0x6d, 0x87, 0xba, 0xbe, 0x43, 0xe8, 0x8f, 0x27, 0x0a, 0x26, 0x69, 0x1a, 0xbf, 0x0f, 0x35, 0x39,
+	0x4f, 0x93, 0xa9, 0xd5, 0x20, 0x49, 0x84, 0x7b, 0xd0, 0x12, 0x9c, 0x86, 0x62, 0x1d, 0xc4, 0x53,
+	0x1a, 0xaf, 0x2d, 0x43, 0x95, 0xbf, 0x86, 0xe1, 0xc7, 0x00, 0x92, 0xad, 0x07, 0xa7, 0x9a, 0x57,
+	0xcd, 0x81, 0xe9, 0xa8, 0xf1, 0x3c, 0x3f, 0xe0, 0x24, 0xc7, 0xb1, 0xff, 0x2b, 0x83, 0x21, 0x7b,
+	0xb5, 0x7f, 0x43, 0x50, 0x4f, 0x77, 0xe9, 0xdd, 0x6a, 0xe1, 0x77, 0x04, 0xb7, 0xd2, 0x53, 0x79,
+	0xb7, 0xac, 0x3f, 0x3c, 0x87, 0x66, 0xee, 0x37, 0x07, 0xdf, 0x85, 0xf7, 0x72, 0xa1, 0x9e, 0x8b,
+	0x66, 0x09, 0xdf, 0x83, 0x0f, 0xf2, 0x70, 0x6e, 0x74, 0x98, 0x08, 0xdf, 0x86, 0xa3, 0x6b, 0x1a,
+	0xee, 0x9a, 0xe5, 0x67, 0x0f, 0xfe, 0xbc, 0xec, 0xa0, 0xd7, 0x97, 0x1d, 0xf4, 0xf7, 0x65, 0x07,
+	0xbd, 0xba, 0xea, 0x94, 0x5e, 0x5f, 0x75, 0x4a, 0x7f, 0x5d, 0x75, 0x4a, 0xdf, 0xc1, 0xf1, 0xe1,
+	0x5f, 0xc2, 0xb2, 0xa6, 0x3e, 0x3e, 0xfb, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x7a, 0xad, 0xe7, 0x46,
+	0x39, 0x08, 0x00, 0x00,
 }
 
 func (m *Message) Marshal() (dAtA []byte, err error) {
@@ -1139,6 +1148,13 @@ func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if len(m.DebugInfo) > 0 {
+		i -= len(m.DebugInfo)
+		copy(dAtA[i:], m.DebugInfo)
+		i = encodeVarintSync(dAtA, i, uint64(len(m.DebugInfo)))
+		i--
+		dAtA[i] = 0x2a
+	}
 	if m.Type != 0 {
 		i = encodeVarintSync(dAtA, i, uint64(m.Type))
 		i--
@@ -1887,6 +1903,10 @@ func (m *Header) Size() (n int) {
 	if m.Type != 0 {
 		n += 1 + sovSync(uint64(m.Type))
 	}
+	l = len(m.DebugInfo)
+	if l > 0 {
+		n += 1 + l + sovSync(uint64(l))
+	}
 	return n
 }
 
@@ -2433,6 +2453,38 @@ func (m *Header) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DebugInfo", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSync
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthSync
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSync
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.DebugInfo = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipSync(dAtA[iNdEx:])