fix(realtime): always roll back a failed table join; re-elect file-doc seeder on reclaim

Two review findings:
- Table join: the catch skipped rollback when superseded, but a socket.join that
  landed before addUserToRoom threw leaves the socket in the Socket.IO room with no
  matching socket->room map entry — unreclaimable by any later op (cleanup keys off
  the map). Under serialization the skip is unnecessary (the newer op hasn't
  committed), so always roll back. Simpler + fixes the strand.
- File-doc reclaim: fully evicting the prior socket didn't release the seeder role
  if it held it, so electSeederIfNeeded (which no-ops while seederSocketId is set)
  never re-elected and an unseeded doc stayed empty until the deadline. Clear the
  role on eviction so the join's election picks a new seeder. + 2 regression tests.

Author: waleedlatif1

apps/realtime/src/handlers/file-doc.test.ts

@@ -612,6 +612,22 @@ describe('setupWorkspaceFileDocHandlers', () => {
     expect(sent.some((m) => m.event === FILE_DOC_EVENTS.MESSAGE)).toBe(false)
   })
 
+  it('re-elects a seeder when the reclaimed socket held the seeder role', async () => {
+    const { io, sent } = createIo()
+    const a = setup('socket-a', io)
+    await a.handlers[FILE_DOC_EVENTS.JOIN]({ fileId: 'file-1', clientId: 7 })
+    // a is the sole owner of an unseeded doc → elected seeder.
+    expect(sent.find((m) => m.event === FILE_DOC_EVENTS.SEED_REQUEST)?.target).toBe('socket-a')
+    sent.length = 0
+
+    const b = setup('socket-b', io) // same user-1 reconnecting, reusing client id 7
+    await b.handlers[FILE_DOC_EVENTS.JOIN]({ fileId: 'file-1', clientId: 7 })
+
+    // The reclaim evicts a (the seeder) and releases the role, so the join's election picks b —
+    // the doc gets seeded instead of waiting out the deadline.
+    expect(sent.find((m) => m.event === FILE_DOC_EVENTS.SEED_REQUEST)?.target).toBe('socket-b')
+  })
+
   it('does not drop the current document when a switch is rejected for a foreign client id', async () => {
     const { io } = createIo()
     const a = setup('socket-a', io) // user-1

apps/realtime/src/handlers/file-doc.ts

@@ -481,6 +481,10 @@ export function setupWorkspaceFileDocHandlers(
         awarenessProtocol.removeAwarenessStates(entry.awareness, [owner.clientId], null)
         socketToRoomName.delete(otherSid)
         io.in(otherSid).socketsLeave(name)
+        // If the evicted socket held the seeder role, release it so the election at the end of
+        // this join re-elects (electSeederIfNeeded no-ops while seederSocketId is set) — otherwise
+        // an unseeded document would stay empty until the seed deadline expires.
+        if (entry.seederSocketId === otherSid) entry.seederSocketId = null
       }
 
       // Only now that the rebind is guaranteed to succeed, leave a previously-joined document if

apps/realtime/src/handlers/tables.test.ts

@@ -297,4 +297,24 @@ describe('setupTablesHandlers', () => {
     expect(roomManager.removeUserFromRoom).toHaveBeenCalledWith(TABLE_ROOM, 'socket-1')
     expect(roomManager.broadcastPresenceUpdate).toHaveBeenCalledWith(TABLE_ROOM, 'socket-1')
   })
+
+  it('rolls back the Socket.IO membership when a join fails mid-commit', async () => {
+    const { socket, handlers } = createSocket()
+    const roomManager = createRoomManager({
+      // socket.join lands first, then the presence write throws — the socket is now in the
+      // Socket.IO room with no matching socket→room map entry, unreclaimable by any later op.
+      addUserToRoom: vi.fn().mockRejectedValue(new Error('redis down')),
+    })
+    setupTablesHandlers(socket as unknown as SetupArg, roomManager)
+
+    await handlers[TABLE_PRESENCE_EVENTS.JOIN]({ tableId: 'table-1' })
+
+    // The catch must always roll back the partial membership, not skip it.
+    expect(socket.leave).toHaveBeenCalledWith('table:table-1')
+    expect(roomManager.removeUserFromRoom).toHaveBeenCalledWith(TABLE_ROOM, 'socket-1')
+    expect(socket.emit).toHaveBeenCalledWith(
+      TABLE_PRESENCE_EVENTS.JOIN_ERROR,
+      expect.objectContaining({ code: 'JOIN_FAILED' })
+    )
+  })
 })

apps/realtime/src/handlers/tables.ts

@@ -223,13 +223,11 @@ export function setupTablesHandlers(socket: AuthenticatedSocket, roomManager: IR
       logger.info(`User ${userId} (${userName}) joined table room ${tableId}`)
     } catch (error) {
       logger.error('Error joining table room:', error)
-      // If a newer JOIN/LEAVE superseded this one while it ran, skip the rollback + error: the
-      // next serialized op cleans up any partial registration via its leave-prior, and the client
-      // already moved off this table so the error is moot. A disconnect (not a supersession) still
-      // falls through and rolls back — hence the generation-only check, not the full `superseded`.
-      if (joinGeneration !== joinAttempt) return
-      // Roll back any partial join so a failed attempt can't leave the socket in the
-      // Socket.IO room or a stale presence entry behind, before signalling a retry.
+      // Always roll back a partial join: cleanup keys off the socket→room map, so a `socket.join`
+      // that landed without a matching `addUserToRoom` (a throw in between) would otherwise leave
+      // the socket stranded in the Socket.IO room, unreclaimable by any later op. Safe to run even
+      // when superseded — serialization means the newer op hasn't committed yet, so this touches
+      // only this join's own (this-table) state, never the newer op's room.
       try {
         const room = tableRoom(tableId)
         socket.leave(roomName(room))