feature: adding buffer to improve quick reconnect handling

internal/websocket/hub.go

···
 )
 
 const (
-	writeWait      = 10 * time.Second
-	pongWait       = 60 * time.Second
-	pingPeriod     = (pongWait * 9) / 10
-	maxMessageSize = 4096
-	sessionTimeout = 25 * time.Minute // Disconnect after 25 minutes
+	writeWait          = 10 * time.Second
+	pongWait           = 60 * time.Second
+	pingPeriod         = (pongWait * 9) / 10
+	maxMessageSize     = 4096
+	sessionTimeout     = 25 * time.Minute // Disconnect after 25 minutes
+	leaveDebounceDelay = 10 * time.Second // Wait before broadcasting leave
 )
 
 // MessageType represents the type of websocket message.
···
 	sessionTimer *time.Timer
 }
 
+// pendingLeave tracks a client that is about to leave with a debounce timer.
+type pendingLeave struct {
+	client *Client
+	timer  *time.Timer
+}
+
 // Hub maintains the set of active clients and broadcasts messages.
 type Hub struct {
-	clients    map[*Client]bool
-	didClients map[string]*Client // Map DID to client
-	broadcast  chan []byte
-	register   chan *Client
-	unregister chan *Client
-	mu         sync.RWMutex
+	clients       map[*Client]bool
+	didClients    map[string]*Client       // Map DID to client
+	pendingLeaves map[string]*pendingLeave // Map DID to pending leave
+	broadcast     chan []byte
+	register      chan *Client
+	unregister    chan *Client
+	mu            sync.RWMutex
 
 	// Callbacks for handling messages
 	onClientJoin  func(client *Client) error
···
 // NewHub creates a new Hub.
 func NewHub() *Hub {
 	return &Hub{
-		clients:    make(map[*Client]bool),
-		didClients: make(map[string]*Client),
-		broadcast:  make(chan []byte),
-		register:   make(chan *Client),
-		unregister: make(chan *Client),
+		clients:       make(map[*Client]bool),
+		didClients:    make(map[string]*Client),
+		pendingLeaves: make(map[string]*pendingLeave),
+		broadcast:     make(chan []byte),
+		register:      make(chan *Client),
+		unregister:    make(chan *Client),
 	}
 }
 
···
 		select {
 		case client := <-h.register:
 			h.mu.Lock()
+			// Check if there's a pending leave for this DID (reconnect scenario)
+			cancelledPendingLeave := false
+			if client.DID != "" {
+				if pending, ok := h.pendingLeaves[client.DID]; ok {
+					// Cancel the pending leave timer
+					pending.timer.Stop()
+					delete(h.pendingLeaves, client.DID)
+					cancelledPendingLeave = true
+					log.Printf("Client reconnected, cancelled pending leave: %s (%s)", client.DID, client.Handle)
+
+					// Close the old client's send channel if it's different
+					if pending.client != client && pending.client.send != nil {
+						close(pending.client.send)
+					}
+				}
+			}
+
 			h.clients[client] = true
 			if client.DID != "" {
 				h.didClients[client.DID] = client
···
 			h.mu.Unlock()
 			log.Printf("Client registered: %s (%s)", client.DID, client.Handle)
 
-			// Call the join callback
+			// If we cancelled a pending leave, mark as reconnect so join callback
+			// doesn't broadcast to other clients (they never saw the user leave)
+			if cancelledPendingLeave {
+				client.IsReconnect = true
+			}
+
 			if h.onClientJoin != nil {
 				if err := h.onClientJoin(client); err != nil {
 					log.Printf("error in client join callback: %v", err)
···
 			h.mu.Lock()
 			if _, ok := h.clients[client]; ok {
 				delete(h.clients, client)
+
 				if client.DID != "" {
+					// Don't immediately remove from didClients or call leave callback
+					// Instead, start a debounce timer
 					delete(h.didClients, client.DID)
+
+					// Create pending leave with timer
+					pending := &pendingLeave{
+						client: client,
+					}
+					pending.timer = time.AfterFunc(leaveDebounceDelay, func() {
+						h.completePendingLeave(client.DID)
+					})
+					h.pendingLeaves[client.DID] = pending
+					log.Printf("Client disconnected, starting leave debounce: %s (%s)", client.DID, client.Handle)
+				} else {
+					// No DID, close immediately
+					close(client.send)
+					h.mu.Unlock()
+					if h.onClientLeave != nil {
+						if err := h.onClientLeave(client); err != nil {
+							log.Printf("error in client leave callback: %v", err)
+						}
+					}
+					continue
 				}
-				close(client.send)
 			}
 			h.mu.Unlock()
-			log.Printf("Client unregistered: %s (%s)", client.DID, client.Handle)
-
-			// Call the leave callback
-			if h.onClientLeave != nil {
-				if err := h.onClientLeave(client); err != nil {
-					log.Printf("error in client leave callback: %v", err)
-				}
-			}
 
 		case message := <-h.broadcast:
 			h.mu.RLock()
···
 				}
 			}
 			h.mu.RUnlock()
+		}
+	}
+}
+
+// completePendingLeave is called after the debounce delay to finalize a client leave.
+func (h *Hub) completePendingLeave(did string) {
+	h.mu.Lock()
+	pending, ok := h.pendingLeaves[did]
+	if !ok {
+		// Already cancelled (client reconnected)
+		h.mu.Unlock()
+		return
+	}
+
+	delete(h.pendingLeaves, did)
+	client := pending.client
+
+	// Close the send channel
+	if client.send != nil {
+		close(client.send)
+	}
+	h.mu.Unlock()
+
+	log.Printf("Client leave confirmed after debounce: %s (%s)", client.DID, client.Handle)
+
+	// Call the leave callback
+	if h.onClientLeave != nil {
+		if err := h.onClientLeave(client); err != nil {
+			log.Printf("error in client leave callback: %v", err)
 		}
 	}
 }