chore(release): 4.67.3 [skip ci]

## [4.67.3](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.67.2...v4.67.3) (2025-10-23)

### Bug Fixes

* **complement-race:** resolve infinite render loop in useTrackManagement ([8b4dacd](8b4dacdc98))

CHANGELOG.md

@@ -1,3 +1,94 @@
+## [4.67.3](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.67.2...v4.67.3) (2025-10-23)
+
+
+### Bug Fixes
+
+* **complement-race:** resolve infinite render loop in useTrackManagement ([8b4dacd](https://github.com/antialias/soroban-abacus-flashcards/commit/8b4dacdc98cc8cb2a503b31698430ad7ffb6ef8e))
+
+## [4.67.2](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.67.1...v4.67.2) (2025-10-23)
+
+
+### Performance Improvements
+
+* **complement-race:** increase train position update frequency to 60fps ([fffaf1d](https://github.com/antialias/soroban-abacus-flashcards/commit/fffaf1df1d4d55c811bf634c957691e3564470d6))
+
+## [4.67.1](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.67.0...v4.67.1) (2025-10-22)
+
+
+### Bug Fixes
+
+* **complement-race:** fix react-spring interpolation TypeScript errors ([0add9e4](https://github.com/antialias/soroban-abacus-flashcards/commit/0add9e4ef1d69e4e92ffe279cce09c68efa43714))
+
+## [4.67.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.66.2...v4.67.0) (2025-10-22)
+
+
+### Features
+
+* **complement-race:** add react-spring animations to ghost trains for smooth movement ([eb3700a](https://github.com/antialias/soroban-abacus-flashcards/commit/eb3700a57d035a142c64b60d5d1b21181d21b69f))
+
+## [4.66.2](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.66.1...v4.66.2) (2025-10-22)
+
+
+### Bug Fixes
+
+* **complement-race:** fix ghost train position update lag and reload position reset ([ad78a65](https://github.com/antialias/soroban-abacus-flashcards/commit/ad78a65ed7f63509602e79246e3761653ea39a15))
+
+## [4.66.1](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.66.0...v4.66.1) (2025-10-22)
+
+
+### Bug Fixes
+
+* **complement-race:** ensure continuous position broadcasting during train movement ([df60824](https://github.com/antialias/soroban-abacus-flashcards/commit/df60824f37f52e77e69d32c26926a24e1af88e66))
+
+## [4.66.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.65.1...v4.66.0) (2025-10-22)
+
+
+### Features
+
+* **complement-race:** implement per-car adaptive opacity for ghost trains ([9b1d47d](https://github.com/antialias/soroban-abacus-flashcards/commit/9b1d47d4c7bdaf44f3921ff99971dfb3b65442bd))
+
+## [4.65.1](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.65.0...v4.65.1) (2025-10-22)
+
+
+### Bug Fixes
+
+* **complement-race:** use sendMove with correct parameters for position updates ([06cd94b](https://github.com/antialias/soroban-abacus-flashcards/commit/06cd94b24cdd9dbd36fb5800c9ba7be194f7eed0))
+
+## [4.65.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.64.2...v4.65.0) (2025-10-22)
+
+
+### Features
+
+* **complement-race:** implement position broadcasting for ghost trains ([c5fba5b](https://github.com/antialias/soroban-abacus-flashcards/commit/c5fba5b7dd0f36fd3bbe596409e01b0d3dbd4fbe))
+
+## [4.64.2](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.64.1...v4.64.2) (2025-10-22)
+
+
+### Bug Fixes
+
+* **complement-race:** use individual player positions for ghost trains ([00dc4b1](https://github.com/antialias/soroban-abacus-flashcards/commit/00dc4b1d06a4e1763deb16333a298145cafd9187))
+
+## [4.64.1](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.64.0...v4.64.1) (2025-10-22)
+
+
+### Bug Fixes
+
+* **complement-race:** use local player instead of first player for train display ([915d8a5](https://github.com/antialias/soroban-abacus-flashcards/commit/915d8a5343e70a30c7a82bed645e6628fcc08a86))
+
+## [4.64.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.63.11...v4.64.0) (2025-10-22)
+
+
+### Features
+
+* **complement-race:** add ghost trains for multiplayer visibility ([7668cc9](https://github.com/antialias/soroban-abacus-flashcards/commit/7668cc9b113b3eae2acb1b852b0ad48c979e6604))
+
+## [4.63.11](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.63.10...v4.63.11) (2025-10-22)
+
+
+### Bug Fixes
+
+* **complement-race:** actually filter by isActive instead of just id ([ef4ca57](https://github.com/antialias/soroban-abacus-flashcards/commit/ef4ca57a6c3f35d1bddc6a70952f478058fbc6b5))
+
 ## [4.63.10](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.63.9...v4.63.10) (2025-10-22)
 
 

apps/web/src/app/arcade/complement-race/components/RaceTrack/GhostTrain.tsx

@@ -0,0 +1,233 @@
+'use client'
+
+import { useSpring, useSprings, animated, to } from '@react-spring/web'
+import { useMemo, useRef } from 'react'
+import type { PlayerState } from '@/arcade-games/complement-race/types'
+import type { RailroadTrackGenerator } from '../../lib/RailroadTrackGenerator'
+
+// Overlap threshold: if ghost car is within this distance of any local car, make it ghostly
+const OVERLAP_THRESHOLD = 20 // % of track length
+const GHOST_OPACITY = 0.35 // Opacity when overlapping
+const SOLID_OPACITY = 1.0 // Opacity when separated
+
+interface GhostTrainProps {
+  player: PlayerState
+  trainPosition: number
+  localTrainCarPositions: number[] // [locomotive, car1, car2, car3]
+  maxCars: number
+  carSpacing: number
+  trackGenerator: RailroadTrackGenerator
+  pathRef: React.RefObject<SVGPathElement>
+}
+
+interface CarTransform {
+  x: number
+  y: number
+  rotation: number
+  opacity: number
+  position: number
+}
+
+/**
+ * Calculate opacity for a ghost car based on distance to nearest local car
+ */
+function calculateCarOpacity(ghostCarPosition: number, localCarPositions: number[]): number {
+  // Find minimum distance to any local car
+  const minDistance = Math.min(
+    ...localCarPositions.map((localPos) => Math.abs(ghostCarPosition - localPos))
+  )
+
+  // If within threshold, use ghost opacity; otherwise solid
+  return minDistance < OVERLAP_THRESHOLD ? GHOST_OPACITY : SOLID_OPACITY
+}
+
+/**
+ * GhostTrain - Renders a semi-transparent train for other players in multiplayer
+ * Uses per-car adaptive opacity: cars are ghostly when overlapping local train,
+ * solid when separated
+ */
+export function GhostTrain({
+  player,
+  trainPosition,
+  localTrainCarPositions,
+  maxCars,
+  carSpacing,
+  trackGenerator,
+  pathRef,
+}: GhostTrainProps) {
+  const ghostRef = useRef<SVGGElement>(null)
+
+  // Calculate target transform for locomotive (used by spring animation)
+  const locomotiveTarget = useMemo<CarTransform | null>(() => {
+    if (!pathRef.current) {
+      return null
+    }
+
+    const pathLength = pathRef.current.getTotalLength()
+    const targetDistance = (trainPosition / 100) * pathLength
+    const point = pathRef.current.getPointAtLength(targetDistance)
+
+    // Calculate tangent for rotation
+    const tangentDelta = 1
+    const tangentDistance = Math.min(targetDistance + tangentDelta, pathLength)
+    const tangentPoint = pathRef.current.getPointAtLength(tangentDistance)
+    const rotation =
+      (Math.atan2(tangentPoint.y - point.y, tangentPoint.x - point.x) * 180) / Math.PI
+
+    return {
+      x: point.x,
+      y: point.y,
+      rotation,
+      position: trainPosition,
+      opacity: calculateCarOpacity(trainPosition, localTrainCarPositions),
+    }
+  }, [trainPosition, localTrainCarPositions, pathRef])
+
+  // Animated spring for smooth locomotive movement
+  const locomotiveSpring = useSpring({
+    x: locomotiveTarget?.x ?? 0,
+    y: locomotiveTarget?.y ?? 0,
+    rotation: locomotiveTarget?.rotation ?? 0,
+    opacity: locomotiveTarget?.opacity ?? 1,
+    config: { tension: 280, friction: 60 }, // Smooth but responsive
+  })
+
+  // Calculate target transforms for cars (used by spring animations)
+  const carTargets = useMemo<CarTransform[]>(() => {
+    if (!pathRef.current) {
+      return []
+    }
+
+    const pathLength = pathRef.current.getTotalLength()
+    const cars: CarTransform[] = []
+
+    for (let i = 0; i < maxCars; i++) {
+      const carPosition = Math.max(0, trainPosition - (i + 1) * carSpacing)
+      const targetDistance = (carPosition / 100) * pathLength
+      const point = pathRef.current.getPointAtLength(targetDistance)
+
+      // Calculate tangent for rotation
+      const tangentDelta = 1
+      const tangentDistance = Math.min(targetDistance + tangentDelta, pathLength)
+      const tangentPoint = pathRef.current.getPointAtLength(tangentDistance)
+      const rotation =
+        (Math.atan2(tangentPoint.y - point.y, tangentPoint.x - point.x) * 180) / Math.PI
+
+      cars.push({
+        x: point.x,
+        y: point.y,
+        rotation,
+        position: carPosition,
+        opacity: calculateCarOpacity(carPosition, localTrainCarPositions),
+      })
+    }
+
+    return cars
+  }, [trainPosition, maxCars, carSpacing, localTrainCarPositions, pathRef])
+
+  // Animated springs for smooth car movement (useSprings for multiple cars)
+  const carSprings = useSprings(
+    carTargets.length,
+    carTargets.map((target) => ({
+      x: target.x,
+      y: target.y,
+      rotation: target.rotation,
+      opacity: target.opacity,
+      config: { tension: 280, friction: 60 },
+    }))
+  )
+
+  // Don't render if position data isn't ready
+  if (!locomotiveTarget) {
+    return null
+  }
+
+  return (
+    <g ref={ghostRef} data-component="ghost-train" data-player-id={player.id}>
+      {/* Ghost locomotive - animated */}
+      <animated.g
+        transform={to(
+          [locomotiveSpring.x, locomotiveSpring.y, locomotiveSpring.rotation],
+          (x, y, rot) => `translate(${x}, ${y}) rotate(${rot}) scale(-1, 1)`
+        )}
+        opacity={locomotiveSpring.opacity}
+      >
+        <text
+          data-element="ghost-locomotive"
+          x={0}
+          y={0}
+          textAnchor="middle"
+          style={{
+            fontSize: '100px',
+            filter: `drop-shadow(0 2px 8px ${player.color || 'rgba(100, 100, 255, 0.6)'})`,
+            pointerEvents: 'none',
+          }}
+        >
+          🚂
+        </text>
+
+        {/* Player name label - positioned above locomotive */}
+        <text
+          data-element="ghost-label"
+          x={0}
+          y={-60}
+          textAnchor="middle"
+          style={{
+            fontSize: '18px',
+            fontWeight: 'bold',
+            fill: player.color || '#6366f1',
+            filter: 'drop-shadow(0 1px 2px rgba(0, 0, 0, 0.3))',
+            pointerEvents: 'none',
+            transform: 'scaleX(-1)', // Counter the parent's scaleX(-1)
+          }}
+        >
+          {player.name || `Player ${player.id.slice(0, 4)}`}
+        </text>
+
+        {/* Score indicator - positioned below locomotive */}
+        <text
+          data-element="ghost-score"
+          x={0}
+          y={50}
+          textAnchor="middle"
+          style={{
+            fontSize: '14px',
+            fontWeight: 'bold',
+            fill: 'rgba(255, 255, 255, 0.9)',
+            filter: 'drop-shadow(0 1px 2px rgba(0, 0, 0, 0.5))',
+            pointerEvents: 'none',
+            transform: 'scaleX(-1)', // Counter the parent's scaleX(-1)
+          }}
+        >
+          {player.score}
+        </text>
+      </animated.g>
+
+      {/* Ghost cars - each with individual animated opacity and position */}
+      {carSprings.map((spring, index) => (
+        <animated.g
+          key={`car-${index}`}
+          transform={to(
+            [spring.x, spring.y, spring.rotation],
+            (x, y, rot) => `translate(${x}, ${y}) rotate(${rot}) scale(-1, 1)`
+          )}
+          opacity={spring.opacity}
+        >
+          <text
+            data-element={`ghost-car-${index}`}
+            x={0}
+            y={0}
+            textAnchor="middle"
+            style={{
+              fontSize: '85px',
+              filter: `drop-shadow(0 2px 6px ${player.color || 'rgba(100, 100, 255, 0.4)'})`,
+              pointerEvents: 'none',
+            }}
+          >
+            🚃
+          </text>
+        </animated.g>
+      ))}
+    </g>
+  )
+}

apps/web/src/app/arcade/complement-race/components/RaceTrack/SteamTrainJourney.tsx

@@ -20,6 +20,7 @@ import { GameHUD } from './GameHUD'
 import { RailroadTrackPath } from './RailroadTrackPath'
 import { TrainAndCars } from './TrainAndCars'
 import { TrainTerrainBackground } from './TrainTerrainBackground'
+import { GhostTrain } from './GhostTrain'
 
 const BoardingPassengerAnimation = memo(({ animation }: { animation: BoardingAnimation }) => {
   const spring = useSpring({
@@ -92,7 +93,7 @@ export function SteamTrainJourney({
   currentQuestion,
   currentInput,
 }: SteamTrainJourneyProps) {
-  const { state } = useComplementRace()
+  const { state, multiplayerState, localPlayerId } = useComplementRace()
 
   const { getSkyGradient, getTimeOfDayPeriod } = useSteamJourney()
   const _skyGradient = getSkyGradient()
@@ -100,10 +101,10 @@ export function SteamTrainJourney({
   const { players } = useGameMode()
   const { profile: _profile } = useUserProfile()
 
-  // Get the first active player's emoji
-  const activePlayers = Array.from(players.values()).filter((p) => p.id)
-  const firstActivePlayer = activePlayers[0]
-  const playerEmoji = firstActivePlayer?.emoji ?? '👤'
+  // Get the LOCAL player's emoji (not just the first player!)
+  const activePlayers = Array.from(players.values()).filter((p) => p.isActive)
+  const localPlayer = activePlayers.find((p) => p.isLocal)
+  const playerEmoji = localPlayer?.emoji ?? '👤'
 
   const svgRef = useRef<SVGSVGElement>(null)
   const pathRef = useRef<SVGPathElement>(null)
@@ -164,14 +165,13 @@ export function SteamTrainJourney({
 
   // Memoize filtered passenger lists to avoid recalculating on every render
   // Arcade room multiplayer uses claimedBy/deliveredBy instead of isBoarded/isDelivered
-  // Only show passengers claimed by the first active player
+  // Only show passengers claimed by the LOCAL player
   const boardedPassengers = useMemo(
     () =>
       displayPassengers.filter(
-        (p) =>
-          p.claimedBy === firstActivePlayer?.id && p.claimedBy !== null && p.deliveredBy === null
+        (p) => p.claimedBy === localPlayer?.id && p.claimedBy !== null && p.deliveredBy === null
       ),
-    [displayPassengers, firstActivePlayer?.id]
+    [displayPassengers, localPlayer?.id]
   )
 
   const nonDeliveredPassengers = useMemo(
@@ -191,6 +191,29 @@ export function SteamTrainJourney({
     []
   )
 
+  // Calculate local train car positions for ghost train overlap detection
+  // Array includes locomotive + all cars: [locomotive, car1, car2, car3]
+  const localTrainCarPositions = useMemo(() => {
+    const positions = [trainPosition] // Locomotive at front
+    for (let i = 0; i < maxCars; i++) {
+      positions.push(Math.max(0, trainPosition - (i + 1) * carSpacing))
+    }
+    return positions
+  }, [trainPosition, maxCars, carSpacing])
+
+  // Get other players for ghost trains (filter out local player)
+  const otherPlayers = useMemo(() => {
+    if (!multiplayerState?.players || !localPlayerId) {
+      return []
+    }
+
+    const filtered = Object.entries(multiplayerState.players)
+      .filter(([playerId, player]) => playerId !== localPlayerId && player.isActive)
+      .map(([_, player]) => player)
+
+    return filtered
+  }, [multiplayerState?.players, localPlayerId])
+
   if (!trackData) return null
 
   return (
@@ -252,7 +275,21 @@ export function SteamTrainJourney({
           disembarkingAnimations={disembarkingAnimations}
         />
 
-        {/* Train, cars, and passenger animations */}
+        {/* Ghost trains - other players in multiplayer */}
+        {otherPlayers.map((player) => (
+          <GhostTrain
+            key={player.id}
+            player={player}
+            trainPosition={player.position} // Use each player's individual position
+            localTrainCarPositions={localTrainCarPositions} // For per-car overlap detection
+            maxCars={maxCars}
+            carSpacing={carSpacing}
+            trackGenerator={trackGenerator}
+            pathRef={pathRef}
+          />
+        ))}
+
+        {/* Train, cars, and passenger animations - local player */}
         <TrainAndCars
           boardingAnimations={boardingAnimations}
           disembarkingAnimations={disembarkingAnimations}

apps/web/src/app/arcade/complement-race/hooks/useSteamJourney.ts

@@ -34,7 +34,7 @@ const MOMENTUM_DECAY_RATES = {
 
 const MOMENTUM_GAIN_PER_CORRECT = 15 // Momentum added for each correct answer
 const SPEED_MULTIPLIER = 0.15 // Convert momentum to speed (% per second at momentum=100)
-const UPDATE_INTERVAL = 50 // Update every 50ms (~20 fps)
+const UPDATE_INTERVAL = 16 // Update every 16ms (~60 fps for smooth animation)
 const GAME_DURATION = 60000 // 60 seconds in milliseconds
 
 export function useSteamJourney() {

apps/web/src/app/arcade/complement-race/hooks/useTrackManagement.ts

@@ -104,7 +104,9 @@ export function useTrackManagement({
       setDisplayPassengers(passengers)
     }
     // Otherwise, keep displaying old passengers until train resets
-  }, [passengers, displayPassengers, trainPosition, currentRoute])
+    // Note: displayPassengers is intentionally NOT in deps to avoid infinite loop
+    // (it's used for comparison, but we don't need to re-run when it changes)
+  }, [passengers, trainPosition, currentRoute])
 
   // Generate ties and rails when path is ready
   useEffect(() => {

apps/web/src/arcade-games/complement-race/Provider.tsx

@@ -99,6 +99,8 @@ interface CompatibleGameState {
  */
 interface ComplementRaceContextValue {
   state: CompatibleGameState // Return adapted state
+  multiplayerState: ComplementRaceState // Raw multiplayer state for rendering other players
+  localPlayerId: string | undefined // Local player ID for filtering
   dispatch: (action: { type: string; [key: string]: any }) => void // Compatibility layer
   lastError: string | null
   startGame: () => void
@@ -304,19 +306,35 @@ export function ComplementRaceProvider({ children }: { children: ReactNode }) {
 
   // Get local player ID
   const localPlayerId = useMemo(() => {
-    return activePlayers.find((id) => {
+    const foundId = activePlayers.find((id) => {
       const player = players.get(id)
       return player?.isLocal
     })
+    return foundId
   }, [activePlayers, players])
 
-  // Debug logging ref (track last logged values)
-  const lastLogRef = useState({ key: '', count: 0 })[0]
-
   // Client-side game state (NOT synced to server - purely visual/gameplay)
   const [clientMomentum, setClientMomentum] = useState(10) // Start at 10 for gentle push
   const [clientPosition, setClientPosition] = useState(0)
   const [clientPressure, setClientPressure] = useState(0)
+
+  // Track if we've synced position from server (for reconnect/reload scenarios)
+  const hasInitializedPositionRef = useRef(false)
+
+  // Ref to track latest position for broadcasting (avoids recreating interval on every position change)
+  const clientPositionRef = useRef(clientPosition)
+
+  // Refs for throttled logging
+  const lastBroadcastLogRef = useRef({ position: 0, time: 0 })
+  const broadcastCountRef = useRef(0)
+  const lastReceivedPositionsRef = useRef<Record<string, number>>({})
+
+  // Ref to hold sendMove so interval doesn't restart when sendMove changes
+  const sendMoveRef = useRef(sendMove)
+  useEffect(() => {
+    sendMoveRef.current = sendMove
+  }, [sendMove])
+
   const [clientAIRacers, setClientAIRacers] = useState<
     Array<{
       id: string
@@ -347,7 +365,7 @@ export function ComplementRaceProvider({ children }: { children: ReactNode }) {
   const MOMENTUM_GAIN_PER_CORRECT = 15
   const MOMENTUM_LOSS_PER_WRONG = 10
   const SPEED_MULTIPLIER = 0.15 // momentum * 0.15 = % per second
-  const UPDATE_INTERVAL = 50 // 50ms = ~20fps
+  const UPDATE_INTERVAL = 16 // 16ms = ~60fps for smooth animation
 
   // Transform multiplayer state to look like single-player state
   const compatibleState = useMemo((): CompatibleGameState => {
@@ -443,16 +461,50 @@ export function ComplementRaceProvider({ children }: { children: ReactNode }) {
     clientAIRacers,
   ])
 
+  // Sync client position from server on reconnect/reload (multiplayer only)
+  useEffect(() => {
+    // Only sync if:
+    // 1. We haven't synced yet
+    // 2. Game is active
+    // 3. We're in sprint mode
+    // 4. We have a local player with a position from server
+    if (
+      !hasInitializedPositionRef.current &&
+      multiplayerState.gamePhase === 'playing' &&
+      multiplayerState.config.style === 'sprint' &&
+      localPlayerId
+    ) {
+      const serverPosition = multiplayerState.players[localPlayerId]?.position
+      if (serverPosition !== undefined && serverPosition > 0) {
+        console.log(`[POSITION_SYNC] Restoring position from server: ${serverPosition.toFixed(1)}%`)
+        setClientPosition(serverPosition)
+        hasInitializedPositionRef.current = true
+      }
+    }
+
+    // Reset sync flag when game ends
+    if (multiplayerState.gamePhase !== 'playing') {
+      hasInitializedPositionRef.current = false
+    }
+  }, [
+    multiplayerState.gamePhase,
+    multiplayerState.config.style,
+    multiplayerState.players,
+    localPlayerId,
+  ])
+
   // Initialize game start time when game becomes active
   useEffect(() => {
     if (compatibleState.isGameActive && compatibleState.style === 'sprint') {
       if (gameStartTimeRef.current === 0) {
         gameStartTimeRef.current = Date.now()
         lastUpdateRef.current = Date.now()
-        // Reset client state for new game
-        setClientMomentum(10) // Start with gentle push
-        setClientPosition(0)
-        setClientPressure((10 / 100) * 150) // Initial pressure from starting momentum
+        // Reset client state for new game (only if not restored from server)
+        if (!hasInitializedPositionRef.current) {
+          setClientMomentum(10) // Start with gentle push
+          setClientPosition(0)
+          setClientPressure((10 / 100) * 150) // Initial pressure from starting momentum
+        }
       }
     } else {
       // Reset when game ends
@@ -548,14 +600,78 @@ export function ComplementRaceProvider({ children }: { children: ReactNode }) {
     const currentRoute = multiplayerState.currentRoute
     // When route changes, reset position and give starting momentum
     if (currentRoute > 1 && compatibleState.style === 'sprint') {
-      console.log(
-        `[Provider] Route changed to ${currentRoute}, resetting position. Passengers: ${multiplayerState.passengers.length}`
-      )
       setClientPosition(0)
       setClientMomentum(10) // Reset to starting momentum (gentle push)
     }
   }, [multiplayerState.currentRoute, compatibleState.style, multiplayerState.passengers.length])
 
+  // Keep position ref in sync with latest position
+  useEffect(() => {
+    clientPositionRef.current = clientPosition
+  }, [clientPosition])
+
+  // Log when we receive position updates from other players
+  useEffect(() => {
+    if (!multiplayerState?.players || !localPlayerId) return
+
+    Object.entries(multiplayerState.players).forEach(([playerId, player]) => {
+      if (playerId === localPlayerId || !player.isActive) return
+
+      const lastPos = lastReceivedPositionsRef.current[playerId] ?? -1
+      const currentPos = player.position
+
+      // Log when position changes significantly (>2%)
+      if (Math.abs(currentPos - lastPos) > 2) {
+        console.log(
+          `[POS_RECEIVED] ${player.name}: ${currentPos.toFixed(1)}% (was ${lastPos.toFixed(1)}%, delta=${(currentPos - lastPos).toFixed(1)}%)`
+        )
+        lastReceivedPositionsRef.current[playerId] = currentPos
+      }
+    })
+  }, [multiplayerState?.players, localPlayerId])
+
+  // Broadcast position to server for multiplayer ghost trains
+  useEffect(() => {
+    const isGameActive = multiplayerState.gamePhase === 'playing'
+    const isSprint = multiplayerState.config.style === 'sprint'
+
+    if (!isGameActive || !isSprint || !localPlayerId) {
+      return
+    }
+
+    console.log('[POS_BROADCAST] Starting position broadcast interval')
+
+    // Send position update every 16ms (~60fps) for smoother ghost trains (reads from refs to avoid restarting interval)
+    const interval = setInterval(() => {
+      const currentPos = clientPositionRef.current
+      broadcastCountRef.current++
+
+      // Throttled logging: only log when position changes by >2% or every 5 seconds
+      const now = Date.now()
+      const posDiff = Math.abs(currentPos - lastBroadcastLogRef.current.position)
+      const timeDiff = now - lastBroadcastLogRef.current.time
+
+      if (posDiff > 2 || timeDiff > 5000) {
+        console.log(
+          `[POS_BROADCAST] #${broadcastCountRef.current} pos=${currentPos.toFixed(1)}% (delta=${posDiff.toFixed(1)}%)`
+        )
+        lastBroadcastLogRef.current = { position: currentPos, time: now }
+      }
+
+      sendMoveRef.current({
+        type: 'UPDATE_POSITION',
+        playerId: localPlayerId,
+        userId: viewerId || '',
+        data: { position: currentPos },
+      } as ComplementRaceMove)
+    }, 16)
+
+    return () => {
+      console.log(`[POS_BROADCAST] Stopping interval (sent ${broadcastCountRef.current} updates)`)
+      clearInterval(interval)
+    }
+  }, [multiplayerState.gamePhase, multiplayerState.config.style, localPlayerId, viewerId])
+
   // Keep lastLogRef for future debugging needs
   // (removed debug logging)
 
@@ -769,7 +885,6 @@ export function ComplementRaceProvider({ children }: { children: ReactNode }) {
         case 'START_NEW_ROUTE':
           // Send route progression to server
           if (action.routeNumber !== undefined) {
-            console.log(`[Provider] Dispatching START_NEW_ROUTE for route ${action.routeNumber}`)
             sendMove({
               type: 'START_NEW_ROUTE',
               playerId: activePlayers[0] || '',
@@ -914,6 +1029,8 @@ export function ComplementRaceProvider({ children }: { children: ReactNode }) {
 
   const contextValue: ComplementRaceContextValue = {
     state: compatibleState, // Use transformed state
+    multiplayerState, // Expose raw multiplayer state for ghost trains
+    localPlayerId, // Expose local player ID for filtering
     dispatch,
     lastError,
     startGame,

apps/web/src/arcade-games/complement-race/Validator.ts

@@ -97,6 +97,9 @@ export class ComplementRaceValidator
       case 'UPDATE_INPUT':
         return this.validateUpdateInput(state, move.playerId, move.data.input)
 
+      case 'UPDATE_POSITION':
+        return this.validateUpdatePosition(state, move.playerId, move.data.position)
+
       case 'CLAIM_PASSENGER':
         return this.validateClaimPassenger(
           state,
@@ -397,6 +400,39 @@ export class ComplementRaceValidator
     return { valid: true, newState }
   }
 
+  private validateUpdatePosition(
+    state: ComplementRaceState,
+    playerId: string,
+    position: number
+  ): ValidationResult {
+    if (state.gamePhase !== 'playing') {
+      return { valid: false, error: 'Game not in playing phase' }
+    }
+
+    const player = state.players[playerId]
+    if (!player) {
+      return { valid: false, error: 'Player not found' }
+    }
+
+    // Validate position is a reasonable number (0-100)
+    if (typeof position !== 'number' || position < 0 || position > 100) {
+      return { valid: false, error: 'Invalid position value' }
+    }
+
+    const newState: ComplementRaceState = {
+      ...state,
+      players: {
+        ...state.players,
+        [playerId]: {
+          ...player,
+          position,
+        },
+      },
+    }
+
+    return { valid: true, newState }
+  }
+
   // ==========================================================================
   // Sprint Mode: Passenger Management
   // ==========================================================================

apps/web/src/arcade-games/complement-race/types.ts

@@ -143,6 +143,7 @@ export type ComplementRaceMove = BaseGameMove &
     // Playing phase
     | { type: 'SUBMIT_ANSWER'; data: { answer: number; responseTime: number } }
     | { type: 'UPDATE_INPUT'; data: { input: string } } // Show "thinking" indicator
+    | { type: 'UPDATE_POSITION'; data: { position: number } } // Sprint mode: sync train position
     | { type: 'CLAIM_PASSENGER'; data: { passengerId: string; carIndex: number } } // Sprint mode: pickup
     | { type: 'DELIVER_PASSENGER'; data: { passengerId: string } } // Sprint mode: delivery
 

package.json

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