chore(release): 2.6.0 [skip ci]

## [2.6.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v2.5.0...v2.6.0) (2025-10-08)

### Features

* refactor room addressing to /arcade/room ([e7d2a73](e7d2a73ddf))

CHANGELOG.md

@@ -1,3 +1,24 @@
+## [2.6.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v2.5.0...v2.6.0) (2025-10-08)
+
+
+### Features
+
+* refactor room addressing to /arcade/room ([e7d2a73](https://github.com/antialias/soroban-abacus-flashcards/commit/e7d2a73ddf2048691325a18e3d71a7ece444c131))
+
+## [2.5.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v2.4.6...v2.5.0) (2025-10-08)
+
+
+### Features
+
+* display room info and network players in mini app nav ([5e3261f](https://github.com/antialias/soroban-abacus-flashcards/commit/5e3261f3bec8c19ec88c9a35a7e6ef8eda88a55e))
+
+## [2.4.6](https://github.com/antialias/soroban-abacus-flashcards/compare/v2.4.5...v2.4.6) (2025-10-08)
+
+
+### Bug Fixes
+
+* real-time room member updates via globalThis socket.io sharing ([94a1d9b](https://github.com/antialias/soroban-abacus-flashcards/commit/94a1d9b11058bfb4b54a4753e143cf85f215e913))
+
 ## [2.4.5](https://github.com/antialias/soroban-abacus-flashcards/compare/v2.4.4...v2.4.5) (2025-10-08)
 
 

apps/web/__tests__/room-realtime-updates.e2e.test.ts

@@ -0,0 +1,371 @@
+/**
+ * @vitest-environment node
+ */
+
+import { createServer } from 'http'
+import { eq } from 'drizzle-orm'
+import { io as ioClient, type Socket } from 'socket.io-client'
+import { afterEach, beforeEach, describe, expect, it, afterAll, beforeAll } from 'vitest'
+import { db, schema } from '../src/db'
+import { createRoom } from '../src/lib/arcade/room-manager'
+import { addRoomMember } from '../src/lib/arcade/room-membership'
+import { initializeSocketServer } from '../socket-server'
+import type { Server as SocketIOServerType } from 'socket.io'
+
+/**
+ * Real-time Room Updates E2E Tests
+ *
+ * Tests that socket broadcasts work correctly when users join/leave rooms.
+ * Simulates multiple connected users and verifies they receive real-time updates.
+ */
+
+describe('Room Real-time Updates', () => {
+  let testUserId1: string
+  let testUserId2: string
+  let testGuestId1: string
+  let testGuestId2: string
+  let testRoomId: string
+  let socket1: Socket
+  let httpServer: any
+  let io: SocketIOServerType
+  let serverPort: number
+
+  beforeAll(async () => {
+    // Create HTTP server and initialize Socket.IO for testing
+    httpServer = createServer()
+    io = initializeSocketServer(httpServer)
+
+    // Find an available port
+    await new Promise<void>((resolve) => {
+      httpServer.listen(0, () => {
+        serverPort = (httpServer.address() as any).port
+        console.log(`Test socket server listening on port ${serverPort}`)
+        resolve()
+      })
+    })
+  })
+
+  afterAll(async () => {
+    // Close all socket connections
+    if (io) {
+      io.close()
+    }
+    if (httpServer) {
+      await new Promise<void>((resolve) => {
+        httpServer.close(() => resolve())
+      })
+    }
+  })
+
+  beforeEach(async () => {
+    // Create test users
+    testGuestId1 = `test-guest-${Date.now()}-${Math.random().toString(36).slice(2)}`
+    testGuestId2 = `test-guest-${Date.now()}-${Math.random().toString(36).slice(2)}`
+
+    const [user1] = await db.insert(schema.users).values({ guestId: testGuestId1 }).returning()
+    const [user2] = await db.insert(schema.users).values({ guestId: testGuestId2 }).returning()
+
+    testUserId1 = user1.id
+    testUserId2 = user2.id
+
+    // Create a test room
+    const room = await createRoom({
+      name: 'Realtime Test Room',
+      createdBy: testGuestId1,
+      creatorName: 'User 1',
+      gameName: 'matching',
+      gameConfig: { difficulty: 6 },
+      ttlMinutes: 60,
+    })
+    testRoomId = room.id
+  })
+
+  afterEach(async () => {
+    // Disconnect sockets
+    if (socket1?.connected) {
+      socket1.disconnect()
+    }
+
+    // Clean up room members
+    await db.delete(schema.roomMembers).where(eq(schema.roomMembers.roomId, testRoomId))
+
+    // Clean up rooms
+    if (testRoomId) {
+      await db.delete(schema.arcadeRooms).where(eq(schema.arcadeRooms.id, testRoomId))
+    }
+
+    // Clean up users
+    await db.delete(schema.users).where(eq(schema.users.id, testUserId1))
+    await db.delete(schema.users).where(eq(schema.users.id, testUserId2))
+  })
+
+  it('should broadcast member-joined when a user joins via API', async () => {
+    // User 1 joins the room via API first (this is what happens when they click "Join Room")
+    await addRoomMember({
+      roomId: testRoomId,
+      userId: testGuestId1,
+      displayName: 'User 1',
+      isCreator: false,
+    })
+
+    // User 1 connects to socket
+    socket1 = ioClient(`http://localhost:${serverPort}`, {
+      path: '/api/socket',
+      transports: ['websocket'],
+    })
+
+    // Wait for socket to connect
+    await new Promise<void>((resolve, reject) => {
+      socket1.on('connect', () => resolve())
+      socket1.on('connect_error', (err) => reject(err))
+      setTimeout(() => reject(new Error('Connection timeout')), 2000)
+    })
+
+    // Small delay to ensure event handlers are set up
+    await new Promise((resolve) => setTimeout(resolve, 50))
+
+    // Set up listener for room-joined BEFORE emitting
+    const roomJoinedPromise = new Promise<void>((resolve, reject) => {
+      socket1.on('room-joined', () => resolve())
+      socket1.on('room-error', (err) => reject(new Error(err.error)))
+      setTimeout(() => reject(new Error('Room-joined timeout')), 3000)
+    })
+
+    // Now emit the join-room event
+    socket1.emit('join-room', { roomId: testRoomId, userId: testGuestId1 })
+
+    // Wait for confirmation
+    await roomJoinedPromise
+
+    // Set up listener for member-joined event BEFORE User 2 joins
+    const memberJoinedPromise = new Promise<any>((resolve, reject) => {
+      socket1.on('member-joined', (data) => {
+        resolve(data)
+      })
+      setTimeout(() => reject(new Error('Timeout waiting for member-joined event')), 3000)
+    })
+
+    // User 2 joins the room via addRoomMember
+    const { member: newMember } = await addRoomMember({
+      roomId: testRoomId,
+      userId: testGuestId2,
+      displayName: 'User 2',
+      isCreator: false,
+    })
+
+    // Manually trigger the broadcast (this is what the API route SHOULD do)
+    const { getRoomMembers } = await import('../src/lib/arcade/room-membership')
+    const { getRoomActivePlayers } = await import('../src/lib/arcade/player-manager')
+
+    const members = await getRoomMembers(testRoomId)
+    const memberPlayers = await getRoomActivePlayers(testRoomId)
+
+    const memberPlayersObj: Record<string, any[]> = {}
+    for (const [uid, players] of memberPlayers.entries()) {
+      memberPlayersObj[uid] = players
+    }
+
+    io.to(`room:${testRoomId}`).emit('member-joined', {
+      roomId: testRoomId,
+      userId: testGuestId2,
+      members,
+      memberPlayers: memberPlayersObj,
+    })
+
+    // Wait for the socket broadcast with timeout
+    const data = await memberJoinedPromise
+
+    // Verify the broadcast data
+    expect(data).toBeDefined()
+    expect(data.roomId).toBe(testRoomId)
+    expect(data.userId).toBe(testGuestId2)
+    expect(data.members).toBeDefined()
+    expect(Array.isArray(data.members)).toBe(true)
+
+    // Verify both users are in the members list
+    const memberUserIds = data.members.map((m: any) => m.userId)
+    expect(memberUserIds).toContain(testGuestId1)
+    expect(memberUserIds).toContain(testGuestId2)
+
+    // Verify the new member details
+    const addedMember = data.members.find((m: any) => m.userId === testGuestId2)
+    expect(addedMember).toBeDefined()
+    expect(addedMember.displayName).toBe('User 2')
+    expect(addedMember.roomId).toBe(testRoomId)
+  })
+
+  it('should broadcast member-left when a user leaves via API', async () => {
+    // User 1 joins the room first
+    await addRoomMember({
+      roomId: testRoomId,
+      userId: testGuestId1,
+      displayName: 'User 1',
+      isCreator: false,
+    })
+
+    // User 2 joins the room
+    await addRoomMember({
+      roomId: testRoomId,
+      userId: testGuestId2,
+      displayName: 'User 2',
+      isCreator: false,
+    })
+
+    // User 1 connects to socket
+    socket1 = ioClient(`http://localhost:${serverPort}`, {
+      path: '/api/socket',
+      transports: ['websocket'],
+    })
+
+    await new Promise<void>((resolve) => {
+      socket1.on('connect', () => resolve())
+    })
+
+    socket1.emit('join-room', { roomId: testRoomId, userId: testGuestId1 })
+
+    await new Promise<void>((resolve) => {
+      socket1.on('room-joined', () => resolve())
+    })
+
+    // Set up listener for member-left event
+    const memberLeftPromise = new Promise<any>((resolve) => {
+      socket1.on('member-left', (data) => {
+        resolve(data)
+      })
+    })
+
+    // User 2 leaves the room via API
+    await db.delete(schema.roomMembers).where(eq(schema.roomMembers.userId, testGuestId2))
+
+    // Manually trigger the leave broadcast (simulating what the API does)
+    const { getSocketIO } = await import('../src/lib/socket-io')
+    const io = await getSocketIO()
+    if (io) {
+      const { getRoomMembers } = await import('../src/lib/arcade/room-membership')
+      const { getRoomActivePlayers } = await import('../src/lib/arcade/player-manager')
+
+      const members = await getRoomMembers(testRoomId)
+      const memberPlayers = await getRoomActivePlayers(testRoomId)
+
+      const memberPlayersObj: Record<string, any[]> = {}
+      for (const [uid, players] of memberPlayers.entries()) {
+        memberPlayersObj[uid] = players
+      }
+
+      io.to(`room:${testRoomId}`).emit('member-left', {
+        roomId: testRoomId,
+        userId: testGuestId2,
+        members,
+        memberPlayers: memberPlayersObj,
+      })
+    }
+
+    // Wait for the socket broadcast with timeout
+    const data = await Promise.race([
+      memberLeftPromise,
+      new Promise((_, reject) =>
+        setTimeout(() => reject(new Error('Timeout waiting for member-left event')), 2000)
+      ),
+    ])
+
+    // Verify the broadcast data
+    expect(data).toBeDefined()
+    expect(data.roomId).toBe(testRoomId)
+    expect(data.userId).toBe(testGuestId2)
+    expect(data.members).toBeDefined()
+    expect(Array.isArray(data.members)).toBe(true)
+
+    // Verify User 2 is no longer in the members list
+    const memberUserIds = data.members.map((m: any) => m.userId)
+    expect(memberUserIds).toContain(testGuestId1)
+    expect(memberUserIds).not.toContain(testGuestId2)
+  })
+
+  it('should update both members and players lists in member-joined broadcast', async () => {
+    // Create an active player for User 2
+    const [player2] = await db
+      .insert(schema.players)
+      .values({
+        userId: testUserId2,
+        name: 'Player 2',
+        emoji: '🎮',
+        color: '#3b82f6',
+        isActive: true,
+      })
+      .returning()
+
+    // User 1 connects and joins room
+    socket1 = ioClient(`http://localhost:${serverPort}`, {
+      path: '/api/socket',
+      transports: ['websocket'],
+    })
+
+    await new Promise<void>((resolve) => {
+      socket1.on('connect', () => resolve())
+    })
+
+    socket1.emit('join-room', { roomId: testRoomId, userId: testGuestId1 })
+
+    await new Promise<void>((resolve) => {
+      socket1.on('room-joined', () => resolve())
+    })
+
+    const memberJoinedPromise = new Promise<any>((resolve) => {
+      socket1.on('member-joined', (data) => {
+        resolve(data)
+      })
+    })
+
+    // User 2 joins via API
+    await addRoomMember({
+      roomId: testRoomId,
+      userId: testGuestId2,
+      displayName: 'User 2',
+      isCreator: false,
+    })
+
+    // Manually trigger the broadcast (simulating what the API does)
+    const { getRoomMembers: getRoomMembers3 } = await import('../src/lib/arcade/room-membership')
+    const { getRoomActivePlayers: getRoomActivePlayers3 } = await import(
+      '../src/lib/arcade/player-manager'
+    )
+
+    const members2 = await getRoomMembers3(testRoomId)
+    const memberPlayers2 = await getRoomActivePlayers3(testRoomId)
+
+    const memberPlayersObj2: Record<string, any[]> = {}
+    for (const [uid, players] of memberPlayers2.entries()) {
+      memberPlayersObj2[uid] = players
+    }
+
+    io.to(`room:${testRoomId}`).emit('member-joined', {
+      roomId: testRoomId,
+      userId: testGuestId2,
+      members: members2,
+      memberPlayers: memberPlayersObj2,
+    })
+
+    const data = await Promise.race([
+      memberJoinedPromise,
+      new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), 2000)),
+    ])
+
+    // Verify members list is updated
+    expect(data.members).toBeDefined()
+    const memberUserIds = data.members.map((m: any) => m.userId)
+    expect(memberUserIds).toContain(testGuestId2)
+
+    // Verify players list is updated
+    expect(data.memberPlayers).toBeDefined()
+    expect(data.memberPlayers[testGuestId2]).toBeDefined()
+    expect(Array.isArray(data.memberPlayers[testGuestId2])).toBe(true)
+
+    // User 2's players should include the active player we created
+    const user2Players = data.memberPlayers[testGuestId2]
+    expect(user2Players.length).toBeGreaterThan(0)
+    expect(user2Players.some((p: any) => p.id === player2.id)).toBe(true)
+
+    // Clean up player
+    await db.delete(schema.players).where(eq(schema.players.id, player2.id))
+  })
+})

apps/web/socket-server.js

@@ -1,29 +0,0 @@
-const { Server } = require('socket.io')
-
-function initializeSocketServer(httpServer) {
-  const io = new Server(httpServer, {
-    path: '/api/socket',
-    cors: {
-      origin: process.env.NEXT_PUBLIC_URL || 'http://localhost:3000',
-      credentials: true,
-    },
-  })
-
-  io.on('connection', (socket) => {
-    console.log('🔌 Client connected:', socket.id)
-
-    socket.on('join-arcade-session', ({ userId }) => {
-      socket.join(`arcade:${userId}`)
-      console.log(`👤 User ${userId} joined arcade room`)
-    })
-
-    socket.on('disconnect', () => {
-      console.log('🔌 Client disconnected:', socket.id)
-    })
-  })
-
-  console.log('✅ Socket.IO initialized on /api/socket')
-  return io
-}
-
-module.exports = { initializeSocketServer }

apps/web/socket-server.ts

@@ -14,19 +14,22 @@ import { getRoomActivePlayers } from './src/lib/arcade/player-manager'
 import type { GameMove, GameName } from './src/lib/arcade/validation'
 import { matchingGameValidator } from './src/lib/arcade/validation/MatchingGameValidator'
 
-// Global socket.io server instance
-let io: SocketIOServerType | null = null
+// Use globalThis to store socket.io instance to avoid module isolation issues
+// This ensures the same instance is accessible across dynamic imports
+declare global {
+  var __socketIO: SocketIOServerType | undefined
+}
 
 /**
  * Get the socket.io server instance
  * Returns null if not initialized
  */
 export function getSocketIO(): SocketIOServerType | null {
-  return io
+  return globalThis.__socketIO || null
 }
 
 export function initializeSocketServer(httpServer: HTTPServer) {
-  io = new SocketIOServer(httpServer, {
+  const io = new SocketIOServer(httpServer, {
     path: '/api/socket',
     cors: {
       origin: process.env.NEXT_PUBLIC_URL || 'http://localhost:3000',
@@ -150,7 +153,7 @@ export function initializeSocketServer(httpServer: HTTPServer) {
             // Notify all connected clients about the new session
             const newSession = await getArcadeSession(data.userId)
             if (newSession) {
-              io.to(`arcade:${data.userId}`).emit('session-state', {
+              io!.to(`arcade:${data.userId}`).emit('session-state', {
                 gameState: newSession.gameState,
                 currentGame: newSession.currentGame,
                 gameUrl: newSession.gameUrl,
@@ -166,7 +169,7 @@ export function initializeSocketServer(httpServer: HTTPServer) {
 
         if (result.success && result.session) {
           // Broadcast the updated state to all devices for this user
-          io.to(`arcade:${data.userId}`).emit('move-accepted', {
+          io!.to(`arcade:${data.userId}`).emit('move-accepted', {
             gameState: result.session.gameState,
             version: result.session.version,
             move: data.move,
@@ -197,7 +200,7 @@ export function initializeSocketServer(httpServer: HTTPServer) {
 
       try {
         await deleteArcadeSession(userId)
-        io.to(`arcade:${userId}`).emit('session-ended')
+        io!.to(`arcade:${userId}`).emit('session-ended')
       } catch (error) {
         console.error('Error ending session:', error)
         socket.emit('session-error', { error: 'Failed to end session' })
@@ -279,7 +282,7 @@ export function initializeSocketServer(httpServer: HTTPServer) {
         }
 
         // Notify remaining members
-        io.to(`room:${roomId}`).emit('member-left', {
+        io!.to(`room:${roomId}`).emit('member-left', {
           roomId,
           userId,
           members,
@@ -307,7 +310,7 @@ export function initializeSocketServer(httpServer: HTTPServer) {
         }
 
         // Broadcast to all members in the room (including sender)
-        io.to(`room:${roomId}`).emit('room-players-updated', {
+        io!.to(`room:${roomId}`).emit('room-players-updated', {
           roomId,
           memberPlayers: memberPlayersObj,
         })
@@ -328,6 +331,8 @@ export function initializeSocketServer(httpServer: HTTPServer) {
     })
   })
 
+  // Store in globalThis to make accessible across module boundaries
+  globalThis.__socketIO = io
   console.log('✅ Socket.IO initialized on /api/socket')
   return io
 }

apps/web/src/app/api/arcade/rooms/current/route.ts

@@ -0,0 +1,52 @@
+import { NextResponse } from 'next/server'
+import { getUserRooms } from '@/lib/arcade/room-membership'
+import { getRoomById } from '@/lib/arcade/room-manager'
+import { getRoomMembers } from '@/lib/arcade/room-membership'
+import { getRoomActivePlayers } from '@/lib/arcade/player-manager'
+import { getViewerId } from '@/lib/viewer'
+
+/**
+ * GET /api/arcade/rooms/current
+ * Returns the user's current room (if any)
+ */
+export async function GET() {
+  try {
+    const userId = await getViewerId()
+
+    // Get all rooms user is in (should be at most 1 due to modal room enforcement)
+    const roomIds = await getUserRooms(userId)
+
+    if (roomIds.length === 0) {
+      return NextResponse.json({ room: null }, { status: 200 })
+    }
+
+    const roomId = roomIds[0]
+
+    // Get room data
+    const room = await getRoomById(roomId)
+    if (!room) {
+      return NextResponse.json({ error: 'Room not found' }, { status: 404 })
+    }
+
+    // Get members
+    const members = await getRoomMembers(roomId)
+
+    // Get active players for all members
+    const memberPlayers = await getRoomActivePlayers(roomId)
+
+    // Convert Map to object for JSON serialization
+    const memberPlayersObj: Record<string, any[]> = {}
+    for (const [uid, players] of memberPlayers.entries()) {
+      memberPlayersObj[uid] = players
+    }
+
+    return NextResponse.json({
+      room,
+      members,
+      memberPlayers: memberPlayersObj,
+    })
+  } catch (error) {
+    console.error('[Current Room API] Error:', error)
+    return NextResponse.json({ error: 'Failed to fetch current room' }, { status: 500 })
+  }
+}

apps/web/src/app/arcade/room/page.tsx

@@ -0,0 +1,77 @@
+'use client'
+
+import { useRouter } from 'next/navigation'
+import { useEffect } from 'react'
+import { ArcadeGuardedPage } from '@/components/ArcadeGuardedPage'
+import { useRoomData } from '@/hooks/useRoomData'
+import { MemoryPairsGame } from '../matching/components/MemoryPairsGame'
+import { ArcadeMemoryPairsProvider } from '../matching/context/ArcadeMemoryPairsContext'
+
+/**
+ * /arcade/room - Renders the game for the user's current room
+ * Since users can only be in one room at a time, this is a simple singular route
+ */
+export default function RoomPage() {
+  const router = useRouter()
+  const { roomData, isLoading } = useRoomData()
+
+  // Redirect to arcade if no room
+  useEffect(() => {
+    if (!isLoading && !roomData) {
+      console.log('[RoomPage] No active room, redirecting to /arcade')
+      router.push('/arcade')
+    }
+  }, [isLoading, roomData, router])
+
+  // Show loading state
+  if (isLoading) {
+    return (
+      <div
+        style={{
+          display: 'flex',
+          alignItems: 'center',
+          justifyContent: 'center',
+          height: '100vh',
+          fontSize: '18px',
+          color: '#666',
+        }}
+      >
+        Loading room...
+      </div>
+    )
+  }
+
+  // Show nothing while redirecting
+  if (!roomData) {
+    return null
+  }
+
+  // Render the appropriate game based on room's gameName
+  switch (roomData.gameName) {
+    case 'matching':
+      return (
+        <ArcadeGuardedPage>
+          <ArcadeMemoryPairsProvider>
+            <MemoryPairsGame />
+          </ArcadeMemoryPairsProvider>
+        </ArcadeGuardedPage>
+      )
+
+    // TODO: Add other games (complement-race, memory-quiz, etc.)
+    default:
+      return (
+        <div
+          style={{
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+            height: '100vh',
+            fontSize: '18px',
+            color: '#666',
+          }}
+        >
+          Game "{roomData.gameName}" not yet supported
+        </div>
+      )
+  }
+}

apps/web/src/components/PageWithNav.tsx

@@ -3,6 +3,8 @@
 import React from 'react'
 import { useGameMode } from '../contexts/GameModeContext'
 import { useArcadeGuard } from '../hooks/useArcadeGuard'
+import { useRoomData } from '../hooks/useRoomData'
+import { useViewerId } from '../hooks/useViewerId'
 import { AppNavBar } from './AppNavBar'
 import { GameContextNav } from './nav/GameContextNav'
 import { PlayerConfigDialog } from './nav/PlayerConfigDialog'
@@ -30,6 +32,8 @@ export function PageWithNav({
 }: PageWithNavProps) {
   const { players, activePlayers, setActive, activePlayerCount } = useGameMode()
   const { hasActiveSession, activeSession } = useArcadeGuard({ enabled: false }) // Don't redirect, just get info
+  const { roomData, isInRoom } = useRoomData()
+  const { data: viewerId } = useViewerId()
   const [mounted, setMounted] = React.useState(false)
   const [configurePlayerId, setConfigurePlayerId] = React.useState<string | null>(null)
 
@@ -80,17 +84,33 @@ export function PageWithNav({
 
   // Compute arcade session info for display
   const roomInfo =
-    hasActiveSession && activeSession
+    isInRoom && roomData
       ? {
-          gameName: activeSession.currentGame,
-          playerCount: activePlayerCount, // TODO: Get actual player count from session when available
+          roomName: roomData.name,
+          gameName: roomData.gameName,
+          playerCount: roomData.members.length,
         }
-      : undefined
+      : hasActiveSession && activeSession
+        ? {
+            gameName: activeSession.currentGame,
+            playerCount: activePlayerCount,
+          }
+        : undefined
 
-  // Compute network players (other players in the arcade session)
-  // For now, we don't have this info in activeSession, so return empty array
-  // TODO: When arcade room system is implemented, fetch other players from session
-  const networkPlayers: Array<{ id: string; emoji?: string; name?: string }> = []
+  // Compute network players (other players in the room, excluding current user)
+  const networkPlayers: Array<{ id: string; emoji?: string; name?: string }> =
+    isInRoom && roomData
+      ? roomData.members
+          .filter((member) => member.userId !== viewerId)
+          .flatMap((member) => {
+            const memberPlayerList = roomData.memberPlayers[member.userId] || []
+            return memberPlayerList.map((player) => ({
+              id: player.id,
+              emoji: player.emoji,
+              name: `${player.name} (${member.displayName})`,
+            }))
+          })
+      : []
 
   // Create nav content if title is provided
   const navContent = navTitle ? (

apps/web/src/components/nav/GameContextNav.tsx

@@ -22,6 +22,7 @@ interface NetworkPlayer {
 }
 
 interface ArcadeRoomInfo {
+  roomName?: string
   gameName: string
   playerCount: number
 }
@@ -134,6 +135,7 @@ export function GameContextNav({
         {/* Room Info - show when in arcade session */}
         {roomInfo && !showFullscreenSelection && (
           <RoomInfo
+            roomName={roomInfo.roomName}
             gameName={roomInfo.gameName}
             playerCount={roomInfo.playerCount}
             shouldEmphasize={shouldEmphasize}

apps/web/src/components/nav/RoomInfo.tsx

@@ -1,4 +1,5 @@
 interface RoomInfoProps {
+  roomName?: string
   gameName: string
   playerCount: number
   shouldEmphasize: boolean
@@ -7,7 +8,7 @@ interface RoomInfoProps {
 /**
  * Displays current arcade room/session information
  */
-export function RoomInfo({ gameName, playerCount, shouldEmphasize }: RoomInfoProps) {
+export function RoomInfo({ roomName, gameName, playerCount, shouldEmphasize }: RoomInfoProps) {
   return (
     <div
       style={{
@@ -53,7 +54,7 @@ export function RoomInfo({ gameName, playerCount, shouldEmphasize }: RoomInfoPro
             letterSpacing: '0.5px',
           }}
         >
-          Arcade Session
+          {roomName ? 'Room' : 'Arcade Session'}
         </div>
         <div
           style={{
@@ -61,7 +62,7 @@ export function RoomInfo({ gameName, playerCount, shouldEmphasize }: RoomInfoPro
             fontWeight: 'bold',
           }}
         >
-          {gameName}
+          {roomName || gameName}
         </div>
       </div>
 

apps/web/src/hooks/useRoomData.ts

@@ -0,0 +1,203 @@
+import { useEffect, useState } from 'react'
+import { io, type Socket } from 'socket.io-client'
+import { useViewerId } from './useViewerId'
+
+export interface RoomMember {
+  id: string
+  userId: string
+  displayName: string
+  isOnline: boolean
+  isCreator: boolean
+}
+
+export interface RoomPlayer {
+  id: string
+  name: string
+  emoji: string
+  color: string
+}
+
+export interface RoomData {
+  id: string
+  name: string
+  code: string
+  gameName: string
+  members: RoomMember[]
+  memberPlayers: Record<string, RoomPlayer[]> // userId -> players
+}
+
+/**
+ * Hook to fetch and subscribe to the user's current room data
+ * Returns null if user is not in any room
+ */
+export function useRoomData() {
+  const { data: userId } = useViewerId()
+  const [socket, setSocket] = useState<Socket | null>(null)
+  const [roomData, setRoomData] = useState<RoomData | null>(null)
+  const [isLoading, setIsLoading] = useState(false)
+
+  // Fetch the user's current room
+  useEffect(() => {
+    if (!userId) {
+      setRoomData(null)
+      return
+    }
+
+    setIsLoading(true)
+
+    // Fetch current room data
+    fetch('/api/arcade/rooms/current')
+      .then((res) => {
+        if (!res.ok) throw new Error('Failed to fetch current room')
+        return res.json()
+      })
+      .then((data) => {
+        if (data.room) {
+          setRoomData({
+            id: data.room.id,
+            name: data.room.name,
+            code: data.room.code,
+            gameName: data.room.gameName,
+            members: data.members || [],
+            memberPlayers: data.memberPlayers || {},
+          })
+        } else {
+          setRoomData(null)
+        }
+        setIsLoading(false)
+      })
+      .catch((error) => {
+        console.error('Failed to fetch room data:', error)
+        setRoomData(null)
+        setIsLoading(false)
+      })
+  }, [userId])
+
+  // Initialize socket connection when user has a room
+  useEffect(() => {
+    if (!roomData?.id || !userId) {
+      if (socket) {
+        socket.disconnect()
+        setSocket(null)
+      }
+      return
+    }
+
+    const sock = io({ path: '/api/socket' })
+
+    sock.on('connect', () => {
+      console.log('[useRoomData] Socket connected, joining room:', roomData.id)
+      // Join the room to receive updates
+      sock.emit('join-room', { roomId: roomData.id, userId })
+    })
+
+    sock.on('disconnect', () => {
+      console.log('[useRoomData] Socket disconnected')
+    })
+
+    setSocket(sock)
+
+    return () => {
+      if (sock.connected) {
+        // Leave the room before disconnecting
+        sock.emit('leave-room', { roomId: roomData.id, userId })
+        sock.disconnect()
+      }
+    }
+  }, [roomData?.id, userId])
+
+  // Subscribe to real-time updates via socket
+  useEffect(() => {
+    if (!socket || !roomData?.id) return
+
+    const handleRoomJoined = (data: {
+      roomId: string
+      members: RoomMember[]
+      memberPlayers: Record<string, RoomPlayer[]>
+    }) => {
+      console.log('[useRoomData] Received room-joined event:', data)
+      if (data.roomId === roomData.id) {
+        setRoomData((prev) => {
+          if (!prev) return null
+          return {
+            ...prev,
+            members: data.members,
+            memberPlayers: data.memberPlayers,
+          }
+        })
+      }
+    }
+
+    const handleMemberJoined = (data: {
+      roomId: string
+      userId: string
+      members: RoomMember[]
+      memberPlayers: Record<string, RoomPlayer[]>
+    }) => {
+      console.log('[useRoomData] Received member-joined event:', data)
+      if (data.roomId === roomData.id) {
+        setRoomData((prev) => {
+          if (!prev) return null
+          return {
+            ...prev,
+            members: data.members,
+            memberPlayers: data.memberPlayers,
+          }
+        })
+      }
+    }
+
+    const handleMemberLeft = (data: {
+      roomId: string
+      userId: string
+      members: RoomMember[]
+      memberPlayers: Record<string, RoomPlayer[]>
+    }) => {
+      console.log('[useRoomData] Received member-left event:', data)
+      if (data.roomId === roomData.id) {
+        setRoomData((prev) => {
+          if (!prev) return null
+          return {
+            ...prev,
+            members: data.members,
+            memberPlayers: data.memberPlayers,
+          }
+        })
+      }
+    }
+
+    const handleRoomPlayersUpdated = (data: {
+      roomId: string
+      memberPlayers: Record<string, RoomPlayer[]>
+    }) => {
+      console.log('[useRoomData] Received room-players-updated event:', data)
+      if (data.roomId === roomData.id) {
+        setRoomData((prev) => {
+          if (!prev) return null
+          return {
+            ...prev,
+            memberPlayers: data.memberPlayers,
+          }
+        })
+      }
+    }
+
+    socket.on('room-joined', handleRoomJoined)
+    socket.on('member-joined', handleMemberJoined)
+    socket.on('member-left', handleMemberLeft)
+    socket.on('room-players-updated', handleRoomPlayersUpdated)
+
+    return () => {
+      socket.off('room-joined', handleRoomJoined)
+      socket.off('member-joined', handleMemberJoined)
+      socket.off('member-left', handleMemberLeft)
+      socket.off('room-players-updated', handleRoomPlayersUpdated)
+    }
+  }, [socket, roomData?.id])
+
+  return {
+    roomData,
+    isLoading,
+    isInRoom: !!roomData,
+  }
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "soroban-monorepo",
-  "version": "2.4.5",
+  "version": "2.6.0",
   "private": true,
   "description": "Beautiful Soroban Flashcard Generator - Monorepo",
   "workspaces": [