feat: seed OT engine with document text on room creation

internal/collaboration/hub.go

···
 	unregister   chan *Client
 	mu           sync.RWMutex
 	ot           *OTEngine
+	seeded       bool // true after SeedText has been called
 }
 
 // broadcastMsg carries a message and an optional sender to exclude.
···
 	}
 	r.Broadcast(data)
 }
+
+// IsNewRoom returns true if SeedText has not yet been called on this room.
+func (r *Room) IsNewRoom() bool {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	return !r.seeded
+}
+
+// SeedText sets the initial document text for the OT engine.
+// Idempotent — only the first call has effect.
+func (r *Room) SeedText(text string) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if !r.seeded {
+		r.ot.SetText(text)
+		r.seeded = true
+	}
+}

internal/collaboration/hub_test.go

···
 	}
 }
 
+// --- SeedText / IsNewRoom ---
+
+func TestRoom_SeedText_SetsInitialOTState(t *testing.T) {
+	hub := NewHub()
+	room := hub.GetOrCreateRoom("doc-seed")
+	if !room.IsNewRoom() {
+		t.Fatal("new room should report IsNewRoom=true")
+	}
+	room.SeedText("initial document content")
+	if room.IsNewRoom() {
+		t.Error("IsNewRoom should be false after seeding")
+	}
+	if got := room.ot.GetText(); got != "initial document content" {
+		t.Errorf("OT text after seed: got %q, want %q", got, "initial document content")
+	}
+}
+
+func TestRoom_SeedText_IdempotentAfterFirstCall(t *testing.T) {
+	hub := NewHub()
+	room := hub.GetOrCreateRoom("doc-seed-idem")
+	room.SeedText("first")
+	room.SeedText("second") // should be ignored
+	if got := room.ot.GetText(); got != "first" {
+		t.Errorf("second SeedText should be ignored: got %q, want %q", got, "first")
+	}
+}
+
 // --- GetPresence ---
 
 func TestRoom_GetPresence_Empty(t *testing.T) {

internal/collaboration/ot.go

···
 }
 
 func (ot *OTEngine) applyInternal(op Operation) (string, bool) {
-	if op.Insert == "" {
-		return ot.documentText, false
-	}
 	if op.From < 0 {
 		op.From = 0
 	}
···
 		op.To = len(ot.documentText)
 	}
 	if op.From > op.To {
+		return ot.documentText, false
+	}
+
+	// True no-op: nothing deleted and nothing inserted.
+	if op.From == op.To && op.Insert == "" {
 		return ot.documentText, false
 	}
 
···
 	ot.version++
 
 	return newText, true
