🤖 Create Your Chess Bot with AI

I want to create a chess bot for ChessArena.dev. Please write a JavaScript function following these CRITICAL rules:

🚨 CRITICAL RULES:
1. 20 SECOND TIME LIMIT PER MOVE - if we don't call reportMove() in time, we LOSE!
2. Use "anytime algorithm" pattern: call reportMove() EARLY, then keep improving
3. Shorter code wins in draws - keep it compact!

Function requirements:
- Named exactly: makeMove
- Takes 3 parameters: board, timeRemaining, reportMove
- Uses chess.js library (already provided)
- Must call reportMove(legalMove) IMMEDIATELY with first valid move
- Then can call reportMove() again with better moves as we find them
- Last call to reportMove() before timeout is used

Forbidden:
- NO fetch, eval, async/await, or network requests
- Maximum 30KB of code
- NO board modification methods (see below)

📚 API REFERENCE - Available Methods:

🚫 FORBIDDEN METHODS - Will cause validation to FAIL:

⛔ board.load(fen) - Modifies the board position (READ-ONLY board!)
⛔ board.reset() - Resets the board (READ-ONLY board!)
⛔ board.put(piece, square) - Places a piece (READ-ONLY board!)
⛔ board.remove(square) - Removes a piece (READ-ONLY board!)
⛔ board.clear() - Clears the board (READ-ONLY board!)
⛔ board.load_pgn(pgn) - Loads a game (READ-ONLY board!)

❌ Using any of these will immediately fail validation with error:
   "FORBIDDEN: board.xxx() is not allowed. The board is read-only."

✅ ALLOWED METHODS:

🎯 board.moves() → Returns array of legal moves
   Example: ["e4", "d4", "Nf3", "Nc3", ...]
   const moves = board.moves();
   reportMove(moves[0]); // Play first legal move

🔄 board.clone() → Create mutable copy for move exploration
   Example: Test moves without affecting the original board
   const clone = board.clone();
   clone.move("e4");  // Make move on clone
   const evaluation = evaluatePosition(clone);
   clone.undo();      // Undo on clone

   ⚠️ The original board is READ-ONLY. Use clone() to explore moves!
   ⚠️ DO NOT use board.move() + board.undo() on the original board

🔍 board.get(square) → Get piece at a square
   Example: board.get("e2") returns {type: 'p', color: 'w'} or null
   const piece = board.get("e4");
   if (piece && piece.type === 'q') {
       // There's a queen on e4
   }

⚪⚫ board.turn() → Whose turn is it?
   Returns: 'w' for white, 'b' for black
   if (board.turn() === 'w') {
       // It's white's turn
   }

🎯 board.fen() → Get board position as FEN string
   Example: "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"

✅ board.in_check() → Is current player in check?
   if (board.in_check()) {
       // Must escape check!
   }

🏁 board.game_over() → Is game finished?
   Returns true if checkmate, stalemate, or draw

🧠 getMemory() → Monitor memory usage (in MB)
   Returns: {heapUsed: 45, heapTotal: 89, rss: 120, external: 2}
   const mem = getMemory();
   if (mem.heapUsed > 200) {
       return; // Stop to avoid crash!
   }

⏱️ timeRemaining → Milliseconds left (starts at 20000)
   if (timeRemaining < 1000) {
       return; // Less than 1 second left, stop searching
   }

Strategy pattern (IMPORTANT):
function makeMove(board, timeRemaining, reportMove, getMemory) {
    // 1. IMMEDIATELY report first legal move (safety!)
    const moves = board.moves();
    reportMove(moves[0]);

    // 2. Now search for better moves using clone()
    for (const move of moves) {
        const clone = board.clone(); // Create mutable copy
        clone.move(move);            // Test move on clone

        // Evaluate position, look ahead, etc.
        const score = evaluatePosition(clone);

        // No need to undo - just discard clone
        if (score > bestScore) {
            reportMove(move); // Found better move!
        }
    }

    // 3. Call reportMove() again each time we find better move
    // 4. Server uses LAST reported move before timeout

    // OPTIONAL: Monitor memory usage
    // const mem = getMemory();
    // if (mem.heapUsed > 200) {
    //     // Stop searching if using too much memory
    // }
}

Please write a competitive bot that follows this anytime algorithm pattern!

function makeMove(board, timeRemaining, reportMove, getMemory) {
    const moves = board.moves();

    // ⚡ CRITICAL: Report a move immediately (anytime algorithm!)
    reportMove(moves[0]);

    // Now we have 20 seconds to find something better
    // Each time we find improvement, call reportMove() again

    // Try to find captures using clone()
    for (const move of moves) {
        const clone = board.clone();  // Create mutable copy
        const result = clone.move(move);

        if (result && result.captured) {
            reportMove(move); // Found a capture, report it!
            break;
        }
        // No need to undo - clone is discarded
    }

    // Could add more sophisticated search here
    // Just keep calling reportMove() with better moves!
}

My chess bot is losing. Can you improve this code to make better moves?

Current strategy: [describe what your bot does]

Suggestions:
- Look ahead more moves
- Better piece valuations
- Avoid leaving pieces undefended
- Control more center squares

Here's my current code:
[paste your bot code here]