/**
 * board.js: Chessground wrapper
 *
 * Wraps the vendor Chessground() instance and a chessops position, and owns:
 *   - A branching move tree (_nodes/_rootChildren) used by the PGN panel:
 *     playing a move after navigating back adds a variation instead of
 *     overwriting the continuation from that point. A plain
 *     undo/redo FEN stack (_history/_future) sits alongside it as a
 *     fallback for Back/Forward once navigation walks off the tree (e.g.
 *     past a board edit that started a fresh one).
 *   - Best-move arrows for DTZ/DTC/DTM/DTM50, drawn via chessground's
 *     native drawable.autoShapes.
 *   - Click-to-place editing: click a spare piece, then click a square to
 *     place it. Drag-from-tray is also supported (chessground's
 *     dragNewPiece()).
 *   - goToNode() - jump to any node in the current move tree (used by
 *     the PGN panel, including variation moves) without resetting the tree
 *     or re-triggering a probe for a position that's already been evaluated.
 *   - Board/piece theming: the piece image path is owned by theme.js
 *     (Theme.pieceThemeFn()). reconstruct() updates the piece
 *     CSS <link> and repopulates the spare-tray/promotion-dialog images;
 *     chessground is never destroyed and rebuilt for theming, since piece
 *     images are plain CSS.
 *   - The active rules variant (Standard / Chess960) and the FEN protocol
 *     boundary between them. chessops's own `Chess` class implements both
 *     rulesets' move generation/legality/SAN identically and has no
 *     variant concept of its own - castling legality, paths, and rook
 *     squares are computed the same way regardless of variant (see
 *     chessgroundDests() below for the one place chessops is told which
 *     variant is active, purely to choose which destinations chessground
 *     is offered). The application's Standard-vs-Chess960 FEN contract is
 *     stricter than chessops's generic one: chessops's FEN parser resolves
 *     a 'K'/'Q'/'k'/'q' castling letter to whichever rook sits on the
 *     correct side of the king wherever the king happens to be (needed for
 *     Chess960, where the king isn't always on the e-file) and also accepts
 *     Shredder-FEN/X-FEN rook-file letters unconditionally - neither of
 *     which is a legal Standard-chess castling encoding. _buildPosition()
 *     below enforces the application's Standard-mode castling contract
 *     (only 'K'/'Q'/'k'/'q', each requiring the king on its e1/e8 home
 *     square and the resolved rook on its exact a1/h1/a8/h8 home square)
 *     before trusting chessops's more permissive parse, so the frontend
 *     and the backend (see app.py's _validate_fen_parts and python-chess's
 *     own chess960=False castling validation) agree on whether a given FEN
 *     is valid for the active variant.
 *
 * Every position-changing action - setPosition(), clear(), playMove(),
 * goBack()/goForward(), board edits (off-board drop, board-setup drag,
 * click-to-place), setVariant() - records itself (in the tree or the
 * undo/redo stack, whichever applies) and invokes the onPositionChange
 * callback itself, so callers never need to remember to do either one
 * manually.
 *
 * The chessops position (_position) is the single source of truth for
 * position/legality - chessground is a dumb, controlled rendering surface.
 * Every position-changing function ends with a call to _syncChessground(),
 * which pushes _position's current FEN (plus turn colour, check state, and
 * last-move squares) into chessground in one shot. The core mutation
 * handler (_handleBoardMutation) is idempotent rather than tracking which
 * of chessground's several event hooks handled a given user action,
 * because chessground fires multiple, differently-scoped events for what
 * is logically one move. For an ordinary relocation, events.move fires
 * first, then events.change, then movable.events.after (see board.ts's
 * baseMove()/userMove()). events.change carries no orig/dest, so if it won
 * the idempotency race it would take the generic "board edit" branch and
 * leave movable.events.after's orig/dest with nothing left to act on.
 * events.move is therefore the primary handler: it fires before
 * events.change and, unlike movable.events.after, carries orig/dest (plus
 * capture info), so it wins the idempotency race with enough information
 * to classify the move correctly. events.change and movable.events.after
 * are wired as idempotent fallbacks, and events.change is the only hook
 * that fires for an off-board deletion (drag.ts's deleteOnDropOff branch
 * calls it directly, with no accompanying events.move/
 * movable.events.after).
 */

import { Chessground } from '../vendor/chessground.min.js';
import { Theme }       from './theme.js';
import * as Storage    from './storage.js';

import { Chess, Castles, castlingSide } from '../vendor/chessops/chess.js';
import { parseFen, makeFen }       from '../vendor/chessops/fen.js';
import { chessgroundDests }        from '../vendor/chessops/compat.js';
import { parseSan, makeSan }       from '../vendor/chessops/san.js';
import { parseSquare, makeSquare } from '../vendor/chessops/util.js';

// ── Variant ──────────────────────────────────────────────────────────────
// The application's rules-mode state. Distinct from chessops's own `rules`
// property (always 'chess' for both Standard and Chess960 - see the
// module doc comment above): this is application metadata that travels
// alongside the position, never derived from it.
const VARIANTS = Object.freeze({ STANDARD: 'standard', CHESS960: 'chess960' });