+}
+
+// SetText replaces the canonical document text without incrementing the version.
+// Call this once when a room is first created, before any edits are applied.
+func (ot *OTEngine) SetText(text string) {
+	ot.mu.Lock()
+	defer ot.mu.Unlock()
+	ot.documentText = text
 }
 
 func (ot *OTEngine) GetText() string {

internal/collaboration/ot_test.go

···
+package collaboration
+
+import (
+	"sync"
+	"testing"
+)
+
+func TestOTEngine_NewEngine(t *testing.T) {
+	ot := NewOTEngine("hello world")
+	if ot.GetText() != "hello world" {
+		t.Errorf("expected initial text %q, got %q", "hello world", ot.GetText())
+	}
+	if ot.GetVersion() != 0 {
+		t.Errorf("expected initial version 0, got %d", ot.GetVersion())
+	}
+}
+
+func TestOTEngine_Apply_Insert(t *testing.T) {
+	ot := NewOTEngine("hello world")
+	result := ot.Apply(Operation{From: 5, To: 5, Insert: " beautiful"})
+	want := "hello beautiful world"
+	if result != want {
+		t.Errorf("Apply insert: got %q, want %q", result, want)
+	}
+}
+
+func TestOTEngine_Apply_Replace(t *testing.T) {
+	ot := NewOTEngine("hello world")
+	result := ot.Apply(Operation{From: 6, To: 11, Insert: "Go"})
+	want := "hello Go"
+	if result != want {
+		t.Errorf("Apply replace: got %q, want %q", result, want)
+	}
+}
+
+func TestOTEngine_Apply_Delete(t *testing.T) {
+	ot := NewOTEngine("hello world")
+	// Delete " world" by replacing with empty string.
+	result := ot.Apply(Operation{From: 5, To: 11, Insert: ""})
+	want := "hello"
+	if result != want {
+		t.Errorf("Apply delete (empty insert): got %q, want %q", result, want)
+	}
+}
+
+func TestOTEngine_Apply_DeleteIncrementsVersion(t *testing.T) {
+	ot := NewOTEngine("hello world")
+	ot.Apply(Operation{From: 5, To: 11, Insert: ""})
+	if ot.GetVersion() != 1 {
+		t.Errorf("delete should increment version: got %d, want 1", ot.GetVersion())
+	}
+}
+
+func TestOTEngine_Apply_EmptyInsertAtSamePosition_IsNoOp(t *testing.T) {
+	ot := NewOTEngine("hello")
+	result := ot.Apply(Operation{From: 3, To: 3, Insert: ""})
+	if result != "hello" {
+		t.Errorf("From==To and Insert==\"\" should be no-op: got %q", result)
+	}
+	if ot.GetVersion() != 0 {
+		t.Errorf("no-op should not increment version: got %d", ot.GetVersion())
+	}
+}
+
+func TestOTEngine_Apply_FullReplace(t *testing.T) {
+	ot := NewOTEngine("old text")
+	result := ot.Apply(Operation{From: 0, To: -1, Insert: "brand new content"})
+	want := "brand new content"
+	if result != want {
+		t.Errorf("Apply full replace (To=-1): got %q, want %q", result, want)
+	}
+}
+
+func TestOTEngine_Apply_FromBeyondEnd_Clamps(t *testing.T) {
+	ot := NewOTEngine("hi")
+	// From beyond length should be clamped to len(text)
+	result := ot.Apply(Operation{From: 100, To: 200, Insert: "!"})
+	want := "hi!"
+	if result != want {
+		t.Errorf("Apply clamped From: got %q, want %q", result, want)
+	}
+}
+
+func TestOTEngine_Apply_NegativeFrom_Clamps(t *testing.T) {
+	ot := NewOTEngine("hello")
+	result := ot.Apply(Operation{From: -5, To: 0, Insert: ">> "})
+	want := ">> hello"
+	if result != want {
+		t.Errorf("Apply negative From: got %q, want %q", result, want)
+	}
+}
+
+func TestOTEngine_Apply_FromGreaterThanTo_NoOp(t *testing.T) {
+	ot := NewOTEngine("hello")
+	result := ot.Apply(Operation{From: 3, To: 1, Insert: "X"})
+	// From > To → no-op
+	if result != "hello" {
+		t.Errorf("Apply From>To should be no-op: got %q, want %q", result, "hello")
+	}
+}
+
+func TestOTEngine_VersionIncrements(t *testing.T) {
+	ot := NewOTEngine("abc")
+	if ot.GetVersion() != 0 {
+		t.Fatalf("initial version should be 0")
+	}
+	ot.Apply(Operation{From: 0, To: 0, Insert: "X"})
+	if ot.GetVersion() != 1 {
+		t.Errorf("version after apply: got %d, want 1", ot.GetVersion())
+	}
+	ot.Apply(Operation{From: 0, To: 0, Insert: "Y"})
+	if ot.GetVersion() != 2 {
+		t.Errorf("version after second apply: got %d, want 2", ot.GetVersion())
+	}
+}
+
+func TestOTEngine_NoOpDoesNotIncrementVersion(t *testing.T) {
+	ot := NewOTEngine("abc")
+	ot.Apply(Operation{From: 1, To: 1, Insert: ""}) // no-op
+	if ot.GetVersion() != 0 {
+		t.Errorf("no-op should not increment version: got %d, want 0", ot.GetVersion())
+	}
+}
+
+func TestOTEngine_ApplyWithVersion(t *testing.T) {
+	ot := NewOTEngine("hello")
+	text, ver := ot.ApplyWithVersion(Operation{From: 5, To: 5, Insert: "!"})
+	if text != "hello!" {
+		t.Errorf("ApplyWithVersion text: got %q, want %q", text, "hello!")
+	}
+	if ver != 1 {
+		t.Errorf("ApplyWithVersion version: got %d, want 1", ver)
+	}
+}
+
+func TestOTEngine_SetText(t *testing.T) {
+	ot := NewOTEngine("")
+	ot.SetText("initial content")
+	if ot.GetText() != "initial content" {
+		t.Errorf("SetText: got %q, want %q", ot.GetText(), "initial content")
+	}
+	// SetText should not change the version counter.
+	if ot.GetVersion() != 0 {
+		t.Errorf("SetText should not increment version: got %d", ot.GetVersion())
+	}
+}
+
+func TestOTEngine_ConcurrentApply_DataRace(t *testing.T) {
+	// Run with -race to catch races. This test just verifies no panic / race.
+	ot := NewOTEngine("start")
+	var wg sync.WaitGroup
+	for i := 0; i < 20; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			ot.Apply(Operation{From: 0, To: 0, Insert: "x"})
+		}()
+	}
+	wg.Wait()
+	// After 20 inserts of "x" at position 0, we have 20 extra chars
+	text := ot.GetText()
+	if len(text) != len("start")+20 {
+		t.Errorf("concurrent apply: expected length %d, got %d (text=%q)", len("start")+20, len(text), text)
+	}
+}

internal/handler/handler.go

···
 	}
 
 	room := h.CollaborationHub.GetOrCreateRoom(rKey)
+	if room.IsNewRoom() {
+		var initialText string
+		if doc.Content != nil {
+			initialText = doc.Content.Text.RawMarkdown
+		}
+		room.SeedText(initialText)
+	}
 	wsClient := collaboration.NewClient(h.CollaborationHub, conn, did, name, color, rKey)
 	room.RegisterClient(wsClient)