chore(release): 3.24.0 [skip ci]

## [3.24.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v3.23.0...v3.24.0) (2025-10-16)

### Features

* **math-sprint:** add game manifest ([1eefcc8](1eefcc89a5))

CHANGELOG.md

@@ -1,3 +1,29 @@
+## [3.24.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v3.23.0...v3.24.0) (2025-10-16)
+
+
+### Features
+
+* **math-sprint:** add game manifest ([1eefcc8](https://github.com/antialias/soroban-abacus-flashcards/commit/1eefcc89a58b79f928932a7425d6b88fb45a5526))
+
+## [3.23.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v3.22.3...v3.23.0) (2025-10-16)
+
+
+### Features
+
+* **arcade:** add Math Sprint game implementation ([e5be09e](https://github.com/antialias/soroban-abacus-flashcards/commit/e5be09ef5f170c7544557f75b9eca17bb2069246))
+* **arcade:** register Math Sprint in game system ([0c05a7c](https://github.com/antialias/soroban-abacus-flashcards/commit/0c05a7c6bbc8d6f6e1f92e15e691d7e1aba0d8f7)), closes [#2](https://github.com/antialias/soroban-abacus-flashcards/issues/2) [#3](https://github.com/antialias/soroban-abacus-flashcards/issues/3)
+
+
+### Bug Fixes
+
+* **api:** add 'math-sprint' to settings endpoint validation ([d790e5e](https://github.com/antialias/soroban-abacus-flashcards/commit/d790e5e278f81686077dbe3ef4adca49574ae434)), closes [#1](https://github.com/antialias/soroban-abacus-flashcards/issues/1)
+* **db:** add 'math-sprint' to database schema enums ([7b112a9](https://github.com/antialias/soroban-abacus-flashcards/commit/7b112a98babe782d4c254ef18a0295e7cbf8fefa)), closes [#1](https://github.com/antialias/soroban-abacus-flashcards/issues/1)
+
+
+### Documentation
+
+* add architecture quality audit [#2](https://github.com/antialias/soroban-abacus-flashcards/issues/2) ([5b91b71](https://github.com/antialias/soroban-abacus-flashcards/commit/5b91b710782dc450405583bc196e5156a296d0df))
+
 ## [3.22.3](https://github.com/antialias/soroban-abacus-flashcards/compare/v3.22.2...v3.22.3) (2025-10-16)
 
 

apps/web/docs/AUDIT_2_ARCHITECTURE_QUALITY.md

@@ -0,0 +1,451 @@
+# Architecture Quality Audit #2
+
+**Date**: 2025-10-16
+**Context**: After implementing Number Guesser (turn-based) and starting Math Sprint (free-for-all)
+**Goal**: Assess if the system is truly modular or if there's too much boilerplate
+
+---
+
+## Executive Summary
+
+**Status**: ⚠️ **Good Foundation, But Boilerplate Issues**
+
+The unified validator registry successfully solved the dual registration problem. However, implementing a second game revealed **significant boilerplate** and **database schema coupling** that violate the modular architecture goals.
+
+**Grade**: **B-** (Down from B+ after implementation testing)
+
+---
+
+## Issues Found
+
+### 🚨 Issue #1: Database Schema Coupling (CRITICAL)
+
+**Problem**: The `room_game_configs` table schema hard-codes game names, preventing true modularity.
+
+**Evidence**:
+```typescript
+// db/schema/room-game-configs.ts
+gameName: text('game_name').$type<'matching' | 'memory-quiz' | 'number-guesser' | 'complement-race'>()
+```
+
+When adding 'math-sprint':
+```
+Type '"math-sprint"' is not assignable to type '"matching" | "memory-quiz" | "number-guesser" | "complement-race"'
+```
+
+**Impact**:
+- ❌ Must manually update database schema for every new game
+- ❌ TypeScript errors force schema migration
+- ❌ Breaks "just register and go" promise
+- ❌ Requires database migration for each game
+
+**Root Cause**: The schema uses a union type instead of a string with runtime validation.
+
+**Fix Required**: Change schema to accept any string, validate against registry at runtime.
+
+---
+
+### ⚠️ Issue #2: game-config-helpers.ts Boilerplate
+
+**Problem**: Three switch statements must be updated for every new game:
+
+1. `getDefaultGameConfig()` - add case
+2. Import default config constant
+3. `validateGameConfig()` - add validation logic
+
+**Example** (from Math Sprint):
+```typescript
+// Must add to imports
+import { DEFAULT_MATH_SPRINT_CONFIG } from './game-configs'
+
+// Must add case to switch #1
+case 'math-sprint':
+  return DEFAULT_MATH_SPRINT_CONFIG
+
+// Must add case to switch #2
+case 'math-sprint':
+  return (
+    typeof config === 'object' &&
+    config !== null &&
+    ['easy', 'medium', 'hard'].includes(config.difficulty) &&
+    // ... 10+ lines of validation
+  )
+```
+
+**Impact**:
+- ⏱️ 5-10 minutes of boilerplate per game
+- 🐛 Easy to forget a switch case
+- 📝 Repetitive validation logic
+
+**Better Approach**: Config defaults and validation should be part of the game definition.
+
+---
+
+### ⚠️ Issue #3: game-configs.ts Boilerplate
+
+**Problem**: Must update 4 places in game-configs.ts:
+
+1. Import types from game
+2. Define `XGameConfig` interface
+3. Add to `GameConfigByName` union
+4. Add to `RoomGameConfig` interface
+5. Create `DEFAULT_X_CONFIG` constant
+
+**Example** (from Math Sprint):
+```typescript
+// 1. Import
+import type { Difficulty as MathSprintDifficulty } from '@/arcade-games/math-sprint/types'
+
+// 2. Interface
+export interface MathSprintGameConfig {
+  difficulty: MathSprintDifficulty
+  questionsPerRound: number
+  timePerQuestion: number
+}
+
+// 3. Add to union
+export type GameConfigByName = {
+  'math-sprint': MathSprintGameConfig
+  // ...
+}
+
+// 4. Add to RoomGameConfig
+export interface RoomGameConfig {
+  'math-sprint'?: MathSprintGameConfig
+  // ...
+}
+
+// 5. Default constant
+export const DEFAULT_MATH_SPRINT_CONFIG: MathSprintGameConfig = {
+  difficulty: 'medium',
+  questionsPerRound: 10,
+  timePerQuestion: 30,
+}
+```
+
+**Impact**:
+- ⏱️ 10-15 lines of boilerplate per game
+- 🐛 Easy to forget one of the 5 updates
+- 🔄 Repeating type information (already in game definition)
+
+**Better Approach**: Game config types should be inferred from game definitions.
+
+---
+
+### 📊 Issue #4: High Boilerplate Ratio
+
+**Files Required Per Game**:
+
+| Category | Files | Purpose |
+|----------|-------|---------|
+| **Game Code** | 7 files | types.ts, Validator.ts, Provider.tsx, index.ts, 3x components |
+| **Registration** | 2 files | validators.ts, game-registry.ts |
+| **Config** | 2 files | game-configs.ts, game-config-helpers.ts |
+| **Database** | 1 file | schema migration |
+| **Total** | **12 files** | For one game! |
+
+**Lines of Boilerplate** (non-game-logic):
+- game-configs.ts: ~15 lines
+- game-config-helpers.ts: ~25 lines
+- validators.ts: ~2 lines
+- game-registry.ts: ~2 lines
+- **Total: ~44 lines of pure boilerplate per game**
+
+**Comparison**:
+- Number Guesser: ~500 lines of actual game logic
+- Boilerplate: ~44 lines (8.8% overhead) ✅ Acceptable
+- But spread across 4 different files ⚠️ Developer friction
+
+---
+
+## Positive Aspects
+
+### ✅ What Works Well
+
+1. **SDK Abstraction**
+   - `useArcadeSession` is clean and reusable
+   - `buildPlayerMetadata` helper reduces duplication
+   - Hook-based API is intuitive
+
+2. **Provider Pattern**
+   - Consistent across games
+   - Clear separation of concerns
+   - Easy to understand
+
+3. **Component Structure**
+   - SetupPhase, PlayingPhase, ResultsPhase pattern is clear
+   - GameComponent wrapper is simple
+   - PageWithNav integration is seamless
+
+4. **Unified Validator Registry**
+   - Single source of truth for validators ✅
+   - Auto-derived GameName type ✅
+   - Type-safe validator access ✅
+
+5. **Error Feedback**
+   - lastError/clearError pattern works well
+   - Auto-dismiss UX is good
+   - Consistent error handling
+
+---
+
+## Comparison: Number Guesser vs. Math Sprint
+
+### Similarities (Good!)
+- ✅ Same file structure
+- ✅ Same SDK usage patterns
+- ✅ Same Provider pattern
+- ✅ Same component phases
+
+### Differences (Revealing!)
+- Math Sprint uses TEAM_MOVE (no turn owner)
+- Math Sprint has server-generated questions
+- Database schema didn't support Math Sprint name
+
+**Key Insight**: The SDK handles different game types well (turn-based vs. free-for-all), but infrastructure (database, config system) is rigid.
+
+---
+
+## Developer Experience Score
+
+### Time to Add a Game
+
+| Task | Time | Notes |
+|------|------|-------|
+| Write game logic | 2-4 hours | Validator, state management, components |
+| Registration boilerplate | 15-20 min | 4 files to update |
+| Database migration | 10-15 min | Schema update, migration file |
+| Debugging type errors | 10-30 min | Database schema mismatches |
+| **Total** | **3-5 hours** | For a simple game |
+
+### Pain Points
+
+1. **Database Schema** ⚠️ Critical blocker
+   - Must update schema for each game
+   - Requires migration
+   - TypeScript errors are confusing
+
+2. **Config System** ⚠️ Medium friction
+   - 5 places to update in game-configs.ts
+   - Easy to miss one
+   - Repetitive type definitions
+
+3. **Helper Functions** ⚠️ Low friction
+   - Switch statements in game-config-helpers.ts
+   - Not hard, just tedious
+
+### What Developers Like
+
+1. ✅ SDK is intuitive
+2. ✅ Pattern is consistent
+3. ✅ Error messages are clear (once you know where to look)
+4. ✅ Documentation is comprehensive
+
+---
+
+## Architectural Recommendations
+
+### Critical (Before Adding More Games)
+
+**1. Fix Database Schema Coupling**
+
+**Current**:
+```typescript
+gameName: text('game_name').$type<'matching' | 'memory-quiz' | 'number-guesser' | 'complement-race'>()
+```
+
+**Recommended**:
+```typescript
+// Accept any string, validate at runtime
+gameName: text('game_name').$type<string>().notNull()
+
+// Runtime validation in helper functions
+export function validateGameName(gameName: string): gameName is GameName {
+  return hasValidator(gameName)
+}
+```
+
+**Benefits**:
+- ✅ No schema migration per game
+- ✅ Works with auto-derived GameName
+- ✅ Runtime validation is sufficient
+
+---
+
+**2. Infer Config Types from Game Definitions**
+
+**Current** (manual):
+```typescript
+// In game-configs.ts
+export interface MathSprintGameConfig { ... }
+export const DEFAULT_MATH_SPRINT_CONFIG = { ... }
+
+// In game definition
+const defaultConfig: MathSprintGameConfig = { ... }
+```
+
+**Recommended**:
+```typescript
+// In game definition (single source of truth)
+export const mathSprintGame = defineGame({
+  defaultConfig: {
+    difficulty: 'medium',
+    questionsPerRound: 10,
+    timePerQuestion: 30,
+  },
+  validator: mathSprintValidator,
+  // ...
+})
+
+// Auto-infer types
+type MathSprintConfig = typeof mathSprintGame.defaultConfig
+```
+
+**Benefits**:
+- ✅ No duplication
+- ✅ Single source of truth
+- ✅ Type inference handles it
+
+---
+
+**3. Move Config Validation to Game Definition**
+
+**Current** (switch statement in helper):
+```typescript
+function validateGameConfig(gameName: GameName, config: any): boolean {
+  switch (gameName) {
+    case 'math-sprint':
+      return /* 15 lines of validation */
+  }
+}
+```
+
+**Recommended**:
+```typescript
+// In game definition
+export const mathSprintGame = defineGame({
+  defaultConfig: { ... },
+  validateConfig: (config: any): config is MathSprintConfig => {
+    return /* validation logic */
+  },
+  // ...
+})
+
+// In helper (generic)
+export function validateGameConfig(gameName: GameName, config: any): boolean {
+  const game = getGame(gameName)
+  return game?.validateConfig?.(config) ?? true
+}
+```
+
+**Benefits**:
+- ✅ No switch statement
+- ✅ Validation lives with game
+- ✅ One place to update
+
+---
+
+### Medium Priority
+
+**4. Create CLI Tool for Game Generation**
+
+```bash
+npm run create-game math-sprint "Math Sprint" "🧮"
+```
+
+Generates:
+- File structure
+- Boilerplate code
+- Registration entries
+- Types
+
+**Benefits**:
+- ✅ Eliminates manual boilerplate
+- ✅ Consistent structure
+- ✅ Reduces errors
+
+---
+
+**5. Add Runtime Registry Validation**
+
+On app start, verify:
+- ✅ All games in registry have validators
+- ✅ All validators have games
+- ✅ No orphaned configs
+- ✅ All game names are unique
+
+```typescript
+function validateRegistries() {
+  const games = getAllGames()
+  const validators = getRegisteredGameNames()
+
+  for (const game of games) {
+    if (!validators.includes(game.manifest.name)) {
+      throw new Error(`Game ${game.manifest.name} has no validator!`)
+    }
+  }
+}
+```
+
+---
+
+## Updated Compliance Table
+
+| Intention | Status | Notes |
+|-----------|--------|-------|
+| Modularity | ⚠️ Partial | Validators unified, but database/config not modular |
+| Self-registration | ✅ Pass | Two registration points (validator + game), both clear |
+| Type safety | ⚠️ Partial | Types work, but database schema breaks for new games |
+| No core changes | ⚠️ Partial | Must update 4 files + database schema |
+| Drop-in games | ❌ Fail | Database migration required |
+| Stable SDK API | ✅ Pass | SDK is excellent |
+| Clear patterns | ✅ Pass | Patterns are consistent |
+| Low boilerplate | ⚠️ Partial | SDK usage is clean, registration is verbose |
+
+**Overall Grade**: **B-** (Was B+, downgraded after implementation testing)
+
+---
+
+## Summary
+
+### What We Learned
+
+✅ **The Good**:
+- SDK design is solid
+- Unified validator registry works
+- Pattern is consistent and learnable
+- Number Guesser proves the concept
+
+⚠️ **The Not-So-Good**:
+- Database schema couples to game names (critical blocker)
+- Config system has too much boilerplate
+- 12 files touched per game is high
+
+❌ **The Bad**:
+- Can't truly "drop in" a game without schema migration
+- Config types are duplicated
+- Helper switch statements are tedious
+
+### Verdict
+
+The system **works** and is **usable**, but falls short of "modular architecture" goals due to:
+1. Database schema hard-coding
+2. Config system boilerplate
+3. Required schema migrations
+
+**Recommendation**:
+1. **Option A (Quick Fix)**: Document the 12-file checklist, live with boilerplate for now
+2. **Option B (Proper Fix)**: Implement Critical recommendations 1-3 before adding Math Sprint
+
+**My Recommendation**: Option A for now (get Math Sprint working), then Option B as a refactoring sprint.
+
+---
+
+## Next Steps
+
+1. ✅ Document "Adding a Game" checklist (12 files)
+2. 🔴 Fix database schema to accept any game name
+3. 🟡 Test Math Sprint with current architecture
+4. 🟡 Evaluate if boilerplate is acceptable in practice
+5. 🟢 Consider config system refactoring for later
+

apps/web/src/app/api/arcade/rooms/[roomId]/settings/route.ts

@@ -20,7 +20,7 @@ type RouteContext = {
  * Body:
  *   - accessMode?: 'open' | 'locked' | 'retired' | 'password' | 'restricted' | 'approval-only'
  *   - password?: string (plain text, will be hashed)
- *   - gameName?: 'matching' | 'memory-quiz' | 'complement-race' | 'number-guesser' | null (select game for room)
+ *   - gameName?: 'matching' | 'memory-quiz' | 'complement-race' | 'number-guesser' | 'math-sprint' | null (select game for room)
  *   - gameConfig?: object (game-specific settings)
  */
 export async function PATCH(req: NextRequest, context: RouteContext) {
@@ -95,7 +95,7 @@ export async function PATCH(req: NextRequest, context: RouteContext) {
     // Validate gameName if provided
     if (body.gameName !== undefined && body.gameName !== null) {
       // Legacy games + registry games (TODO: make this dynamic when we refactor to lazy-load registry)
-      const validGames = ['matching', 'memory-quiz', 'complement-race', 'number-guesser']
+      const validGames = ['matching', 'memory-quiz', 'complement-race', 'number-guesser', 'math-sprint']
       if (!validGames.includes(body.gameName)) {
         return NextResponse.json({ error: 'Invalid game name' }, { status: 400 })
       }

apps/web/src/arcade-games/math-sprint/Provider.tsx

@@ -0,0 +1,198 @@
+/**
+ * Math Sprint Provider
+ *
+ * Context provider for Math Sprint game state management.
+ * Demonstrates free-for-all gameplay with TEAM_MOVE pattern.
+ */
+
+'use client'
+
+import { createContext, useCallback, useContext, useMemo, type ReactNode } from 'react'
+import {
+  buildPlayerMetadata,
+  useArcadeSession,
+  useGameMode,
+  useRoomData,
+  useUpdateGameConfig,
+  useViewerId,
+} from '@/lib/arcade/game-sdk'
+import { TEAM_MOVE } from '@/lib/arcade/validation/types'
+import type { Difficulty, MathSprintState } from './types'
+
+/**
+ * Context value provided to child components
+ */
+interface MathSprintContextValue {
+  state: MathSprintState
+  lastError: string | null
+  startGame: () => void
+  submitAnswer: (answer: number) => void
+  nextQuestion: () => void
+  resetGame: () => void
+  setConfig: (field: 'difficulty' | 'questionsPerRound' | 'timePerQuestion', value: any) => void
+  clearError: () => void
+  exitSession: () => void
+}
+
+const MathSprintContext = createContext<MathSprintContextValue | null>(null)
+
+/**
+ * Hook to access Math Sprint context
+ */
+export function useMathSprint() {
+  const context = useContext(MathSprintContext)
+  if (!context) {
+    throw new Error('useMathSprint must be used within MathSprintProvider')
+  }
+  return context
+}
+
+/**
+ * Math Sprint Provider Component
+ */
+export function MathSprintProvider({ children }: { children: ReactNode }) {
+  const { data: viewerId } = useViewerId()
+  const { roomData } = useRoomData()
+  const { activePlayers: activePlayerIds, players } = useGameMode()
+  const { mutate: updateGameConfig } = useUpdateGameConfig()
+
+  // Get active players as array (keep Set iteration order)
+  const activePlayers = Array.from(activePlayerIds)
+
+  // Merge saved config from room with defaults
+  const gameConfig = useMemo(() => {
+    const allGameConfigs = roomData?.gameConfig as Record<string, unknown> | null | undefined
+    const savedConfig = allGameConfigs?.['math-sprint'] as Record<string, unknown> | undefined
+    return {
+      difficulty: (savedConfig?.difficulty as Difficulty) || 'medium',
+      questionsPerRound: (savedConfig?.questionsPerRound as number) || 10,
+      timePerQuestion: (savedConfig?.timePerQuestion as number) || 30,
+    }
+  }, [roomData?.gameConfig])
+
+  // Initial state with merged config
+  const initialState = useMemo<MathSprintState>(
+    () => ({
+      gamePhase: 'setup',
+      activePlayers: [],
+      playerMetadata: {},
+      difficulty: gameConfig.difficulty,
+      questionsPerRound: gameConfig.questionsPerRound,
+      timePerQuestion: gameConfig.timePerQuestion,
+      currentQuestionIndex: 0,
+      questions: [],
+      scores: {},
+      correctAnswersCount: {},
+      answers: [],
+      questionStartTime: 0,
+      questionAnswered: false,
+      winnerId: null,
+    }),
+    [gameConfig]
+  )
+
+  // Arcade session integration
+  const { state, sendMove, exitSession, lastError, clearError } =
+    useArcadeSession<MathSprintState>({
+      userId: viewerId || '',
+      roomId: roomData?.id,
+      initialState,
+      applyMove: (state) => state, // Server handles all state updates
+    })
+
+  // Action: Start game
+  const startGame = useCallback(() => {
+    const playerMetadata = buildPlayerMetadata(activePlayers, {}, players, viewerId || undefined)
+
+    sendMove({
+      type: 'START_GAME',
+      playerId: TEAM_MOVE, // Free-for-all: no specific turn owner
+      userId: viewerId || '',
+      data: { activePlayers, playerMetadata },
+    })
+  }, [activePlayers, players, viewerId, sendMove])
+
+  // Action: Submit answer
+  const submitAnswer = useCallback(
+    (answer: number) => {
+      // Find this user's player ID from game state
+      const myPlayerId = state.activePlayers.find((pid) => {
+        return state.playerMetadata[pid]?.userId === viewerId
+      })
+
+      if (!myPlayerId) {
+        console.error('[MathSprint] No player found for current user')
+        return
+      }
+
+      sendMove({
+        type: 'SUBMIT_ANSWER',
+        playerId: myPlayerId, // Specific player answering
+        userId: viewerId || '',
+        data: { answer },
+      })
+    },
+    [state.activePlayers, state.playerMetadata, viewerId, sendMove]
+  )
+
+  // Action: Next question
+  const nextQuestion = useCallback(() => {
+    sendMove({
+      type: 'NEXT_QUESTION',
+      playerId: TEAM_MOVE, // Any player can advance
+      userId: viewerId || '',
+      data: {},
+    })
+  }, [viewerId, sendMove])
+
+  // Action: Reset game
+  const resetGame = useCallback(() => {
+    sendMove({
+      type: 'RESET_GAME',
+      playerId: TEAM_MOVE,
+      userId: viewerId || '',
+      data: {},
+    })
+  }, [viewerId, sendMove])
+
+  // Action: Set config
+  const setConfig = useCallback(
+    (field: 'difficulty' | 'questionsPerRound' | 'timePerQuestion', value: any) => {
+      sendMove({
+        type: 'SET_CONFIG',
+        playerId: TEAM_MOVE,
+        userId: viewerId || '',
+        data: { field, value },
+      })
+
+      // Persist to database for next session
+      if (roomData?.id) {
+        updateGameConfig({
+          roomId: roomData.id,
+          gameConfig: {
+            ...roomData.gameConfig,
+            'math-sprint': {
+              ...(roomData.gameConfig?.['math-sprint'] || {}),
+              [field]: value,
+            },
+          },
+        })
+      }
+    },
+    [viewerId, sendMove, updateGameConfig, roomData]
+  )
+
+  const contextValue: MathSprintContextValue = {
+    state,
+    lastError,
+    startGame,
+    submitAnswer,
+    nextQuestion,
+    resetGame,
+    setConfig,
+    clearError,
+    exitSession,
+  }
+
+  return <MathSprintContext.Provider value={contextValue}>{children}</MathSprintContext.Provider>
+}

apps/web/src/arcade-games/math-sprint/Validator.ts

@@ -0,0 +1,340 @@
+/**
+ * Math Sprint Validator
+ *
+ * Server-side validation for Math Sprint game.
+ * Generates questions, validates answers, awards points.
+ */
+
+import type { GameValidator, ValidationResult } from '@/lib/arcade/game-sdk'
+import { TEAM_MOVE } from '@/lib/arcade/validation/types'
+import type {
+  Difficulty,
+  MathSprintConfig,
+  MathSprintMove,
+  MathSprintState,
+  Operation,
+  Question,
+} from './types'
+
+export class MathSprintValidator
+  implements GameValidator<MathSprintState, MathSprintMove>
+{
+  /**
+   * Validate a game move
+   */
+  validateMove(
+    state: MathSprintState,
+    move: MathSprintMove,
+    context?: { userId?: string }
+  ): ValidationResult {
+    switch (move.type) {
+      case 'START_GAME':
+        return this.validateStartGame(state, move.data.activePlayers, move.data.playerMetadata)
+
+      case 'SUBMIT_ANSWER':
+        return this.validateSubmitAnswer(
+          state,
+          move.playerId,
+          Number(move.data.answer),
+          move.timestamp
+        )
+
+      case 'NEXT_QUESTION':
+        return this.validateNextQuestion(state)
+
+      case 'RESET_GAME':
+        return this.validateResetGame(state)
+
+      case 'SET_CONFIG':
+        return this.validateSetConfig(state, move.data.field, move.data.value)
+
+      default:
+        return { valid: false, error: 'Unknown move type' }
+    }
+  }
+
+  /**
+   * Check if game is complete
+   */
+  isGameComplete(state: MathSprintState): boolean {
+    return state.gamePhase === 'results'
+  }
+
+  /**
+   * Get initial state for new game
+   */
+  getInitialState(config: unknown): MathSprintState {
+    const { difficulty, questionsPerRound, timePerQuestion } = config as MathSprintConfig
+
+    return {
+      gamePhase: 'setup',
+      activePlayers: [],
+      playerMetadata: {},
+      difficulty: difficulty || 'medium',
+      questionsPerRound: questionsPerRound || 10,
+      timePerQuestion: timePerQuestion || 30,
+      currentQuestionIndex: 0,
+      questions: [],
+      scores: {},
+      correctAnswersCount: {},
+      answers: [],
+      questionStartTime: 0,
+      questionAnswered: false,
+      winnerId: null,
+    }
+  }
+
+  // ============================================================================
+  // Validation Methods
+  // ============================================================================
+
+  private validateStartGame(
+    state: MathSprintState,
+    activePlayers: string[],
+    playerMetadata: Record<string, any>
+  ): ValidationResult {
+    if (state.gamePhase !== 'setup') {
+      return { valid: false, error: 'Game already started' }
+    }
+
+    if (activePlayers.length < 2) {
+      return { valid: false, error: 'Need at least 2 players' }
+    }
+
+    // Generate questions
+    const questions = this.generateQuestions(state.difficulty, state.questionsPerRound)
+
+    const newState: MathSprintState = {
+      ...state,
+      gamePhase: 'playing',
+      activePlayers,
+      playerMetadata,
+      questions,
+      currentQuestionIndex: 0,
+      scores: activePlayers.reduce((acc, p) => ({ ...acc, [p]: 0 }), {}),
+      correctAnswersCount: activePlayers.reduce((acc, p) => ({ ...acc, [p]: 0 }), {}),
+      answers: [],
+      questionStartTime: Date.now(),
+      questionAnswered: false,
+      winnerId: null,
+    }
+
+    return { valid: true, newState }
+  }
+
+  private validateSubmitAnswer(
+    state: MathSprintState,
+    playerId: string,
+    answer: number,
+    timestamp: number
+  ): ValidationResult {
+    if (state.gamePhase !== 'playing') {
+      return { valid: false, error: 'Game not in progress' }
+    }
+
+    if (!state.activePlayers.includes(playerId)) {
+      return { valid: false, error: 'Player not in game' }
+    }
+
+    if (state.questionAnswered) {
+      return { valid: false, error: 'Question already answered correctly' }
+    }
+
+    // Check if player already answered this question
+    const alreadyAnswered = state.answers.some((a) => a.playerId === playerId)
+    if (alreadyAnswered) {
+      return { valid: false, error: 'You already answered this question' }
+    }
+
+    const currentQuestion = state.questions[state.currentQuestionIndex]
+    const correct = answer === currentQuestion.correctAnswer
+
+    const answerRecord = {
+      playerId,
+      answer,
+      timestamp,
+      correct,
+    }
+
+    const newAnswers = [...state.answers, answerRecord]
+    let newState = { ...state, answers: newAnswers }
+
+    // If correct, award points and mark question as answered
+    if (correct) {
+      newState = {
+        ...newState,
+        questionAnswered: true,
+        winnerId: playerId,
+        scores: {
+          ...state.scores,
+          [playerId]: state.scores[playerId] + 10,
+        },
+        correctAnswersCount: {
+          ...state.correctAnswersCount,
+          [playerId]: state.correctAnswersCount[playerId] + 1,
+        },
+      }
+    }
+
+    return { valid: true, newState }
+  }
+
+  private validateNextQuestion(state: MathSprintState): ValidationResult {
+    if (state.gamePhase !== 'playing') {
+      return { valid: false, error: 'Game not in progress' }
+    }
+
+    if (!state.questionAnswered) {
+      return { valid: false, error: 'Current question not answered yet' }
+    }
+
+    const isLastQuestion = state.currentQuestionIndex >= state.questions.length - 1
+
+    if (isLastQuestion) {
+      // Game complete, go to results
+      const newState: MathSprintState = {
+        ...state,
+        gamePhase: 'results',
+      }
+      return { valid: true, newState }
+    }
+
+    // Move to next question
+    const newState: MathSprintState = {
+      ...state,
+      currentQuestionIndex: state.currentQuestionIndex + 1,
+      answers: [],
+      questionStartTime: Date.now(),
+      questionAnswered: false,
+      winnerId: null,
+    }
+
+    return { valid: true, newState }
+  }
+
+  private validateResetGame(state: MathSprintState): ValidationResult {
+    const newState = this.getInitialState({
+      difficulty: state.difficulty,
+      questionsPerRound: state.questionsPerRound,
+      timePerQuestion: state.timePerQuestion,
+    })
+
+    return { valid: true, newState }
+  }
+
+  private validateSetConfig(
+    state: MathSprintState,
+    field: string,
+    value: any
+  ): ValidationResult {
+    if (state.gamePhase !== 'setup') {
+      return { valid: false, error: 'Cannot change config during game' }
+    }
+
+    const newState = {
+      ...state,
+      [field]: value,
+    }
+
+    return { valid: true, newState }
+  }
+
+  // ============================================================================
+  // Question Generation
+  // ============================================================================
+
+  private generateQuestions(difficulty: Difficulty, count: number): Question[] {
+    const questions: Question[] = []
+
+    for (let i = 0; i < count; i++) {
+      const operation = this.randomOperation()
+      const question = this.generateQuestion(difficulty, operation, `q-${i}`)
+      questions.push(question)
+    }
+
+    return questions
+  }
+
+  private generateQuestion(
+    difficulty: Difficulty,
+    operation: Operation,
+    id: string
+  ): Question {
+    let operand1: number
+    let operand2: number
+    let correctAnswer: number
+
+    switch (difficulty) {
+      case 'easy':
+        operand1 = this.randomInt(1, 10)
+        operand2 = this.randomInt(1, 10)
+        break
+      case 'medium':
+        operand1 = this.randomInt(10, 50)
+        operand2 = this.randomInt(1, 20)
+        break
+      case 'hard':
+        operand1 = this.randomInt(10, 100)
+        operand2 = this.randomInt(10, 50)
+        break
+    }
+
+    switch (operation) {
+      case 'addition':
+        correctAnswer = operand1 + operand2
+        break
+      case 'subtraction':
+        // Ensure positive result
+        if (operand1 < operand2) {
+          ;[operand1, operand2] = [operand2, operand1]
+        }
+        correctAnswer = operand1 - operand2
+        break
+      case 'multiplication':
+        // Smaller numbers for multiplication
+        if (difficulty === 'hard') {
+          operand1 = this.randomInt(2, 20)
+          operand2 = this.randomInt(2, 12)
+        } else {
+          operand1 = this.randomInt(2, 10)
+          operand2 = this.randomInt(2, 10)
+        }
+        correctAnswer = operand1 * operand2
+        break
+    }
+
+    const operationSymbol = this.getOperationSymbol(operation)
+    const displayText = `${operand1} ${operationSymbol} ${operand2} = ?`
+
+    return {
+      id,
+      operand1,
+      operand2,
+      operation,
+      correctAnswer,
+      displayText,
+    }
+  }
+
+  private randomOperation(): Operation {
+    const operations: Operation[] = ['addition', 'subtraction', 'multiplication']
+    return operations[Math.floor(Math.random() * operations.length)]
+  }
+
+  private randomInt(min: number, max: number): number {
+    return Math.floor(Math.random() * (max - min + 1)) + min
+  }
+
+  private getOperationSymbol(operation: Operation): string {
+    switch (operation) {
+      case 'addition':
+        return '+'
+      case 'subtraction':
+        return '−'
+      case 'multiplication':
+        return '×'
+    }
+  }
+}
+
+export const mathSprintValidator = new MathSprintValidator()

apps/web/src/arcade-games/math-sprint/components/GameComponent.tsx

@@ -0,0 +1,40 @@
+/**
+ * Math Sprint - Game Component
+ *
+ * Main wrapper component with navigation and phase routing.
+ */
+
+'use client'
+
+import { useRouter } from 'next/navigation'
+import { PageWithNav } from '@/components/PageWithNav'
+import { useMathSprint } from '../Provider'
+import { PlayingPhase } from './PlayingPhase'
+import { ResultsPhase } from './ResultsPhase'
+import { SetupPhase } from './SetupPhase'
+
+export function GameComponent() {
+  const router = useRouter()
+  const { state, exitSession, resetGame } = useMathSprint()
+
+  return (
+    <PageWithNav
+      navTitle="Math Sprint"
+      navEmoji="🧮"
+      emphasizePlayerSelection={state.gamePhase === 'setup'}
+      // No currentPlayerId - free-for-all game, everyone can act simultaneously
+      playerScores={state.scores}
+      onExitSession={() => {
+        exitSession?.()
+        router.push('/arcade')
+      }}
+      onNewGame={() => {
+        resetGame()
+      }}
+    >
+      {state.gamePhase === 'setup' && <SetupPhase />}
+      {state.gamePhase === 'playing' && <PlayingPhase />}
+      {state.gamePhase === 'results' && <ResultsPhase />}
+    </PageWithNav>
+  )
+}

apps/web/src/arcade-games/math-sprint/components/PlayingPhase.tsx

@@ -0,0 +1,347 @@
+/**
+ * Math Sprint - Playing Phase
+ *
+ * Main gameplay: show question, accept answers, show feedback.
+ */
+
+'use client'
+
+import { useEffect, useState } from 'react'
+import { useViewerId } from '@/lib/arcade/game-sdk'
+import { css } from '../../../../styled-system/css'
+import { useMathSprint } from '../Provider'
+
+export function PlayingPhase() {
+  const { state, submitAnswer, nextQuestion, lastError, clearError } = useMathSprint()
+  const { data: viewerId } = useViewerId()
+  const [inputValue, setInputValue] = useState('')
+
+  const currentQuestion = state.questions[state.currentQuestionIndex]
+  const progress = `${state.currentQuestionIndex + 1} / ${state.questions.length}`
+
+  // Find if current user answered
+  const myPlayerId = Object.keys(state.playerMetadata).find(
+    (pid) => state.playerMetadata[pid]?.userId === viewerId
+  )
+  const myAnswer = state.answers.find((a) => a.playerId === myPlayerId)
+
+  // Auto-clear error after 3 seconds
+  useEffect(() => {
+    if (lastError) {
+      const timeout = setTimeout(() => clearError(), 3000)
+      return () => clearTimeout(timeout)
+    }
+  }, [lastError, clearError])
+
+  // Clear input after question changes
+  useEffect(() => {
+    setInputValue('')
+  }, [state.currentQuestionIndex])
+
+  const handleSubmit = () => {
+    const answer = Number.parseInt(inputValue, 10)
+    if (Number.isNaN(answer)) return
+
+    submitAnswer(answer)
+  }
+
+  const handleKeyDown = (e: React.KeyboardEvent) => {
+    if (e.key === 'Enter') {
+      handleSubmit()
+    }
+  }
+
+  return (
+    <div
+      className={css({
+        display: 'flex',
+        flexDirection: 'column',
+        gap: '24px',
+        maxWidth: '700px',
+        margin: '0 auto',
+        padding: '32px 20px',
+      })}
+    >
+      {/* Progress Bar */}
+      <div
+        className={css({
+          background: 'white',
+          border: '1px solid',
+          borderColor: 'gray.200',
+          borderRadius: '12px',
+          padding: '16px',
+        })}
+      >
+        <div
+          className={css({
+            display: 'flex',
+            justifyContent: 'space-between',
+            alignItems: 'center',
+            marginBottom: '8px',
+          })}
+        >
+          <span className={css({ fontSize: 'sm', fontWeight: 'semibold' })}>Question {progress}</span>
+          <span className={css({ fontSize: 'sm', color: 'gray.600' })}>
+            {state.difficulty.charAt(0).toUpperCase() + state.difficulty.slice(1)}
+          </span>
+        </div>
+        <div
+          className={css({
+            background: 'gray.200',
+            height: '8px',
+            borderRadius: '4px',
+            overflow: 'hidden',
+          })}
+        >
+          <div
+            className={css({
+              background: 'linear-gradient(90deg, #a78bfa, #8b5cf6)',
+              height: '100%',
+              borderRadius: '4px',
+              transition: 'width 0.3s',
+            })}
+            style={{
+              width: `${((state.currentQuestionIndex + 1) / state.questions.length) * 100}%`,
+            }}
+          />
+        </div>
+      </div>
+
+      {/* Error Banner */}
+      {lastError && (
+        <div
+          className={css({
+            background: 'linear-gradient(135deg, #fef2f2, #fee2e2)',
+            border: '2px solid',
+            borderColor: 'red.300',
+            borderRadius: '12px',
+            padding: '12px 16px',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'space-between',
+          })}
+        >
+          <div className={css({ display: 'flex', alignItems: 'center', gap: '8px' })}>
+            <span>⚠️</span>
+            <span className={css({ fontSize: 'sm', color: 'red.700' })}>{lastError}</span>
+          </div>
+          <button
+            type="button"
+            onClick={clearError}
+            className={css({
+              fontSize: 'xs',
+              padding: '4px 8px',
+              background: 'red.100',
+              border: 'none',
+              borderRadius: '4px',
+              cursor: 'pointer',
+              _hover: { background: 'red.200' },
+            })}
+          >
+            Dismiss
+          </button>
+        </div>
+      )}
+
+      {/* Question Display */}
+      <div
+        className={css({
+          background: 'linear-gradient(135deg, #ede9fe, #ddd6fe)',
+          border: '2px solid',
+          borderColor: 'purple.300',
+          borderRadius: '16px',
+          padding: '48px',
+          textAlign: 'center',
+        })}
+      >
+        <div
+          className={css({
+            fontSize: '4xl',
+            fontWeight: 'bold',
+            color: 'purple.700',
+            fontFamily: 'monospace',
+          })}
+        >
+          {currentQuestion.displayText}
+        </div>
+      </div>
+
+      {/* Answer Input */}
+      {!state.questionAnswered && (
+        <div
+          className={css({
+            background: 'white',
+            border: '2px solid',
+            borderColor: myAnswer ? 'gray.300' : 'purple.500',
+            borderRadius: '12px',
+            padding: '24px',
+          })}
+        >
+          {myAnswer ? (
+            <div className={css({ textAlign: 'center' })}>
+              <div
+                className={css({
+                  fontSize: 'lg',
+                  color: 'gray.600',
+                  marginBottom: '8px',
+                })}
+              >
+                Your answer: <strong>{myAnswer.answer}</strong>
+              </div>
+              <div className={css({ fontSize: 'sm', color: 'gray.500' })}>
+                Waiting for others or correct answer...
+              </div>
+            </div>
+          ) : (
+            <div>
+              <label
+                className={css({
+                  display: 'block',
+                  fontSize: 'sm',
+                  fontWeight: 'semibold',
+                  marginBottom: '8px',
+                })}
+              >
+                Your Answer
+              </label>
+              <div className={css({ display: 'flex', gap: '12px' })}>
+                <input
+                  type="number"
+                  value={inputValue}
+                  onChange={(e) => setInputValue(e.target.value)}
+                  onKeyDown={handleKeyDown}
+                  placeholder="Type your answer..."
+                  autoFocus
+                  className={css({
+                    flex: 1,
+                    padding: '12px 16px',
+                    fontSize: 'lg',
+                    border: '2px solid',
+                    borderColor: 'gray.300',
+                    borderRadius: '8px',
+                    _focus: {
+                      outline: 'none',
+                      borderColor: 'purple.500',
+                    },
+                  })}
+                />
+                <button
+                  type="button"
+                  onClick={handleSubmit}
+                  disabled={!inputValue}
+                  className={css({
+                    padding: '12px 24px',
+                    fontSize: 'md',
+                    fontWeight: 'semibold',
+                    color: 'white',
+                    background: inputValue ? 'purple.600' : 'gray.400',
+                    border: 'none',
+                    borderRadius: '8px',
+                    cursor: inputValue ? 'pointer' : 'not-allowed',
+                    _hover: {
+                      background: inputValue ? 'purple.700' : 'gray.400',
+                    },
+                  })}
+                >
+                  Submit
+                </button>
+              </div>
+            </div>
+          )}
+        </div>
+      )}
+
+      {/* Winner Display */}
+      {state.questionAnswered && state.winnerId && (
+        <div
+          className={css({
+            background: 'linear-gradient(135deg, #d1fae5, #a7f3d0)',
+            border: '2px solid',
+            borderColor: 'green.400',
+            borderRadius: '12px',
+            padding: '24px',
+            textAlign: 'center',
+          })}
+        >
+          <div className={css({ fontSize: '3xl', marginBottom: '8px' })}>🎉</div>
+          <div className={css({ fontSize: 'lg', fontWeight: 'bold', color: 'green.700' })}>
+            {state.playerMetadata[state.winnerId]?.name || 'Someone'} got it right!
+          </div>
+          <div className={css({ fontSize: 'md', color: 'green.600', marginTop: '4px' })}>
+            Answer: {currentQuestion.correctAnswer}
+          </div>
+
+          <button
+            type="button"
+            onClick={nextQuestion}
+            className={css({
+              marginTop: '16px',
+              padding: '12px 32px',
+              fontSize: 'md',
+              fontWeight: 'semibold',
+              color: 'white',
+              background: 'green.600',
+              border: 'none',
+              borderRadius: '8px',
+              cursor: 'pointer',
+              _hover: { background: 'green.700' },
+            })}
+          >
+            Next Question →
+          </button>
+        </div>
+      )}
+
+      {/* Scoreboard */}
+      <div
+        className={css({
+          background: 'white',
+          border: '1px solid',
+          borderColor: 'gray.200',
+          borderRadius: '12px',
+          padding: '16px',
+        })}
+      >
+        <h3
+          className={css({
+            fontSize: 'sm',
+            fontWeight: 'semibold',
+            marginBottom: '12px',
+          })}
+        >
+          Scores
+        </h3>
+        <div className={css({ display: 'flex', flexDirection: 'column', gap: '8px' })}>
+          {Object.entries(state.scores)
+            .sort(([, a], [, b]) => b - a)
+            .map(([playerId, score]) => {
+              const player = state.playerMetadata[playerId]
+              return (
+                <div
+                  key={playerId}
+                  className={css({
+                    display: 'flex',
+                    justifyContent: 'space-between',
+                    alignItems: 'center',
+                    padding: '8px 12px',
+                    background: 'gray.50',
+                    borderRadius: '8px',
+                  })}
+                >
+                  <div className={css({ display: 'flex', alignItems: 'center', gap: '8px' })}>
+                    <span className={css({ fontSize: 'xl' })}>{player?.emoji}</span>
+                    <span className={css({ fontSize: 'sm', fontWeight: 'medium' })}>
+                      {player?.name}
+                    </span>
+                  </div>
+                  <span className={css({ fontSize: 'sm', fontWeight: 'bold', color: 'purple.600' })}>
+                    {score} pts
+                  </span>
+                </div>
+              )
+            })}
+        </div>
+      </div>
+    </div>
+  )
+}

apps/web/src/arcade-games/math-sprint/components/ResultsPhase.tsx

@@ -0,0 +1,194 @@
+/**
+ * Math Sprint - Results Phase
+ *
+ * Show final scores and winner.
+ */
+
+'use client'
+
+import { css } from '../../../../styled-system/css'
+import { useMathSprint } from '../Provider'
+
+export function ResultsPhase() {
+  const { state, resetGame } = useMathSprint()
+
+  // Sort players by score
+  const sortedPlayers = Object.entries(state.scores)
+    .map(([playerId, score]) => ({
+      playerId,
+      score,
+      correct: state.correctAnswersCount[playerId] || 0,
+      player: state.playerMetadata[playerId],
+    }))
+    .sort((a, b) => b.score - a.score)
+
+  const winner = sortedPlayers[0]
+
+  return (
+    <div
+      className={css({
+        display: 'flex',
+        flexDirection: 'column',
+        gap: '24px',
+        maxWidth: '600px',
+        margin: '0 auto',
+        padding: '32px 20px',
+      })}
+    >
+      {/* Winner Announcement */}
+      <div
+        className={css({
+          background: 'linear-gradient(135deg, #fef3c7, #fde68a)',
+          border: '2px solid',
+          borderColor: 'yellow.400',
+          borderRadius: '16px',
+          padding: '32px',
+          textAlign: 'center',
+        })}
+      >
+        <div className={css({ fontSize: '4xl', marginBottom: '12px' })}>🏆</div>
+        <h2
+          className={css({
+            fontSize: '2xl',
+            fontWeight: 'bold',
+            color: 'yellow.800',
+            marginBottom: '8px',
+          })}
+        >
+          {winner.player?.name} Wins!
+        </h2>
+        <div className={css({ fontSize: 'lg', color: 'yellow.700' })}>
+          {winner.score} points • {winner.correct} correct
+        </div>
+      </div>
+
+      {/* Final Scores */}
+      <div
+        className={css({
+          background: 'white',
+          border: '1px solid',
+          borderColor: 'gray.200',
+          borderRadius: '12px',
+          padding: '24px',
+        })}
+      >
+        <h3
+          className={css({
+            fontSize: 'lg',
+            fontWeight: 'semibold',
+            marginBottom: '16px',
+          })}
+        >
+          Final Scores
+        </h3>
+        <div className={css({ display: 'flex', flexDirection: 'column', gap: '12px' })}>
+          {sortedPlayers.map((item, index) => (
+            <div
+              key={item.playerId}
+              className={css({
+                display: 'flex',
+                alignItems: 'center',
+                gap: '12px',
+                padding: '16px',
+                background: index === 0 ? 'linear-gradient(135deg, #fef3c7, #fde68a)' : 'gray.50',
+                border: '1px solid',
+                borderColor: index === 0 ? 'yellow.300' : 'gray.200',
+                borderRadius: '12px',
+              })}
+            >
+              {/* Rank */}
+              <div
+                className={css({
+                  width: '32px',
+                  height: '32px',
+                  display: 'flex',
+                  alignItems: 'center',
+                  justifyContent: 'center',
+                  background: index === 0 ? 'yellow.500' : 'gray.300',
+                  color: index === 0 ? 'white' : 'gray.700',
+                  borderRadius: '50%',
+                  fontWeight: 'bold',
+                  fontSize: 'sm',
+                })}
+              >
+                {index + 1}
+              </div>
+
+              {/* Player Info */}
+              <div className={css({ flex: 1 })}>
+                <div className={css({ display: 'flex', alignItems: 'center', gap: '8px' })}>
+                  <span className={css({ fontSize: 'xl' })}>{item.player?.emoji}</span>
+                  <span className={css({ fontSize: 'md', fontWeight: 'semibold' })}>
+                    {item.player?.name}
+                  </span>
+                </div>
+                <div className={css({ fontSize: 'xs', color: 'gray.600', marginTop: '2px' })}>
+                  {item.correct} / {state.questions.length} correct
+                </div>
+              </div>
+
+              {/* Score */}
+              <div
+                className={css({
+                  fontSize: 'xl',
+                  fontWeight: 'bold',
+                  color: index === 0 ? 'yellow.700' : 'purple.600',
+                })}
+              >
+                {item.score}
+              </div>
+            </div>
+          ))}
+        </div>
+      </div>
+
+      {/* Stats */}
+      <div
+        className={css({
+          background: 'linear-gradient(135deg, #ede9fe, #ddd6fe)',
+          border: '1px solid',
+          borderColor: 'purple.300',
+          borderRadius: '12px',
+          padding: '20px',
+        })}
+      >
+        <div className={css({ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '16px' })}>
+          <div className={css({ textAlign: 'center' })}>
+            <div className={css({ fontSize: '2xl', fontWeight: 'bold', color: 'purple.700' })}>
+              {state.questions.length}
+            </div>
+            <div className={css({ fontSize: 'sm', color: 'purple.600' })}>Questions</div>
+          </div>
+          <div className={css({ textAlign: 'center' })}>
+            <div className={css({ fontSize: '2xl', fontWeight: 'bold', color: 'purple.700' })}>
+              {state.difficulty.charAt(0).toUpperCase() + state.difficulty.slice(1)}
+            </div>
+            <div className={css({ fontSize: 'sm', color: 'purple.600' })}>Difficulty</div>
+          </div>
+        </div>
+      </div>
+
+      {/* Play Again Button */}
+      <button
+        type="button"
+        onClick={resetGame}
+        className={css({
+          padding: '14px 28px',
+          fontSize: 'lg',
+          fontWeight: 'semibold',
+          color: 'white',
+          background: 'purple.600',
+          border: 'none',
+          borderRadius: '12px',
+          cursor: 'pointer',
+          transition: 'background 0.2s',
+          _hover: {
+            background: 'purple.700',
+          },
+        })}
+      >
+        Play Again
+      </button>
+    </div>
+  )
+}

apps/web/src/arcade-games/math-sprint/components/SetupPhase.tsx

@@ -0,0 +1,196 @@
+/**
+ * Math Sprint - Setup Phase
+ *
+ * Configure game settings before starting.
+ */
+
+'use client'
+
+import { css } from '../../../../styled-system/css'
+import { useMathSprint } from '../Provider'
+import type { Difficulty } from '../types'
+
+export function SetupPhase() {
+  const { state, startGame, setConfig } = useMathSprint()
+
+  const handleDifficultyChange = (difficulty: Difficulty) => {
+    setConfig('difficulty', difficulty)
+  }
+
+  const handleQuestionsChange = (questions: number) => {
+    setConfig('questionsPerRound', questions)
+  }
+
+  return (
+    <div
+      className={css({
+        display: 'flex',
+        flexDirection: 'column',
+        gap: '24px',
+        maxWidth: '600px',
+        margin: '0 auto',
+        padding: '32px 20px',
+      })}
+    >
+      {/* Game Title */}
+      <div className={css({ textAlign: 'center' })}>
+        <h1
+          className={css({
+            fontSize: '2xl',
+            fontWeight: 'bold',
+            color: 'purple.700',
+            marginBottom: '8px',
+          })}
+        >
+          🧮 Math Sprint
+        </h1>
+        <p className={css({ color: 'gray.600' })}>
+          Race to solve math problems! First correct answer wins points.
+        </p>
+      </div>
+
+      {/* Settings Card */}
+      <div
+        className={css({
+          background: 'white',
+          border: '1px solid',
+          borderColor: 'gray.200',
+          borderRadius: '12px',
+          padding: '24px',
+        })}
+      >
+        <h2
+          className={css({
+            fontSize: 'lg',
+            fontWeight: 'semibold',
+            marginBottom: '16px',
+          })}
+        >
+          Game Settings
+        </h2>
+
+        {/* Difficulty */}
+        <div className={css({ marginBottom: '20px' })}>
+          <label
+            className={css({
+              display: 'block',
+              fontSize: 'sm',
+              fontWeight: 'medium',
+              marginBottom: '8px',
+            })}
+          >
+            Difficulty
+          </label>
+          <div className={css({ display: 'flex', gap: '8px' })}>
+            {(['easy', 'medium', 'hard'] as Difficulty[]).map((diff) => (
+              <button
+                key={diff}
+                type="button"
+                onClick={() => handleDifficultyChange(diff)}
+                className={css({
+                  flex: 1,
+                  padding: '10px 16px',
+                  borderRadius: '8px',
+                  border: '2px solid',
+                  borderColor: state.difficulty === diff ? 'purple.500' : 'gray.300',
+                  background: state.difficulty === diff ? 'purple.50' : 'white',
+                  color: state.difficulty === diff ? 'purple.700' : 'gray.700',
+                  fontWeight: state.difficulty === diff ? 'semibold' : 'normal',
+                  cursor: 'pointer',
+                  transition: 'all 0.2s',
+                  _hover: {
+                    borderColor: 'purple.400',
+                  },
+                })}
+              >
+                {diff.charAt(0).toUpperCase() + diff.slice(1)}
+              </button>
+            ))}
+          </div>
+          <p className={css({ fontSize: 'xs', color: 'gray.500', marginTop: '4px' })}>
+            {state.difficulty === 'easy' && 'Numbers 1-10, simple operations'}
+            {state.difficulty === 'medium' && 'Numbers 1-50, varied operations'}
+            {state.difficulty === 'hard' && 'Numbers 1-100, harder calculations'}
+          </p>
+        </div>
+
+        {/* Questions Per Round */}
+        <div>
+          <label
+            className={css({
+              display: 'block',
+              fontSize: 'sm',
+              fontWeight: 'medium',
+              marginBottom: '8px',
+            })}
+          >
+            Questions: {state.questionsPerRound}
+          </label>
+          <input
+            type="range"
+            min="5"
+            max="20"
+            step="5"
+            value={state.questionsPerRound}
+            onChange={(e) => handleQuestionsChange(Number(e.target.value))}
+            className={css({
+              width: '100%',
+            })}
+          />
+          <div className={css({ display: 'flex', justifyContent: 'space-between', fontSize: 'xs' })}>
+            <span>5</span>
+            <span>10</span>
+            <span>15</span>
+            <span>20</span>
+          </div>
+        </div>
+      </div>
+
+      {/* Instructions */}
+      <div
+        className={css({
+          background: 'linear-gradient(135deg, #fef3c7, #fde68a)',
+          border: '1px solid',
+          borderColor: 'yellow.300',
+          borderRadius: '12px',
+          padding: '16px',
+        })}
+      >
+        <h3 className={css({ fontSize: 'sm', fontWeight: 'semibold', marginBottom: '8px' })}>
+          How to Play
+        </h3>
+        <ul className={css({ fontSize: 'sm', color: 'gray.700', paddingLeft: '20px' })}>
+          <li>Solve math problems as fast as you can</li>
+          <li>First correct answer earns 10 points</li>
+          <li>Everyone can answer at the same time</li>
+          <li>Most points wins!</li>
+        </ul>
+      </div>
+
+      {/* Start Button */}
+      <button
+        type="button"
+        onClick={startGame}
+        disabled={state.activePlayers.length < 2}
+        className={css({
+          padding: '14px 28px',
+          fontSize: 'lg',
+          fontWeight: 'semibold',
+          color: 'white',
+          background: state.activePlayers.length < 2 ? 'gray.400' : 'purple.600',
+          borderRadius: '12px',
+          border: 'none',
+          cursor: state.activePlayers.length < 2 ? 'not-allowed' : 'pointer',
+          transition: 'all 0.2s',
+          _hover: {
+            background: state.activePlayers.length < 2 ? 'gray.400' : 'purple.700',
+          },
+        })}
+      >
+        {state.activePlayers.length < 2
+          ? `Need ${2 - state.activePlayers.length} more player(s)`
+          : 'Start Game'}
+      </button>
+    </div>
+  )
+}

apps/web/src/arcade-games/math-sprint/game.yaml

@@ -0,0 +1,16 @@
+name: math-sprint
+displayName: Math Sprint
+icon: 🧮
+description: Fast-paced math racing game
+longDescription: Race against other players to solve math problems! Answer questions quickly to earn points. First person to answer correctly wins the round. Features multiple difficulty levels and customizable question counts.
+maxPlayers: 6
+difficulty: Beginner
+chips:
+  - 👥 Multiplayer
+  - ⚡ Free-for-All
+  - 🧮 Math Skills
+  - 🏃 Speed
+color: purple
+gradient: linear-gradient(135deg, #ddd6fe, #c4b5fd)
+borderColor: purple.200
+available: true

apps/web/src/arcade-games/math-sprint/index.ts

@@ -0,0 +1,43 @@
+/**
+ * Math Sprint Game Definition
+ *
+ * A free-for-all math game demonstrating the TEAM_MOVE pattern.
+ * Players race to solve math problems - first correct answer wins points.
+ */
+
+import { defineGame } from '@/lib/arcade/game-sdk'
+import type { GameManifest } from '@/lib/arcade/game-sdk'
+import { GameComponent } from './components/GameComponent'
+import { MathSprintProvider } from './Provider'
+import type { MathSprintConfig, MathSprintMove, MathSprintState } from './types'
+import { mathSprintValidator } from './Validator'
+
+const manifest: GameManifest = {
+  name: 'math-sprint',
+  displayName: 'Math Sprint',
+  icon: '🧮',
+  description: 'Race to solve math problems!',
+  longDescription:
+    'A fast-paced free-for-all game where players compete to solve math problems. First correct answer earns points. Choose your difficulty and test your mental math skills!',
+  maxPlayers: 8,
+  difficulty: 'Beginner',
+  chips: ['👥 Multiplayer', '⚡ Fast-Paced', '🧠 Mental Math'],
+  color: 'purple',
+  gradient: 'linear-gradient(135deg, #ddd6fe, #c4b5fd)',
+  borderColor: 'purple.200',
+  available: true,
+}
+
+const defaultConfig: MathSprintConfig = {
+  difficulty: 'medium',
+  questionsPerRound: 10,
+  timePerQuestion: 30,
+}
+
+export const mathSprintGame = defineGame<MathSprintConfig, MathSprintState, MathSprintMove>({
+  manifest,
+  Provider: MathSprintProvider,
+  GameComponent,
+  validator: mathSprintValidator,
+  defaultConfig,
+})

apps/web/src/arcade-games/math-sprint/types.ts

@@ -0,0 +1,120 @@
+/**
+ * Math Sprint Game Types
+ *
+ * A free-for-all game where players race to solve math problems.
+ * Demonstrates the TEAM_MOVE pattern (no specific turn owner).
+ */
+
+import type { GameConfig, GameMove, GameState } from '@/lib/arcade/game-sdk'
+
+/**
+ * Difficulty levels for math problems
+ */
+export type Difficulty = 'easy' | 'medium' | 'hard'
+
+/**
+ * Math operation types
+ */
+export type Operation = 'addition' | 'subtraction' | 'multiplication'
+
+/**
+ * Game configuration (persisted to database)
+ */
+export interface MathSprintConfig extends GameConfig {
+  difficulty: Difficulty
+  questionsPerRound: number
+  timePerQuestion: number // seconds
+}
+
+/**
+ * A math question
+ */
+export interface Question {
+  id: string
+  operand1: number
+  operand2: number
+  operation: Operation
+  correctAnswer: number
+  displayText: string // e.g., "5 + 3 = ?"
+}
+
+/**
+ * Player answer submission
+ */
+export interface Answer {
+  playerId: string
+  answer: number
+  timestamp: number
+  correct: boolean
+}
+
+/**
+ * Game state (synchronized across all clients)
+ */
+export interface MathSprintState extends GameState {
+  gamePhase: 'setup' | 'playing' | 'results'
+  activePlayers: string[]
+  playerMetadata: Record<string, { name: string; emoji: string; color: string; userId: string }>
+
+  // Configuration
+  difficulty: Difficulty
+  questionsPerRound: number
+  timePerQuestion: number
+
+  // Game progress
+  currentQuestionIndex: number
+  questions: Question[]
+
+  // Scoring
+  scores: Record<string, number> // playerId -> score
+  correctAnswersCount: Record<string, number> // playerId -> count
+
+  // Current question state
+  answers: Answer[] // All answers for current question
+  questionStartTime: number // Timestamp when question was shown
+  questionAnswered: boolean // True if someone got it right
+  winnerId: string | null // Winner of current question (first correct)
+}
+
+/**
+ * Move types for Math Sprint
+ */
+export type MathSprintMove =
+  | StartGameMove
+  | SubmitAnswerMove
+  | NextQuestionMove
+  | ResetGameMove
+  | SetConfigMove
+
+export interface StartGameMove extends GameMove {
+  type: 'START_GAME'
+  data: {
+    activePlayers: string[]
+    playerMetadata: Record<string, unknown>
+  }
+}
+
+export interface SubmitAnswerMove extends GameMove {
+  type: 'SUBMIT_ANSWER'
+  data: {
+    answer: number
+  }
+}
+
+export interface NextQuestionMove extends GameMove {
+  type: 'NEXT_QUESTION'
+  data: Record<string, never>
+}
+
+export interface ResetGameMove extends GameMove {
+  type: 'RESET_GAME'
+  data: Record<string, never>
+}
+
+export interface SetConfigMove extends GameMove {
+  type: 'SET_CONFIG'
+  data: {
+    field: 'difficulty' | 'questionsPerRound' | 'timePerQuestion'
+    value: Difficulty | number
+  }
+}

apps/web/src/db/schema/arcade-rooms.ts

@@ -34,7 +34,7 @@ export const arcadeRooms = sqliteTable('arcade_rooms', {
 
   // Game configuration (nullable to support game selection in room)
   gameName: text('game_name', {
-    enum: ['matching', 'memory-quiz', 'complement-race', 'number-guesser'],
+    enum: ['matching', 'memory-quiz', 'complement-race', 'number-guesser', 'math-sprint'],
   }),
   gameConfig: text('game_config', { mode: 'json' }), // Game-specific settings (nullable when no game selected)
 

apps/web/src/db/schema/arcade-sessions.ts

@@ -17,7 +17,7 @@ export const arcadeSessions = sqliteTable('arcade_sessions', {
 
   // Session metadata
   currentGame: text('current_game', {
-    enum: ['matching', 'memory-quiz', 'complement-race', 'number-guesser'],
+    enum: ['matching', 'memory-quiz', 'complement-race', 'number-guesser', 'math-sprint'],
   }).notNull(),
 
   gameUrl: text('game_url').notNull(), // e.g., '/arcade/matching'

apps/web/src/db/schema/room-game-configs.ts

@@ -20,7 +20,7 @@ export const roomGameConfigs = sqliteTable(
 
     // Game identifier
     gameName: text('game_name', {
-      enum: ['matching', 'memory-quiz', 'complement-race', 'number-guesser'],
+      enum: ['matching', 'memory-quiz', 'complement-race', 'number-guesser', 'math-sprint'],
     }).notNull(),
 
     // Game-specific configuration JSON
@@ -28,6 +28,8 @@ export const roomGameConfigs = sqliteTable(
     // - matching: { gameType, difficulty, turnTimer }
     // - memory-quiz: { selectedCount, displayTime, selectedDifficulty, playMode }
     // - complement-race: TBD
+    // - number-guesser: { minNumber, maxNumber, roundsToWin }
+    // - math-sprint: { difficulty, questionsPerRound, timePerQuestion }
     config: text('config', { mode: 'json' }).notNull(),
 
     // Timestamps

apps/web/src/lib/arcade/game-config-helpers.ts

@@ -15,6 +15,7 @@ import {
   DEFAULT_MEMORY_QUIZ_CONFIG,
   DEFAULT_COMPLEMENT_RACE_CONFIG,
   DEFAULT_NUMBER_GUESSER_CONFIG,
+  DEFAULT_MATH_SPRINT_CONFIG,
 } from './game-configs'
 
 /**
@@ -36,6 +37,8 @@ function getDefaultGameConfig(gameName: ExtendedGameName): GameConfigByName[Exte
       return DEFAULT_COMPLEMENT_RACE_CONFIG
     case 'number-guesser':
       return DEFAULT_NUMBER_GUESSER_CONFIG
+    case 'math-sprint':
+      return DEFAULT_MATH_SPRINT_CONFIG
     default:
       throw new Error(`Unknown game: ${gameName}`)
   }
@@ -215,6 +218,18 @@ export function validateGameConfig(gameName: ExtendedGameName, config: any): boo
         config.roundsToWin >= 1
       )
 
+    case 'math-sprint':
+      return (
+        typeof config === 'object' &&
+        config !== null &&
+        ['easy', 'medium', 'hard'].includes(config.difficulty) &&
+        typeof config.questionsPerRound === 'number' &&
+        typeof config.timePerQuestion === 'number' &&
+        config.questionsPerRound >= 5 &&
+        config.questionsPerRound <= 20 &&
+        config.timePerQuestion >= 10
+      )
+
     default:
       return false
   }

apps/web/src/lib/arcade/game-configs.ts

@@ -11,6 +11,7 @@
 
 import type { DifficultyLevel } from '@/app/arcade/memory-quiz/types'
 import type { Difficulty, GameType } from '@/app/games/matching/context/types'
+import type { Difficulty as MathSprintDifficulty } from '@/arcade-games/math-sprint/types'
 
 /**
  * Configuration for matching (memory pairs) game
@@ -49,6 +50,15 @@ export interface NumberGuesserGameConfig {
   roundsToWin: number
 }
 
+/**
+ * Configuration for math-sprint game
+ */
+export interface MathSprintGameConfig {
+  difficulty: MathSprintDifficulty
+  questionsPerRound: number
+  timePerQuestion: number
+}
+
 /**
  * Union type of all game configs for type-safe access
  */
@@ -57,6 +67,7 @@ export type GameConfigByName = {
   'memory-quiz': MemoryQuizGameConfig
   'complement-race': ComplementRaceGameConfig
   'number-guesser': NumberGuesserGameConfig
+  'math-sprint': MathSprintGameConfig
 }
 
 /**
@@ -68,6 +79,7 @@ export interface RoomGameConfig {
   'memory-quiz'?: MemoryQuizGameConfig
   'complement-race'?: ComplementRaceGameConfig
   'number-guesser'?: NumberGuesserGameConfig
+  'math-sprint'?: MathSprintGameConfig
 }
 
 /**
@@ -95,3 +107,9 @@ export const DEFAULT_NUMBER_GUESSER_CONFIG: NumberGuesserGameConfig = {
   maxNumber: 100,
   roundsToWin: 3,
 }
+
+export const DEFAULT_MATH_SPRINT_CONFIG: MathSprintGameConfig = {
+  difficulty: 'medium',
+  questionsPerRound: 10,
+  timePerQuestion: 30,
+}

apps/web/src/lib/arcade/game-registry.ts

@@ -107,5 +107,7 @@ export function clearRegistry(): void {
 // ============================================================================
 
 import { numberGuesserGame } from '@/arcade-games/number-guesser'
+import { mathSprintGame } from '@/arcade-games/math-sprint'
 
 registerGame(numberGuesserGame)
+registerGame(mathSprintGame)

apps/web/src/lib/arcade/validators.ts

@@ -13,6 +13,7 @@
 import { matchingGameValidator } from './validation/MatchingGameValidator'
 import { memoryQuizGameValidator } from './validation/MemoryQuizGameValidator'
 import { numberGuesserValidator } from '@/arcade-games/number-guesser/Validator'
+import { mathSprintValidator } from '@/arcade-games/math-sprint/Validator'
 import type { GameValidator } from './validation/types'
 
 /**
@@ -24,6 +25,7 @@ export const validatorRegistry = {
   matching: matchingGameValidator,
   'memory-quiz': memoryQuizGameValidator,
   'number-guesser': numberGuesserValidator,
+  'math-sprint': mathSprintValidator,
   // Add new games here - GameName type will auto-update
 } as const
 
@@ -65,4 +67,9 @@ export function getRegisteredGameNames(): GameName[] {
 /**
  * Re-export validators for backwards compatibility
  */
-export { matchingGameValidator, memoryQuizGameValidator, numberGuesserValidator }
+export {
+  matchingGameValidator,
+  memoryQuizGameValidator,
+  numberGuesserValidator,
+  mathSprintValidator,
+}

package.json

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