const Board = (() => {

    let cg     = null;   // Chessground instance
    let _position = null;   // chessops Chess position - see module doc comment
    let _variant  = VARIANTS.STANDARD;
    let _onPositionChange    = null;
    let _onMoveHistoryChange = null;

    let _pendingPromotion = null;

    // ── Lock mode ────────────────────────────────────────────────────────────
    // When true, the board only accepts legal moves for the side to move;
    // spare-piece placement and off-board deletion are disabled. Toggled via
    // setLocked(). Moves played through the ranked-moves table, auto-play, or
    // the PGN panel are unaffected, since those are already always legal.
    let _locked = false;

    // [orig, dest] of the most recently played/navigated-to move, or
    // undefined. Fed into chessground's `lastMove` config on every sync.
    // Tracked separately from the move tree because Back/Forward/goToNode
    // land on a node that already has its own from/to squares recorded;
    // this variable is what lets _syncChessground() highlight the right
    // squares for those navigations too, not just for a freshly played move.
    let _lastMoveKeys = undefined;

    // ── Undo / redo stacks ────────────────────────────────────────────────────
    // Plain chronological FEN log, used only as a Back/Forward fallback once
    // navigation walks off the current move tree entirely (e.g. past a board
    // edit - edits aren't part of the tree, see _resetMoveLine below). While
    // the current position is inside the tree, goBack()/goForward() use the
    // tree's parent/activeChild pointers instead (see below).
    let _history = [];
    let _future  = [];
    const _MAX_HISTORY = 100;

    function _pushHistory(fen) {
        _history.push(fen);
        if (_history.length > _MAX_HISTORY) _history.shift();
        _future = [];   // any new position discards the redo stack
    }

    // ── Move tree ──────────────────────────────────────────────────────────────
    // Only legal moves via playMove() (and the promotion/drag-move
    // equivalents) are recorded here. setPosition() / clear() / board edits /
    // setVariant() reset the tree.
    //
    // Each node is {id, san, fen, from, to, parentId, children, activeChild}.
    // `id` is also the node's index in _nodes. parentId === ROOT (-1) means
    // the node replies to the tree's start position (_startFen). `children`
    // lists every move tried from that node - children[0] renders as the
    // "main" continuation, children[1+] as parenthesised variations.
    // `activeChild` is whichever child Forward should follow from that node
    // (whichever branch was most recently played/clicked into) - not
    // necessarily children[0]. `from`/`to` are the move's origin/destination
    // squares exactly as played (for a Chess960 castle, the king's origin
    // and whichever destination square chessground/chessops reported,
    // never assumed to be a fixed c/g-file square), recorded alongside
    // san/fen so lastMove highlighting works when navigating the tree, not
    // just on a freshly-played move.
    //
    // The PGN panel and PGN export walk this tree recursively so alternate
    // moves are preserved as variations instead of overwriting history.
    const ROOT = -1;

    let _nodes           = [];   // [{id, san, fen, from, to, parentId, children:[], activeChild}]
    let _rootChildren    = [];   // ids of moves played directly from _startFen
    let _rootActiveChild = null;
    let _currentId        = ROOT; // id of the node currently shown, or ROOT for _startFen itself
    let _startFen         = null; // FEN the current tree began from (for PGN formatting)

    function _childrenOf(id) { return id === ROOT ? _rootChildren : _nodes[id].children; }
    function _activeChildOf(id) { return id === ROOT ? _rootActiveChild : _nodes[id].activeChild; }
    function _setActiveChild(id, childId) {
        if (id === ROOT) _rootActiveChild = childId;
        else _nodes[id].activeChild = childId;
    }

    function _resetMoveLine() {
        _nodes            = [];
        _rootChildren     = [];
        _rootActiveChild  = null;
        _currentId        = ROOT;
        _future           = [];
        _startFen         = _position ? currentFen() : null;
        if (_onMoveHistoryChange) _emitHistory();
    }

    function _emitHistory() {
        if (_onMoveHistoryChange) {
            _onMoveHistoryChange({
                nodes: _nodes, rootChildren: _rootChildren,
                rootActiveChild: _rootActiveChild, currentId: _currentId,
            }, _startFen);
        }
    }

    // Records a played move as a child of the current node. If the current
    // node already has a child with this exact SAN (the user replayed a move
    // already tried from this point), that existing node is reused instead
    // of creating a duplicate. Otherwise a new node is created and appended
    // to the end of the children list, so an already-explored continuation
    // stays the main line and the newly-played move is recorded as a
    // parenthesised variation.
    function _addMove(san, fen, from, to) {
        _future = [];   // starting a fresh line invalidates any pre-tree redo
        const kids = _childrenOf(_currentId);
        let childId = kids.find(id => _nodes[id].san === san);
        if (childId === undefined) {
            childId = _nodes.length;
            _nodes.push({ id: childId, san, fen, from, to, parentId: _currentId, children: [], activeChild: null });
            kids.push(childId);
        }
        // (else: reused an existing child - same SAN replayed from this node)
        _setActiveChild(_currentId, childId);
        _currentId = childId;
        return childId;
    }

    // ── Piece theme ───────────────────────────────────────────────────────────
    // Delegates to theme.js, which owns the active piece set. Kept as a local
    // wrapper (rather than calling Theme.pieceThemeFn() inline everywhere)
    // so callers below don't need to know theme.js exists. Resolved once on
    // first use rather than re-fetched from Theme on every call.
    let _pieceThemeFn = null;
    function _pieceTheme(piece) {
        if (!_pieceThemeFn) _pieceThemeFn = Theme.pieceThemeFn();
        return _pieceThemeFn(piece);
    }

    // ── chessops adapter ─────────────────────────────────────────────────────
    // Small translation layer between this file's FEN-string/algebraic-key
    // vocabulary and chessops's Setup/Position/numeric-square vocabulary.
    // Contains no chess rules of its own - every legality, castling, and
    // check/mate determination below is delegated to chessops.

    function currentFen() { return makeFen(_position.toSetup()); }
    function _turnChar(pos) { return pos.turn === 'white' ? 'w' : 'b'; }

    function _fenErrorMessage(err) {
        switch (err && err.message) {
            case 'ERR_CASTLING':
                return "Invalid castling availability: expected some combination of 'K', 'Q', 'k', 'q', rook-file letters 'a'-'h'/'A'-'H', or '-'.";
            case 'ERR_TURN':      return 'Invalid FEN: side to move must be "w" or "b".';
            case 'ERR_EP_SQUARE': return 'Invalid FEN: en passant target square is not valid.';
            case 'ERR_HALFMOVES': return 'Invalid FEN: halfmove clock is not valid.';
            case 'ERR_FULLMOVES': return 'Invalid FEN: fullmove number is not valid.';
            case 'ERR_BOARD':     return 'Invalid FEN: board part is not valid.';
            default:               return 'Invalid FEN: position violates chess rules.';
        }
    }
    function _positionErrorMessage(err) {
        switch (err && err.message) {
            case 'ERR_KINGS':            return 'Position must have exactly one king per side.';
            case 'ERR_OPPOSITE_CHECK':   return 'Invalid position: the side not to move is already in check.';
            case 'ERR_PAWNS_ON_BACKRANK': return 'Invalid position: a pawn is on the back rank.';
            case 'ERR_EMPTY':            return 'Position has no pieces.';
            default:                      return 'Invalid FEN: position violates chess rules.';
        }
    }

    // A castling-availability letter with no matching king/rook pair on the
    // board (e.g. "K" with no white king and rook on their home squares) is
    // syntactically valid but not a legal right - chessops's own parser
    // silently drops it rather than rejecting the FEN (see parseCastlingFen
    // in fen.js), so that has to be checked here by comparing what was
    // requested against what the constructed position actually granted.
    // This works the same way for Standard 'KQkq' and Chess960 file-letter
    // rights, since both are resolved by chessops before this comparison;
    // no Standard-only assumption is made about which squares are valid.
    function _missingCastlingRights(setup, pos) {
        const missing = [];
        for (const square of setup.castlingRights) {
            if (!pos.castles.castlingRights.has(square)) missing.push(makeSquare(square));
        }
        return missing;
    }

    // Standard chess's castling letters mean something fixed: 'K'/'Q' is
    // the White rook on h1/a1, with the White king on e1 - never "whichever
    // rook is right/left of the king" (chessops's own, Chess960-capable,
    // resolution rule; see the module doc comment). A right that chessops
    // resolves to any other square is a Chess960-only reading of the same
    // letter and must be rejected here, in Standard mode, even though
    // chessops itself parsed it without complaint. Chess960 mode has no
    // "home square" of its own - any resolved king/rook pair is
    // acceptable there, which _missingCastlingRights above already covers.
    const _HOME_SQUARES = {
        white: { king: parseSquare('e1'), rook: { a: parseSquare('a1'), h: parseSquare('h1') } },
        black: { king: parseSquare('e8'), rook: { a: parseSquare('a8'), h: parseSquare('h8') } },
    };
    function _nonOrthodoxCastlingRights(pos) {
        const offending = [];
        for (const color of ['white', 'black']) {
            const kingSquare = pos.board.kingOf(color);
            for (const side of ['a', 'h']) {
                const rookSquare = pos.castles.rook[color][side];
                if (rookSquare === undefined) continue;
                if (kingSquare !== _HOME_SQUARES[color].king || rookSquare !== _HOME_SQUARES[color].rook[side]) {
                    offending.push(makeSquare(rookSquare));
                }
            }
        }
        return offending;
    }

    // Standard mode accepts only 'K'/'Q'/'k'/'q' (each optional, in that
    // order) or '-'; Chess960 additionally accepts Shredder-FEN/X-FEN
    // rook-file letters. Mirrors app.py's _validate_fen_parts exactly:
    // same accepted grammar, same rejected input, so a FEN the frontend
    // accepts is never one the backend then rejects, or vice versa.
    const _CASTLING_SYNTAX_STANDARD = /^K?Q?k?q?$/;
    const _CASTLING_SYNTAX_CHESS960 = /^[A-Ha-hKQkq]{1,4}$/;
    function _castlingSyntaxError(variant, field) {
        if (field === '-') return null;
        const pattern = variant === VARIANTS.CHESS960 ? _CASTLING_SYNTAX_CHESS960 : _CASTLING_SYNTAX_STANDARD;
        if (pattern.test(field)) return null;
        const expected = variant === VARIANTS.CHESS960
            ? "some combination of 'K', 'Q', 'k', 'q', rook-file letters 'a'-'h'/'A'-'H', or '-'"
            : "some combination of 'K', 'Q', 'k', 'q', or '-'";
        return `Invalid castling availability: '${field}' (expected ${expected}).`;
    }

    // Parses and fully validates a FEN into a chessops position under the
    // given variant (defaulting to the currently-active one), or returns a
    // user-facing reason it was rejected. Rejects a syntactically-valid
    // chessops parse that isn't actually a legal encoding for the
    // requested variant (see the two checks above and the module doc
    // comment) - the same FEN text can be accepted under one variant and
    // rejected under the other.
    function _buildPosition(fen, variant = _variant) {
        const fields = fen.split(' ');
        if (fields.length >= 3) {
            const syntaxError = _castlingSyntaxError(variant, fields[2]);
            if (syntaxError) return { ok: false, reason: syntaxError };
        }
        const parsed = parseFen(fen);
        if (parsed.isErr) return { ok: false, reason: _fenErrorMessage(parsed.error) };
        const setup = parsed.value;
        const built = Chess.fromSetup(setup);
        if (built.isErr) return { ok: false, reason: _positionErrorMessage(built.error) };
        const pos = built.value;
        const missing = _missingCastlingRights(setup, pos);
        if (missing.length) {
            return { ok: false, reason: `Invalid castling availability: no matching king and rook for ${missing.join(', ')}.` };
        }
        if (variant !== VARIANTS.CHESS960) {
            const nonOrthodox = _nonOrthodoxCastlingRights(pos);
            if (nonOrthodox.length) {
                return {
                    ok: false,
                    reason: `Invalid castling availability: Standard chess requires the king and rook on their home squares (${nonOrthodox.join(', ')} is not one).`,
                };
            }
        }
        return { ok: true, pos };
    }

    function _pieceCodeOf(piece) {
        if (!piece) return null;
        const letter = piece.role === 'knight' ? 'N' : piece.role[0].toUpperCase();
        return (piece.color === 'white' ? 'w' : 'b') + letter;
    }

    // Total legal move count, counting each underpromotion choice as a
    // separate move (matching the count a full legal-move generator would
    // report) rather than one destination square per promoting pawn move.
    // Includes Chess960 castling moves - they're just another destination
    // chessops's own move generation supplies (see chessgroundDests below).
    function _countLegalMoves(pos) {
        const ctx = pos.ctx();
        let count = 0;
        for (const [from, squares] of pos.allDests(ctx)) {
            const promotes = pos.board.pawn.has(from);
            for (const to of squares) {
                const isPromotion = promotes && (to < 8 || to >= 56);
                count += isPromotion ? 4 : 1;
            }
        }
        return count;
    }

    // Builds chessground's `movable.dests` shape from the active position,
    // using the variant-aware compatibility bridge. Standard mode exposes
    // orthodox king-destination castling only; Chess960 exposes the
    // king-to-rook destination.
    function _legalDestsMap() {
        if (!_position) return new Map();
        const dests = chessgroundDests(_position, { chess960: _variant === VARIANTS.CHESS960 });
        if (_variant === VARIANTS.CHESS960) return dests;

        const filtered = new Map();
        for (const [from, squares] of dests) {
            const fromSquare = parseSquare(from);
            const allowed = squares.filter(to => {
                const toSquare = parseSquare(to);
                const side = castlingSide(_position, { from: fromSquare, to: toSquare });
                if (!side) return true;
                return toSquare !== _position.castles.rook[_position.turn][side];
            });
            if (allowed.length) filtered.set(from, allowed);
        }
        return filtered;
    }

    // ── Chessground sync ──────────────────────────────────────────────────────
    // The single point where _position's state is pushed into chessground.
    // Called unconditionally after every position-changing action - even a
    // "legal move" one, since chessground's own baseMove() has no concept of
    // en passant, promotion, or Chess960 castling and can leave its internal
    // state briefly chess-wise-incorrect (e.g. not removing the captured
    // pawn on an en passant capture, leaving a pawn on the back rank instead
    // of the promoted piece, or leaving the rook wherever it was dragged
    // from instead of its final castled square) until this call corrects
    // it. Chessground's internal state is not authoritative;
    // this call always overwrites it from _position.
    function _syncChessground() {
        if (!cg || !_position) return;
        cg.set({
            fen:       currentFen(),
            turnColor: _position.turn,
            check:     _position.isCheck() ? _position.turn : false,
            lastMove:  _lastMoveKeys,
            // Locked: restrict dragging/click-move to the side to move's
            // legal destinations. Unlocked: free editing.
            movable: {
                free:  !_locked,
                color: _locked ? _position.turn : 'both',
                dests: _locked ? _legalDestsMap() : undefined,
            },
            // Off-board drop-to-delete is disabled while locked, same as the
            // spare trays below.
            draggable: { deleteOnDropOff: !_locked },
        });
    }

    // ── Promotion ─────────────────────────────────────────────────────────────
    // pieceCode is a two-letter code like 'wP' (colour + uppercase type),
    // matching the shape the rest of this file (and theme.js) already uses.
    function _isPromotionMove(target, pieceCode) {
        if (!pieceCode || pieceCode[1] !== 'P') return false;
        const color = pieceCode[0], rank = target[1];
        return (color === 'w' && rank === '8') || (color === 'b' && rank === '1');
    }
    // Maps the promotion dialog's single-letter piece codes to chessops's
    // full role names.
    const ROLE_OF = { P: 'pawn', N: 'knight', B: 'bishop', R: 'rook', Q: 'queen', K: 'king' };

    function _showPromotionDialog(source, target, color) {
        _pendingPromotion = { source, target };
        const dialog = document.getElementById('promotion-dialog');
        ['q','r','b','n'].forEach(p => {
            const btn = dialog.querySelector(`.promotion-piece-btn[data-piece="${p}"]`);
            const img = btn && btn.querySelector('img');
            if (img) img.src = _pieceTheme(color + p.toUpperCase());
        });
        dialog.classList.add('is-visible');
        dialog.querySelector('.promotion-piece-btn')?.focus();
    }
    function _hidePromotionDialog() {
        document.getElementById('promotion-dialog').classList.remove('is-visible');
    }
    // Cancelling (Escape / backdrop click) needs to resync, since
    // chessground has already visually relocated the pawn to the target
    // square by the time the dialog is showing (its own drag/drop already
    // moved the piece before this handler ever runs). This call reverts
    // that visual relocation by pushing _position's still-unchanged state
    // back into chessground.
    function _cancelPromotion() {
        _hidePromotionDialog();
        _pendingPromotion = null;
        _syncChessground();
    }
    function _onPromotionSelect(pieceLetter) {
        _hidePromotionDialog();
        if (!_pendingPromotion) return;
        const { source, target } = _pendingPromotion;
        _pendingPromotion = null;
        const move = { from: parseSquare(source), to: parseSquare(target), promotion: ROLE_OF[pieceLetter.toUpperCase()] };
        if (!_position.isLegal(move)) { _syncChessground(); return; }   // revert the visual pawn-on-back-rank relocation
        const san = makeSan(_position, move);
        _position.play(move);
        _lastMoveKeys = [source, target];
        _addMove(san, currentFen(), source, target);
        _emitHistory();
        _syncChessground();
        // immediate=true: a completed promotion is a single, definite move
        // (see playMove()'s own comment on this parameter), not part of a
        // rapid-fire stream of changes the debounce below it is meant to
        // guard against.
        if (_onPositionChange) _onPositionChange(currentFen(), true);
    }

    // ── Core sync algorithm ──────────────────────────────────────────────────
    // Chessground fires multiple, differently-scoped callbacks for what a
    // user experiences as a single action (events.move, events.change,
    // movable.events.after, events.dropNewPiece), so rather than track
    // which-callback-handled-what with suppression flags, this handler is
    // idempotent: it compares chessground's current placement against
    // _position's, and no-ops if they already match.
    //
    // events.move is wired as the informative hook (the one that passes
    // origHint/destHint below) rather than movable.events.after, because of
    // chessground's event-firing order for an ordinary relocation:
    // events.move fires first (scheduled from within board.ts's baseMove()),
    // then events.change (also scheduled by baseMove(), immediately after),
    // then movable.events.after (scheduled later by userMove()) - all via
    // setTimeout(fn,1), so same-delay-timer FIFO ordering makes this
    // deterministic. events.change carries no orig/dest, so if it were the
    // informative hook it would always take the generic "board edit" branch
    // below first, leaving movable.events.after's real orig/dest with
    // nothing left to act on once it fires - the idempotency guard would
    // already see the position as synced. events.move fires before
    // events.change and, unlike movable.events.after, carries orig/dest
    // (plus capture info), so it reliably wins the idempotency race with
    // enough information to classify the move correctly.
    // events.change and movable.events.after are wired below as idempotent
    // fallbacks/no-ops for a relocation; events.change is load-bearing for
    // the one case with no orig/dest-carrying hook at all - an off-board
    // deletion (drag.ts's deleteOnDropOff branch).
    //
    // Standard mode accepts only the orthodox king-destination castle;
    // Chess960 accepts the king-to-rook representation.
    function _handleBoardMutation(origHint, destHint) {
        if (!cg || !_position) return;
        const cgPlacement  = cg.getFen();                 // chessground's own current placement-only FEN
        const ourPlacement = currentFen().split(' ')[0];
        if (cgPlacement === ourPlacement) return;          // already synced by another callback this tick

        if (origHint && destHint) {
            // _position hasn't moved yet at this point - only chessground
            // has - so the piece that was at origHint is still readable
            // from _position.
            const pieceCode = _pieceCodeOf(_position.board.get(parseSquare(origHint)));
            if (pieceCode && _isPromotionMove(destHint, pieceCode)) {
                _showPromotionDialog(origHint, destHint, pieceCode[0]);
                return;   // resolved later by _onPromotionSelect()/_cancelPromotion()
            }
            const move = { from: parseSquare(origHint), to: parseSquare(destHint) };
            if (_variant === VARIANTS.STANDARD) {
                const side = castlingSide(_position, move);
                if (side && move.to === _position.castles.rook[_position.turn][side]) {
                    _syncChessground();
                    return;
                }
            }
            if (_position.isLegal(move)) {
                const san = makeSan(_position, move);
                _position.play(move);
                _lastMoveKeys = [origHint, destHint];
                _addMove(san, currentFen(), origHint, destHint);
                _emitHistory();
                _syncChessground();
                // immediate=true: see the comment on the equivalent call in
                // _onPromotionSelect() above - a completed drag-and-drop
                // move is a single, definite move too.
                if (_onPositionChange) _onPositionChange(currentFen(), true);
                return;
            }
            // Not legal - fall through to the generic edit path below, which
            // reads the placement chessground already committed rather than
            // origHint/destHint.
        }

        // Board-edit path: spare-piece drop, off-board delete, or an
        // illegal relocation. Castling rights and the en passant square are
        // always dropped here because an edited placement's rights can no
        // longer be assumed valid.
        const prevFen = currentFen();
        const nextFen = `${cgPlacement} ${_turnChar(_position)} - - 0 1`;
        const built = _buildPosition(nextFen);
        if (!built.ok) { _syncChessground(); return; }   // invalid resulting position - snap back
        _position = built.pos;
        _pushHistory(prevFen);
        _lastMoveKeys = undefined;
        _resetMoveLine();
        _syncChessground();
        if (_onPositionChange) _onPositionChange(currentFen());
    }

    function _onCgSelect(key) {
        if (!_clickPlacePiece) return;         // not in placement mode - let chessground handle the click normally
        cg.selectSquare(null);                  // clear any selection chessground itself may have started,
                                                 // so a piece "armed" for placement never gets relocated
                                                 // by chessground's own click-to-move instead
        const role  = ROLE_OF[_clickPlacePiece[1]];
        const color = _clickPlacePiece[0] === 'w' ? 'white' : 'black';
        const square = parseSquare(key);
        if (role === 'king') {
            const existing = _position.board.kingOf(color);
            if (existing !== undefined && existing !== square) return;   // rejected - a king of this colour already exists elsewhere
        }
        const prevFen = currentFen();
        // Trial-mutate a clone rather than _position directly, so an
        // illegal result (e.g. two kings adjacent, or leaving the side not
        // to move in check) can be refused before anything commits - the
        // same validate-then-commit gate _handleBoardMutation's edit path
        // below already runs every other board edit through.
        const trial = _position.clone();
        trial.board.set(square, { role, color, promoted: false });
        // Re-derive castling rights from the edited board rather than
        // leaving stale rook/king square references behind (e.g. a right
        // pointing at a square this edit just overwrote).
        trial.castles = Castles.fromSetup({ board: trial.board, castlingRights: _position.castles.castlingRights });
        const nextFen = makeFen(trial.toSetup());
        if (nextFen === prevFen) return;   // identity placement (e.g. re-placing the same piece already there) - nothing to record
        const built = _buildPosition(nextFen);
        if (!built.ok) { setClickPlacePiece(null); return; }   // illegal result - refuse, board stays as it was
        _position = built.pos;
        _pushHistory(prevFen);
        _lastMoveKeys = undefined;
        _resetMoveLine();
        _syncChessground();
        if (_onPositionChange) _onPositionChange(currentFen());
    }

    // ── Best-move arrows (DTZ / DTC / DTM / DTM50) ────────────────────────────
    // Native chessground feature (drawable.autoShapes) - square keys, not
    // pixel coordinates, so chessground handles orientation/resizing itself.
    // bestMoves: { dtz: entry|null, dtc: entry|null, dtm: entry|null,
    // dtm50: entry|null } - the top-ranked move for each metric (any of
    // which may be missing, e.g. for a terminal or not-yet-probed position).
    function drawArrows(bestMoves) {
        if (!cg) return;
        if (!bestMoves) { cg.setAutoShapes([]); return; }
        const shapes = [];
        ['dtz', 'dtc', 'dtm', 'dtm50'].forEach(metric => {
            const entry = bestMoves[metric];
            if (!entry) return;
            const move = parseSan(_position, entry.san);
            if (!move) return;
            const side = _variant === VARIANTS.STANDARD ? castlingSide(_position, move) : undefined;
            const dest = side
                ? `${side === 'a' ? 'c' : 'g'}${_position.turn === 'white' ? '1' : '8'}`
                : makeSquare(move.to);
            shapes.push({ orig: makeSquare(move.from), dest, brush: metric });
        });
        cg.setAutoShapes(shapes);
    }
    function clearArrows() {
        if (!cg) return;
        cg.setAutoShapes([]);
    }

    // ── Click-to-place + spare-piece trays ───────────────────────────────────
    let _clickPlacePiece = null;   // e.g. 'wQ', 'bK', or null

    function _toCgPiece(code /* e.g. 'wQ' */) {
        return { color: code[0] === 'w' ? 'white' : 'black', role: ROLE_OF[code[1]] };
    }

    function _populateTrayImages() {
        document.querySelectorAll('.spare-piece').forEach(btn => {
            const code = btn.dataset.piece;
            const img  = btn.querySelector('img');
            if (img && code) img.src = _pieceTheme(code);
        });
    }

    // Two interaction paths, both needed: click-to-place (click a tray
    // piece, then click a destination square) and drag-from-tray (native
    // HTML5 drag onto the board, handled via chessground's dragNewPiece()).
    // The spare-piece trays are expected to support both at once, so
    // neither wiring below can assume the other is absent.
    function _initSpareTrays() {
        document.querySelectorAll('.spare-piece').forEach(btn => {
            const code = btn.dataset.piece;

            // Path 1: click tray piece, then click a square - handled by
            // this click listener (arms _clickPlacePiece) plus _onCgSelect()
            // (does the actual placement), wired in init()'s Config.events.select.
            // Disabled while locked (tray is also dimmed - see setLocked()).
            btn.addEventListener('click', () => {
                if (_locked) return;
                setClickPlacePiece(_clickPlacePiece === code ? null : code);
            });

            // Path 2: drag a tray piece directly onto the board. `force:
            // true` is required - cg.dragNewPiece() without it refuses to
            // overwrite an occupied square, and dropping a spare piece onto
            // an occupied square is expected to replace it. Disabled while locked.
            btn.addEventListener('pointerdown', e => {
                if (_locked) return;
                if (e.button !== undefined && e.button !== 0) return;   // primary pointer only
                cg.dragNewPiece(_toCgPiece(code), e, /* force */ true);
            });
        });

        // Escape clears click-to-place selection
        document.addEventListener('keydown', e => {
            if (e.key === 'Escape' && _clickPlacePiece) setClickPlacePiece(null);
        });
    }

    function setClickPlacePiece(piece) {
        _clickPlacePiece = piece;
        // Visual feedback
        document.querySelectorAll('.spare-piece.cp-selected').forEach(el => el.classList.remove('cp-selected'));
        if (piece) {
            document.querySelectorAll(`.spare-piece[data-piece="${piece}"]`).forEach(el => el.classList.add('cp-selected'));
        }
        // Update cursor on board
        const boardEl = document.getElementById('board');
        if (boardEl) {
            boardEl.classList.toggle('cp-active', !!piece);
        }
    }

    // ── Public API ────────────────────────────────────────────────────────────

    function _restoredOrientation() {
        return Storage.read('chesstb_orientation') === 'black' ? 'black' : 'white';
    }

    function _restoredLocked() {
        return Storage.read('chesstb_locked') === 'true';
    }

    // variant, if given, must be VARIANTS.STANDARD or VARIANTS.CHESS960 and
    // takes precedence over any caller-independent default - callers that
    // already know the intended variant (a URL share-link, a restored saved
    // game) pass it explicitly so the position below is constructed under
    // the correct ruleset context from the very first render, per this
    // file's variant-before-position invariant. Omitted or invalid values
    // fall back to Standard.
    function init(onPositionChange, initialFen, variant) {
        _onPositionChange = onPositionChange;
        _variant = (variant === VARIANTS.CHESS960) ? VARIANTS.CHESS960 : VARIANTS.STANDARD;

        // Same validation setPosition() applies to every later position
        // change - an invalid initialFen (bad king count, unusable castling
        // rights, or anything else chessops rejects) falls back to the
        // default reset position, and the reason is returned below so the
        // caller can tell the user, instead of silently substituting a
        // different position with no feedback.
        const built = _buildPosition(initialFen);
        let loadError = null;
        if (built.ok) {
            _position = built.pos;
        } else {
            loadError = built.reason;
            _position = Chess.default();
        }
        _startFen = currentFen();

        // Built from _startFen (the validated/fallback position), not the
        // raw initialFen - otherwise an invalid initialFen leaves the
        // visible board showing the rejected placement while _position
        // already holds the fallback, a desync baked in right at startup.
        cg = Chessground(document.getElementById('board'), {
            fen:                  _startFen,
            orientation:          _restoredOrientation(),
            turnColor:            _position.turn,
            check:                _position.isCheck() ? _position.turn : false,
            lastMove:             undefined,
            coordinates:          true,
            // coordinatesOnSquares stays false: that mode prints a combined
            // "a8"-style label on all 64 squares, whereas this app wants the
            // classic look - a rank number down the left column and a file
            // letter along the bottom row only, both sitting inset at the
            // board's edges. Chessground's native coords.ranks/coords.files
            // strips (one rank-only label per row, one file-only label per
            // column) already produce that layout once repositioned via CSS
            // (see chess/board.css) to sit inside the board edge instead of outside
            // it, so the combined per-square mode isn't needed here.
            coordinatesOnSquares: false,
            // Castling is driven by the chessops position (_position), not
            // chessground's own king-two-squares heuristic, so chessground
            // should never second-guess or auto-correct a king move into a
            // castle itself - this also holds for Chess960's king-to-rook
            // representation, which chessground has no native concept of.
            autoCastle:           false,
            viewOnly:             false,
            disableContextMenu:   true,
            highlight:            { lastMove: true, check: true },
            animation:            { enabled: true, duration: 200 },
            movable: {
                // Any drag is provisionally accepted here and classified
                // afterward by _handleBoardMutation, rather than gating
                // drags up front with a separate edit-mode toggle.
                free:  true,
                color: 'both',
                showDests: true,
                events: { after: (orig, dest) => _handleBoardMutation(orig, dest) },
            },
            premovable:  { enabled: false },
            draggable: {
                enabled:         true,
                showGhost:       true,
                deleteOnDropOff: true,
            },
            selectable: { enabled: true },
            events: {
                move:         (orig, dest) => _handleBoardMutation(orig, dest),
                change:       () => _handleBoardMutation(),
                dropNewPiece: () => _handleBoardMutation(),
                select:       (key) => _onCgSelect(key),
            },
            drawable: {
                enabled: true,
                visible: true,
                brushes: {
                    dtz:   { key: 'dtz',   color: '#2451c4', opacity: 0.80, lineWidth: 10 },
                    dtc:   { key: 'dtc',   color: '#d113c6', opacity: 0.80, lineWidth: 10 },
                    dtm:   { key: 'dtm',   color: '#8b93a1', opacity: 0.80, lineWidth: 10 },
                    dtm50: { key: 'dtm50', color: '#e1453a', opacity: 0.80, lineWidth: 10 },
                },
            },
        });

        const dialog = document.getElementById('promotion-dialog');
        dialog.querySelectorAll('.promotion-piece-btn').forEach(btn => {
            btn.addEventListener('click', () => _onPromotionSelect(btn.dataset.piece));
        });
        dialog.addEventListener('click', e => {
            if (e.target === dialog) _cancelPromotion();
        });
        document.addEventListener('keydown', e => {
            if (e.key !== 'Escape' || !dialog.classList.contains('is-visible')) return;
            _cancelPromotion();
            // The promotion dialog sits on top of everything else - stop
            // this Escape from also reaching the PGN dialog/settings-panel
            // handlers (see PgnDialog.jsx, SettingsPanel.jsx), which would otherwise close those too
            // if either happened to be open underneath it.
            e.stopImmediatePropagation();
        });

        _populateTrayImages();
        _initSpareTrays();
        _syncTrayOrientation();

        // Restored the same way orientation is above - persist:false since
        // this is a stored preference being applied on load, not a new one
        // being set, so it's not written straight back to the same key.
        setLocked(_restoredLocked(), false);

        return loadError ? { ok: false, reason: loadError } : { ok: true };
    }

    /**
     * Set the piece-set CSS <link> and populate the spare-tray and
     * promotion-dialog images. Registered with theme.js via
     * Theme.init(reconstruct) and invoked once at bootstrap, after theme.js
     * injects the board's theme <style> tag.
     *
     * This never touches the Chessground instance itself - piece images are
     * plain CSS (`.cg-wrap piece.<role>.<color>`), not baked into a
     * constructor closure.
     */
    function reconstruct() {
        if (!cg || !_position) return;
        const link = document.getElementById('chesstb-piece-css');
        if (link) link.href = `/static/css/pieces-${Theme.currentPieceSet()}.css`;
        _populateTrayImages();
    }

    function setPosition(fen) {
        const prevFen = _position ? currentFen() : null;
        // Re-submitting the FEN already on the board (e.g. pressing Enter in
        // the FEN box without editing it) is a no-op - skip the undo-stack
        // push and tree reset so the current move line survives it.
        if (fen === prevFen) return { ok: true };
        const built = _buildPosition(fen);
        if (!built.ok) return { ok: false, reason: built.reason };
        _position = built.pos;
        if (prevFen !== null) _pushHistory(prevFen);
        _hidePromotionDialog();
        _pendingPromotion = null;
        _lastMoveKeys = undefined;
        _resetMoveLine();
        _syncChessground();
        // Position-change callback, as in playMove()/goBack()/goForward()/
        // goToNode()/clear().
        const nextFen = currentFen();
        if (_onPositionChange) _onPositionChange(nextFen);
        return { ok: true };
    }

    // Sets a new FEN and variant together in a single step - for a caller
    // that is replacing the position anyway (a shared URL, PGN import,
    // restoreTree()'s fallback path), so there is no "current position"
    // to preserve or validate against the new variant; the new FEN is
    // validated directly against the new variant instead (see
    // _buildPosition). Use setVariant() instead when the FEN is meant to
    // stay exactly as it is and only its interpretation should change
    // (e.g. the settings-panel toggle).
    function setPositionAndVariant(fen, variant) {
        const next = (variant === VARIANTS.CHESS960) ? VARIANTS.CHESS960 : VARIANTS.STANDARD;
        const prevFen = _position ? currentFen() : null;
        if (fen === prevFen && next === _variant) return { ok: true };   // true no-op
        const built = _buildPosition(fen, next);
        if (!built.ok) return { ok: false, reason: built.reason };
        _variant = next;
        _position = built.pos;
        if (prevFen !== null) _pushHistory(prevFen);
        _hidePromotionDialog();
        _pendingPromotion = null;
        _lastMoveKeys = undefined;
        _resetMoveLine();
        _syncChessground();
        if (_onPositionChange) _onPositionChange(currentFen());
        return { ok: true };
    }

    function clear() {
        const prevFen  = currentFen();
        const resetFen = '4k3/8/8/8/8/8/8/4K3 w - - 0 1';
        const built = _buildPosition(resetFen);
        console.assert(built.ok, 'clear(): resetFen must always be valid');
        _pushHistory(prevFen);
        _position = built.pos;
        _hidePromotionDialog();
        _pendingPromotion = null;
        _lastMoveKeys = undefined;
        _resetMoveLine();
        _syncChessground();
        if (_onPositionChange) _onPositionChange(resetFen);
        return resetFen;
    }

    // Mirrors chessground's own orientation as a class on #board-wrap-inner;
    // chess/board.css uses it to flip flex-direction so the spare-piece trays swap
    // sides visually without moving them in the DOM.
    function _syncTrayOrientation() {
        const wrapEl = document.getElementById('board-wrap-inner');
        if (wrapEl) wrapEl.classList.toggle('orientation-black', cg.state.orientation === 'black');
    }

    function flip() {
        cg.toggleOrientation();
        _syncTrayOrientation();
        Storage.write('chesstb_orientation', cg.state.orientation);
        clearArrows();   // arrows are orientation-dependent; caller (useExplorer.js) redraws right after flip
    }

    // ── Lock mode (public) ───────────────────────────────────────────────────
    // Toggles legal-moves-only board interaction. Persisted to localStorage
    // the same way orientation is (see flip()) when persist defaults to
    // true; callers applying an already-known value (init() restoring on
    // load, or useExplorer.js's auto-play engaging/releasing Lock) pass persist:false.
    function setLocked(locked, persist = true) {
        _locked = !!locked;
        if (_locked) setClickPlacePiece(null);   // drop any armed spare piece
        document.querySelectorAll('.spare-tray').forEach(el => {
            el.classList.toggle('is-locked', _locked);
            if (_locked) el.setAttribute('title', 'Board is locked');
            else el.removeAttribute('title');
        });
        if (persist) Storage.write('chesstb_locked', _locked);
        _syncChessground();
    }
    function isLocked() { return _locked; }

    // ── Variant (public) ─────────────────────────────────────────────────────
    // Persistence and toggle-panel wiring live in useExplorer.js and
    // SettingsPanel.jsx (Chess960 Mode is a Settings-panel item, alongside
    // Autoplay Delay and Show Root Row) - this module only holds the
    // current value and reacts to it changing.
    function setVariant(variant) {
        const next = (variant === VARIANTS.CHESS960) ? VARIANTS.CHESS960 : VARIANTS.STANDARD;
        if (next === _variant) return { ok: true };
        // This reinterprets the current position under a different
        // variant - the FEN itself is not changing (see
        // setPositionAndVariant() above for the "also loading a new
        // position" case) - so unlike every other _buildPosition() call in
        // this file, failure here must not fall back to a default
        // position or otherwise change what's on the board: the position
        // simply isn't representable under the requested variant's
        // castling rules (e.g. Chess960-only castling rights present, or
        // Chess960 castling rights on non-home squares - see
        // _nonOrthodoxCastlingRights), and the switch is refused outright,
        // leaving variant and position exactly as they were.
        if (_position) {
            const trial = _buildPosition(currentFen(), next);
            if (!trial.ok) {
                const modeName = next === VARIANTS.CHESS960 ? 'Chess960' : 'Standard';
                return { ok: false, reason: `Can't switch to ${modeName} mode: ${trial.reason}` };
            }
        }
        _variant = next;
        // The move tree belongs to the active variant; changing variants
        // starts a fresh tree from the current position.
        _lastMoveKeys = undefined;
        _resetMoveLine();
        _syncChessground();
        // Position change with no actual FEN change - still routed through
        // onPositionChange so callers re-probe under the new variant and
        // (via onPositionChange's own guard) auto-play is stopped rather
        // than left running against a variant it started under.
        if (_onPositionChange) _onPositionChange(currentFen());
        return { ok: true };
    }
    function getVariant()  { return _variant; }
    function isChess960()  { return _variant === VARIANTS.CHESS960; }

    // Legal move count for the current position, counting each
    // underpromotion choice separately (see _countLegalMoves above) and
    // including Chess960 castling.
    function legalMoveCount() { return _position ? _countLegalMoves(_position) : 0; }
    function isInsufficientMaterial() { return !!_position && _position.isInsufficientMaterial(); }

    // Result token for an arbitrary FEN, independent of the live board
    // state - used by pgnFormat.js's PGN-result detection. Returns '*'
    // (unknown/in progress) for a FEN that fails to parse.
    function outcomeFromFen(fen) {
        const built = _buildPosition(fen);
        if (!built.ok) return '*';
        const pos = built.pos;
        if (pos.isCheckmate()) return pos.turn === 'white' ? '0-1' : '1-0';
        if (pos.isStalemate() || pos.isInsufficientMaterial()) return '1/2-1/2';
        return '*';
    }

    function playMove(san) {
        if (!_position) return false;
        const move = parseSan(_position, san);
        if (!move) return false;
        const fromKey = makeSquare(move.from), toKey = makeSquare(move.to);
        const playedSan = makeSan(_position, move);
        _position.play(move);

        _lastMoveKeys = [fromKey, toKey];

        // Track in the move tree (branches instead of overwriting if the
        // user had navigated back before playing this move).
        _addMove(playedSan, currentFen(), fromKey, toKey);
        _emitHistory();
        _syncChessground();

        // immediate=true: this is a single, definite move (played by
        // auto-play or by clicking a move in the ranked-moves table, the
        // two callers of playMove() - see useExplorer.js), not part of a
        // rapid-fire stream of changes the 300ms debounce guards against.
        if (_onPositionChange) _onPositionChange(currentFen(), true);
        return true;
    }

    // Back/Forward walk the move tree directly (parent / activeChild) so
    // stepping through a line that includes variations works the same as
    // stepping through the main line. The plain _history/_future FEN stack
    // is only consulted once navigation reaches the tree's root (id ROOT)
    // and goes further back than the tree itself - i.e. undoing past
    // whatever move/edit started the current tree (see _resetMoveLine).
    function goBack() {
        if (_currentId !== ROOT) {
            const parentId = _nodes[_currentId].parentId;
            const fen = parentId === ROOT ? _startFen : _nodes[parentId].fen;
            const built = _buildPosition(fen);
            if (!built.ok) { _syncChessground(); return false; }
            _position = built.pos;
            _lastMoveKeys = parentId === ROOT ? undefined : [_nodes[parentId].from, _nodes[parentId].to];
            _currentId = parentId;
        } else {
            if (_history.length === 0) return false;
            const prevFen = _history.pop();
            _future.push(currentFen());
            const built = _buildPosition(prevFen);
            if (!built.ok) {
                _future.pop();
                _history.push(prevFen);
                _syncChessground();
                return false;
            }
            _position = built.pos;
            // The plain _history/_future stack holds FENs only, with no
            // accompanying from/to squares (unlike tree nodes), so there's
            // nothing to highlight as the last move here.
            _lastMoveKeys = undefined;
            // The loaded position does not match the tree's _startFen, so
            // the tree is reset. _resetMoveLine() also clears _future, so the
            // stack is saved and restored around the reset.
            const _pendingFuture = _future.slice();
            _resetMoveLine();
            _future = _pendingFuture;
        }
        _hidePromotionDialog();
        _pendingPromotion = null;
        _syncChessground();
        _emitHistory();
        if (_onPositionChange) _onPositionChange(currentFen());
        return true;
    }

    function goForward() {
        const activeChildId = _activeChildOf(_currentId);
        if (activeChildId !== null && activeChildId !== undefined) {
            const node = _nodes[activeChildId];
            const built = _buildPosition(node.fen);
            if (!built.ok) { _syncChessground(); return false; }
            _position = built.pos;
            _lastMoveKeys = [node.from, node.to];
            _currentId = activeChildId;
        } else if (_currentId === ROOT && _future.length > 0) {
            const nextFen = _future.pop();
            const built = _buildPosition(nextFen);
            if (!built.ok) {
                _future.push(nextFen);
                _syncChessground();
                return false;
            }
            _history.push(currentFen());
            _position = built.pos;
            _lastMoveKeys = undefined;
            // Mirrors the goBack() fallback above: the position just loaded
            // isn't described by the current (already-reset) tree either, so
            // restart the tree here too and preserve any remaining redo
            // entries across the reset.
            const _pendingFuture = _future.slice();
            _resetMoveLine();
            _future = _pendingFuture;
        } else {
            return false;
        }
        _hidePromotionDialog();
        _pendingPromotion = null;
        _syncChessground();
        _emitHistory();
        if (_onPositionChange) _onPositionChange(currentFen());
        return true;
    }

    // goToNode() jumps to an arbitrary node in the current move tree (used
    // by the PGN panel - including variation moves, not just the main line).
    // Unlike setPosition(), this never calls _resetMoveLine(). targetId ===
    // ROOT (-1) means "start of the tree" (the position before any move was
    // played). Clicking any node marks it - and every ancestor on the path
    // to it - as its parent's activeChild, so Forward continues along
    // whichever branch was just brought into view.
    function goToNode(targetId) {
        if (targetId !== ROOT && !_nodes[targetId]) return false;
        if (targetId === _currentId) return true;

        // Walked before touching _position/_syncChessground, and bounded to
        // at most one hop per node, so a corrupt parentId chain (see
        // _isValidTree) refuses the jump instead of looping forever.
        const chain = [];
        let walk  = targetId;
        let guard = _nodes.length + 1;
        while (walk !== ROOT) {
            if (guard-- <= 0 || !_nodes[walk]) return false;
            chain.unshift(walk);
            walk = _nodes[walk].parentId;
        }

        const fen = targetId === ROOT ? _startFen : _nodes[targetId].fen;
        const built = _buildPosition(fen);
        if (!built.ok) return false;
        _position = built.pos;

        let parent = ROOT;
        chain.forEach(id => { _setActiveChild(parent, id); parent = id; });
        _currentId = targetId;
        _lastMoveKeys = targetId === ROOT ? undefined : [_nodes[targetId].from, _nodes[targetId].to];

        _hidePromotionDialog();
        _pendingPromotion = null;
        _syncChessground();
        _emitHistory();
        if (_onPositionChange) _onPositionChange(currentFen());
        return true;
    }

    // A legitimately-built tree (see _addMove above) only ever gives a node
    // a parentId that's ROOT or an already-existing, strictly smaller id,
    // and only ever lists children/activeChild with a strictly larger one,
    // so parentId chains and children references can never cycle or dangle.
    // Persisted state coming back out of localStorage bypasses that
    // construction path entirely; this re-checks the same invariant before
    // trusting it, since violating it would let goToNode()'s parentId walk
    // (or moveLine.js's tree walk) loop forever or index past the array.
    function _isValidNodeRef(id, nodesLength) {
        return typeof id === 'number' && Number.isInteger(id) && id >= 0 && id < nodesLength;
    }
    function _isValidTree(nodes, rootChildren) {
        if (!Array.isArray(nodes) || !Array.isArray(rootChildren)) return false;
        for (let id = 0; id < nodes.length; id++) {
            const node = nodes[id];
            if (!node || typeof node.san !== 'string' || typeof node.fen !== 'string') return false;
            if (node.parentId !== ROOT && !(_isValidNodeRef(node.parentId, nodes.length) && node.parentId < id)) {
                return false;
            }
            if (!Array.isArray(node.children)) return false;
            for (const childId of node.children) {
                if (!_isValidNodeRef(childId, nodes.length) || childId <= id) return false;
            }
            if (node.activeChild !== null && node.activeChild !== undefined &&
                !(_isValidNodeRef(node.activeChild, nodes.length) && node.activeChild > id)) {
                return false;
            }
        }
        return rootChildren.every(childId => _isValidNodeRef(childId, nodes.length));
    }

    // restoreTree() rehydrates a full move tree (start position + every
    // node + current node) from persisted state in a single board update,
    // without replaying each move or triggering individual probes.
    // The active variant must already be established (via init()'s variant
    // argument) before this is called - this function only restores
    // position/tree data, never variant.
    function restoreTree(startFen, nodes, rootChildren, rootActiveChild, currentId) {
        if (!_position || !startFen) return false;
        const validTree        = _isValidTree(nodes, rootChildren);
        const safeNodes        = validTree ? nodes : [];
        const safeRootChildren = validTree ? rootChildren : [];
        const safeCurrentId    = (currentId === ROOT || (validTree && _isValidNodeRef(currentId, safeNodes.length)))
            ? currentId : ROOT;

        const loadFen = safeCurrentId === ROOT ? startFen : safeNodes[safeCurrentId].fen;
        const built = _buildPosition(loadFen);
        if (!built.ok) {
            // Saved state doesn't parse (e.g. corrupted storage) - fall back
            // to just the start position with an empty tree.
            const fallback = _buildPosition(startFen);
            _position = fallback.ok ? fallback.pos : Chess.default();
            _startFen         = currentFen();
            _nodes            = [];
            _rootChildren     = [];
            _rootActiveChild  = null;
            _currentId        = ROOT;
            _history          = [];
            _future           = [];
            _lastMoveKeys     = undefined;
            if (cg) {
                _hidePromotionDialog();
                _syncChessground();
            }
            _emitHistory();
            return false;
        }
        _position = built.pos;

        _startFen        = startFen;
        _nodes            = safeNodes;
        _rootChildren     = safeRootChildren;
        _rootActiveChild  = _isValidNodeRef(rootActiveChild, safeNodes.length) ? rootActiveChild : null;
        _currentId        = safeCurrentId;
        _history          = [];
        _future           = [];
        _lastMoveKeys     = (safeCurrentId === ROOT || !safeNodes[safeCurrentId])
            ? undefined
            : [safeNodes[safeCurrentId].from, safeNodes[safeCurrentId].to];

        _hidePromotionDialog();
        _pendingPromotion = null;
        if (cg) _syncChessground();
        _emitHistory();
        return true;
    }

    // Install a parsed PGN in one update. Only the displayed start position
    // is probed; every imported move stays available for navigation/export.
    function importGame(tree, variant) {
        const next = variant === VARIANTS.CHESS960 ? VARIANTS.CHESS960 : VARIANTS.STANDARD;
        const built = _buildPosition(tree.startFen, next);
        if (!built.ok) return { ok: false, reason: built.reason };
        if (!_isValidTree(tree.nodes, tree.rootChildren)) {
            return { ok: false, reason: 'Invalid move tree in PGN.' };
        }
        _variant = next;
        _position = built.pos;
        restoreTree(tree.startFen, tree.nodes, tree.rootChildren, tree.rootActiveChild, ROOT);
        if (_onPositionChange) _onPositionChange(currentFen(), true);
        return { ok: true };
    }

    function canGoBack()    { return _currentId !== ROOT || _history.length > 0; }
    function canGoForward() {
        const activeChildId = _activeChildOf(_currentId);
        return (activeChildId !== null && activeChildId !== undefined) || (_currentId === ROOT && _future.length > 0);
    }

    function getMoveHistory() {
        return { nodes: _nodes, rootChildren: _rootChildren, rootActiveChild: _rootActiveChild, currentId: _currentId };
    }
    function getStartFen() { return _startFen; }       // PGN formatting
    function setOnMoveHistoryChange(fn) {
        _onMoveHistoryChange = fn;
    }

    return {
        init, reconstruct, setPosition, setPositionAndVariant, clear, flip, currentFen,
        playMove, goBack, goForward, goToNode, restoreTree, importGame, canGoBack, canGoForward,
        getMoveHistory, getStartFen, setOnMoveHistoryChange,
        drawArrows, clearArrows,
        setLocked, isLocked,
        setVariant, getVariant, isChess960, legalMoveCount, isInsufficientMaterial, outcomeFromFen,
    };

})();

export { Board, VARIANTS };