feat: support multi-delta edit messages on server

internal/collaboration/client.go

···
 }
 
 type ClientMessage struct {
-	Type    string          `json:"type"`
-	RKey    string          `json:"rkey,omitempty"`
-	DID     string          `json:"did,omitempty"`
+	Type string `json:"type"`
+	RKey string `json:"rkey,omitempty"`
+	DID  string `json:"did,omitempty"`
+	// Deltas is the new plural field — a single edit message may carry
+	// multiple operations (e.g. one per CodeMirror ChangeDesc).
+	Deltas []Operation `json:"deltas,omitempty"`
+	// Delta is the legacy singular field. Kept for backward compatibility.
 	Delta   json.RawMessage `json:"delta,omitempty"`
 	Cursor  *CursorPos      `json:"cursor,omitempty"`
 	Comment *CommentMsg     `json:"comment,omitempty"`
+}
+
+// Operations returns the ops from this message, preferring Deltas over the
+// legacy singular Delta field.
+func (m *ClientMessage) Operations() []Operation {
+	if len(m.Deltas) > 0 {
+		return m.Deltas
+	}
+	if len(m.Delta) > 0 {
+		var op Operation
+		if err := json.Unmarshal(m.Delta, &op); err == nil {
+			return []Operation{op}
+		}
+	}
+	return nil
 }
 
 type CursorPos struct {
···
 
 		switch msg.Type {
 		case "edit":
-			var op Operation
-			if err := json.Unmarshal(msg.Delta, &op); err != nil {
-				log.Printf("Failed to parse delta from %s: %v", c.DID, err)
+			ops := msg.Operations()
+			if len(ops) == 0 {
 				continue
 			}
-			op.Author = c.DID
 			room := c.hub.GetRoom(c.roomKey)
-			if room != nil {
-				room.ApplyEdit(op, c)
+			if room == nil {
+				continue
+			}
+			for i := range ops {
+				ops[i].Author = c.DID
 			}
+			room.ApplyEdits(ops, c)
 		case "ping":
 			pong, _ := json.Marshal(map[string]string{"type": "pong"})
 			c.send <- pong

internal/collaboration/client_test.go

···
+package collaboration
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestClientMessage_ParseDeltas_Multiple(t *testing.T) {
+	raw := `{"type":"edit","deltas":[{"from":0,"to":5,"insert":"hello"},{"from":10,"to":10,"insert":"!"}]}`
+	var msg ClientMessage
+	if err := json.Unmarshal([]byte(raw), &msg); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	if len(msg.Deltas) != 2 {
+		t.Fatalf("expected 2 deltas, got %d", len(msg.Deltas))
+	}
+	if msg.Deltas[0].From != 0 || msg.Deltas[0].To != 5 || msg.Deltas[0].Insert != "hello" {
+		t.Errorf("delta[0]: %+v", msg.Deltas[0])
+	}
+	if msg.Deltas[1].From != 10 || msg.Deltas[1].Insert != "!" {
+		t.Errorf("delta[1]: %+v", msg.Deltas[1])
+	}
+}
+
+func TestClientMessage_ParseDeltas_SingleFallback(t *testing.T) {
+	// Old wire format: singular "delta" field — must still work.
+	raw := `{"type":"edit","delta":{"from":3,"to":7,"insert":"xyz"}}`
+	var msg ClientMessage
+	if err := json.Unmarshal([]byte(raw), &msg); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	ops := msg.Operations()
+	if len(ops) != 1 {
+		t.Fatalf("expected 1 op from fallback, got %d", len(ops))
+	}
+	if ops[0].From != 3 || ops[0].To != 7 || ops[0].Insert != "xyz" {
+		t.Errorf("op: %+v", ops[0])
+	}
+}
+
+func TestClientMessage_ParseDeltas_EmptyDeltas(t *testing.T) {
+	raw := `{"type":"edit","deltas":[]}`
+	var msg ClientMessage
+	if err := json.Unmarshal([]byte(raw), &msg); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	if len(msg.Operations()) != 0 {
+		t.Errorf("expected 0 ops for empty deltas")
+	}
+}

internal/collaboration/hub.go

···
 	r.BroadcastExcept(data, sender)
 }
 
+// ApplyEdits applies a sequence of operations in order and broadcasts one
+// combined message to all other clients. Each op is applied to the text
+// resulting from the previous op, so positions in each op must be relative
+// to the document state after all prior ops in the same batch have been
+// applied — which is exactly what CodeMirror's iterChanges produces (fromA/toA
+// are positions in the pre-change document, already adjusted for prior changes
+// within the same transaction by CodeMirror itself).
+func (r *Room) ApplyEdits(ops []Operation, sender *Client) {
+	if len(ops) == 0 {
+		return
+	}
+
+	for i := range ops {
+		r.ot.ApplyWithVersion(ops[i])
+	}
+
+	// Include the full document text so receivers can detect and recover from
+	// divergence without a reconnect.
+	finalText := r.ot.GetText()
+	type editsMsg struct {
+		Type    string      `json:"type"`
+		Deltas  []Operation `json:"deltas"`
+		Author  string      `json:"author"`
+		Content string      `json:"content"`
+	}
+	msg := editsMsg{
+		Type:    "edit",
+		Deltas:  ops,
+		Author:  sender.DID,
+		Content: finalText,
+	}
+	data, err := json.Marshal(msg)
+	if err != nil {
+		log.Printf("ApplyEdits: marshal: %v", err)
+		return
+	}
+	r.BroadcastExcept(data, sender)
+}
+
 func (r *Room) RegisterClient(client *Client) {
 	r.register <- client
 }