@alepot55/chessboardjs 2.3.7 → 2.3.8

package/dist/chessboard.esm.js

@@ -124,7 +124,6 @@ const ERROR_MESSAGES = Object.freeze({
     invalid_fadeTime: 'Invalid fadeTime: ',
     invalid_fadeAnimation: 'Invalid fadeAnimation: ',
     invalid_ratio: 'Invalid ratio: ',
-    invalid_animationStyle: 'Invalid animationStyle: ',
     animation_failed: 'Animation failed: ',
     
     // Event handlers
@@ -346,7 +345,7 @@ class PieceError extends ChessboardError {
 }
 
 /**
- * Service for input validation and data sanitization
+ * ValidationService - Handles input validation and data sanitization
  * @module services/ValidationService
  * @since 2.0.0
  */
@@ -376,7 +375,6 @@ const VALID_VALUES = Object.freeze({
     movableColors: ['w', 'b', 'white', 'black', 'both', 'none'],
     dropOffBoard: ['snapback', 'trash'],
     easingTypes: ['linear', 'ease', 'ease-in', 'ease-out', 'ease-in-out'],
-    animationStyles: ['sequential', 'simultaneous'],
     modes: ['normal', 'creative', 'analysis'],
     promotionPieces: ['q', 'r', 'b', 'n', 'Q', 'R', 'B', 'N']
 });
@@ -396,45 +394,39 @@ const SIZE_CONSTRAINTS = Object.freeze({
 /**
  * Service responsible for validating inputs and data
  * Implements caching for performance optimization
- * @class
+ * @class ValidationService
  */
 class ValidationService {
     /**
-     * Creates a new ValidationService instance
+     * Create a new ValidationService instance
      */
     constructor() {
-        // Cache for validation results to improve performance
         this._validationCache = new Map();
         this._cacheMaxSize = 1000;
-        
-        // Compile patterns for reuse
         this._patterns = VALIDATION_PATTERNS;
         this._validValues = VALID_VALUES;
         this._constraints = SIZE_CONSTRAINTS;
     }
 
     /**
-     * Validates a square identifier with caching
+     * Validate a square identifier with caching
      * @param {string} square - Square to validate (e.g., 'e4')
      * @returns {boolean} True if valid
      */
     isValidSquare(square) {
         const cacheKey = `square:${square}`;
-        
         if (this._validationCache.has(cacheKey)) {
             return this._validationCache.get(cacheKey);
         }
-        
-        const isValid = typeof square === 'string' && 
-                        square.length === 2 && 
-                        this._patterns.square.test(square);
-        
+        const isValid = typeof square === 'string' &&
+            square.length === 2 &&
+            this._patterns.square.test(square);
         this._cacheValidationResult(cacheKey, isValid);
         return isValid;
     }
 
     /**
-     * Validates a piece identifier with enhanced format support
+     * Validate a piece identifier with enhanced format support
      * @param {string} piece - Piece to validate (e.g., 'wK', 'bp')
      * @returns {boolean} True if valid
      */
@@ -442,28 +434,22 @@ class ValidationService {
         if (typeof piece !== 'string' || piece.length !== 2) {
             return false;
         }
-        
         const cacheKey = `piece:${piece}`;
-        
         if (this._validationCache.has(cacheKey)) {
             return this._validationCache.get(cacheKey);
         }
-        
         const [first, second] = piece.split('');
-        
-        // Check both formats: [type][color] and [color][type]
-        const format1 = PIECE_TYPES.includes(first.toLowerCase()) && 
-                       PIECE_COLORS.includes(second);
-        const format2 = PIECE_COLORS.includes(first) && 
-                       PIECE_TYPES.includes(second.toLowerCase());
-        
+        const format1 = PIECE_TYPES.includes(first.toLowerCase()) &&
+            PIECE_COLORS.includes(second);
+        const format2 = PIECE_COLORS.includes(first) &&
+            PIECE_TYPES.includes(second.toLowerCase());
         const isValid = format1 || format2;
         this._cacheValidationResult(cacheKey, isValid);
         return isValid;
     }
 
     /**
-     * Validates a FEN string with comprehensive checks
+     * Validate a FEN string with comprehensive checks
      * @param {string} fen - FEN string to validate
      * @returns {boolean} True if valid
      */
@@ -471,86 +457,64 @@ class ValidationService {
         if (typeof fen !== 'string') {
             return false;
         }
-        
         const cacheKey = `fen:${fen}`;
-        
         if (this._validationCache.has(cacheKey)) {
             return this._validationCache.get(cacheKey);
         }
-        
-        // Basic pattern check
         if (!this._patterns.fen.test(fen)) {
             this._cacheValidationResult(cacheKey, false);
             return false;
         }
-        
-        // Additional FEN validation
         const isValid = this._validateFenStructure(fen);
         this._cacheValidationResult(cacheKey, isValid);
         return isValid;
     }
 
     /**
-     * Validates FEN structure in detail
+     * Validate FEN structure in detail
      * @private
      * @param {string} fen - FEN string to validate
      * @returns {boolean} True if valid
      */
     _validateFenStructure(fen) {
         const parts = fen.split(' ');
-        
         if (parts.length !== 6) {
             return false;
         }
-        
-        // Validate piece placement
         const ranks = parts[0].split('/');
         if (ranks.length !== 8) {
             return false;
         }
-        
-        // Validate each rank
         for (const rank of ranks) {
             if (!this._validateRank(rank)) {
                 return false;
             }
         }
-        
-        // Validate active color
         if (!['w', 'b'].includes(parts[1])) {
             return false;
         }
-        
-        // Validate castling rights
         if (!/^[KQkq-]*$/.test(parts[2])) {
             return false;
         }
-        
-        // Validate en passant target
         if (parts[3] !== '-' && !this.isValidSquare(parts[3])) {
             return false;
         }
-        
-        // Validate halfmove clock and fullmove number
         const halfmove = parseInt(parts[4], 10);
         const fullmove = parseInt(parts[5], 10);
-        
-        return !isNaN(halfmove) && !isNaN(fullmove) && 
-               halfmove >= 0 && fullmove >= 1;
+        return !isNaN(halfmove) && !isNaN(fullmove) &&
+            halfmove >= 0 && fullmove >= 1;
     }
 
     /**
-     * Validates a single rank in FEN notation
+     * Validate a single rank in FEN notation
      * @private
      * @param {string} rank - Rank to validate
      * @returns {boolean} True if valid
      */
     _validateRank(rank) {
         let squares = 0;
-        
         for (let i = 0; i < rank.length; i++) {
             const char = rank[i];
-            
             if (/[1-8]/.test(char)) {
                 squares += parseInt(char, 10);
             } else if (/[prnbqkPRNBQK]/.test(char)) {
@@ -559,12 +523,11 @@ class ValidationService {
                 return false;
             }
         }
-        
         return squares === 8;
     }
 
     /**
-     * Validates a move string with comprehensive format support
+     * Validate a move string with comprehensive format support
      * @param {string} move - Move string to validate (e.g., 'e2e4', 'e7e8q')
      * @returns {boolean} True if valid
      */
@@ -572,20 +535,17 @@ class ValidationService {
         if (typeof move !== 'string') {
             return false;
         }
-        
         const cacheKey = `move:${move}`;
-        
         if (this._validationCache.has(cacheKey)) {
             return this._validationCache.get(cacheKey);
         }
-        
         const isValid = this._validateMoveFormat(move);
         this._cacheValidationResult(cacheKey, isValid);
         return isValid;
     }
 
     /**
-     * Validates move format in detail
+     * Validate move format in detail
      * @private
      * @param {string} move - Move string to validate
      * @returns {boolean} True if valid
@@ -594,21 +554,15 @@ class ValidationService {
         if (move.length < 4 || move.length > 5) {
             return false;
         }
-        
-        const from = move.slice(0, 2);
-        const to = move.slice(2, 4);
-        const promotion = move.slice(4, 5);
-        
+        const from = move.substring(0, 2);
+        const to = move.substring(2, 4);
         if (!this.isValidSquare(from) || !this.isValidSquare(to)) {
             return false;
         }
-        
-        if (promotion && !this._validValues.promotionPieces.includes(promotion)) {
+        if (move.length === 5 && !/[qrnb]/i.test(move[4])) {
             return false;
         }
-        
-        // Additional move validation (e.g., source and target different)
-        return from !== to;
+        return true;
     }
 
     /**
@@ -638,11 +592,9 @@ class ValidationService {
         if (size === 'auto') {
             return true;
         }
-        
         if (typeof size === 'number') {
             return size >= this._constraints.min && size <= this._constraints.max;
         }
-        
         return false;
     }
 
@@ -652,9 +604,9 @@ class ValidationService {
      * @returns {boolean} True if valid
      */
     isValidTime(time) {
-        return typeof time === 'number' && 
-               time >= 0 && 
-               time <= this._constraints.maxTime;
+        return typeof time === 'number' &&
+            time >= 0 &&
+            time <= this._constraints.maxTime;
     }
 
     /**
@@ -672,10 +624,10 @@ class ValidationService {
      * @returns {boolean} True if valid
      */
     isValidElementId(id) {
-        return typeof id === 'string' && 
-               id.length > 0 && 
-               id.length <= 100 && // Reasonable length limit
-               /^[a-zA-Z][\w:-]*$/.test(id); // Valid HTML ID format
+        return typeof id === 'string' &&
+            id.length > 0 &&
+            id.length <= 100 && // Reasonable length limit
+            /^[a-zA-Z][\w:-]*$/.test(id); // Valid HTML ID format
     }
 
     /**
@@ -705,14 +657,6 @@ class ValidationService {
         return this._validValues.easingTypes.includes(easing);
     }
 
-    /**
-     * Validates animation style
-     * @param {string} style - Animation style to validate
-     * @returns {boolean} True if valid
-     */
-    isValidAnimationStyle(style) {
-        return this._validValues.animationStyles.includes(style);
-    }
 
     /**
      * Validates CSS color format
@@ -723,24 +667,20 @@ class ValidationService {
         if (typeof color !== 'string') {
             return false;
         }
-        
         // Check for hex colors
         if (this._patterns.color.test(color)) {
             return true;
         }
-        
         // Check for named colors (basic set)
         const namedColors = ['white', 'black', 'red', 'green', 'blue', 'yellow', 'cyan', 'magenta'];
         if (namedColors.includes(color.toLowerCase())) {
             return true;
         }
-        
         // Check for rgb/rgba format
         if (/^rgb\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*\)$/.test(color) ||
             /^rgba\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*,\s*[0-1](\.\d+)?\s*\)$/.test(color)) {
             return true;
         }
-        
         return false;
     }
 
@@ -753,8 +693,8 @@ class ValidationService {
     validateSquare(square) {
         if (!this.isValidSquare(square)) {
             throw new ValidationError(
-                ERROR_MESSAGES.invalid_square + square, 
-                'square', 
+                ERROR_MESSAGES.invalid_square + square,
+                'square',
                 square
             );
         }
@@ -770,8 +710,8 @@ class ValidationService {
     validatePiece(piece) {
         if (!this.isValidPiece(piece)) {
             throw new ValidationError(
-                ERROR_MESSAGES.invalid_piece + piece, 
-                'piece', 
+                ERROR_MESSAGES.invalid_piece + piece,
+                'piece',
                 piece
             );
         }
@@ -787,8 +727,8 @@ class ValidationService {
     validateFen(fen) {
         if (!this.isValidFen(fen)) {
             throw new ValidationError(
-                ERROR_MESSAGES.invalid_fen + fen, 
-                'fen', 
+                ERROR_MESSAGES.invalid_fen + fen,
+                'fen',
                 fen
             );
         }
@@ -804,8 +744,8 @@ class ValidationService {
     validateMove(move) {
         if (!this.isValidMove(move)) {
             throw new ValidationError(
-                ERROR_MESSAGES.invalid_move + move, 
-                'move', 
+                ERROR_MESSAGES.invalid_move + move,
+                'move',
                 move
             );
         }
@@ -821,16 +761,15 @@ class ValidationService {
     validateOrientation(orientation) {
         if (!this.isValidOrientation(orientation)) {
             throw new ValidationError(
-                ERROR_MESSAGES.invalid_orientation + orientation, 
-                'orientation', 
+                ERROR_MESSAGES.invalid_orientation + orientation,
+                'orientation',
                 orientation
             );
         }
-        
         // Normalize to 'w' or 'b'
-        return orientation === 'white' ? 'w' : 
-               orientation === 'black' ? 'b' : 
-               orientation;
+        return orientation === 'white' ? 'w' :
+            orientation === 'black' ? 'b' :
+                orientation;
     }
 
     /**
@@ -842,16 +781,15 @@ class ValidationService {
     validateColor(color) {
         if (!this.isValidColor(color)) {
             throw new ValidationError(
-                ERROR_MESSAGES.invalid_color + color, 
-                'color', 
+                ERROR_MESSAGES.invalid_color + color,
+                'color',
                 color
             );
         }
-        
         // Normalize to 'w' or 'b'
-        return color === 'white' ? 'w' : 
-               color === 'black' ? 'b' : 
-               color;
+        return color === 'white' ? 'w' :
+            color === 'black' ? 'b' :
+                color;
     }
 
     /**
@@ -863,8 +801,8 @@ class ValidationService {
     validateSize(size) {
         if (!this.isValidSize(size)) {
             throw new ValidationError(
-                ERROR_MESSAGES.invalid_size + size, 
-                'size', 
+                ERROR_MESSAGES.invalid_size + size,
+                'size',
                 size
             );
         }
@@ -880,40 +818,29 @@ class ValidationService {
     validateConfig(config) {
         if (!config || typeof config !== 'object') {
             throw new ValidationError(
-                'Configuration must be an object', 
-                'config', 
+                'Configuration must be an object',
+                'config',
                 config
             );
         }
-        
         const errors = [];
-        
         // Validate required fields
         if (!config.id && !config.id_div) {
             errors.push('Configuration must include id or id_div');
         }
-        
         // Validate optional fields
         if (config.orientation && !this.isValidOrientation(config.orientation)) {
             errors.push(ERROR_MESSAGES.invalid_orientation + config.orientation);
         }
-        
         if (config.size && !this.isValidSize(config.size)) {
             errors.push(ERROR_MESSAGES.invalid_size + config.size);
         }
-        
         if (config.movableColors && !this.isValidMovableColors(config.movableColors)) {
             errors.push(ERROR_MESSAGES.invalid_color + config.movableColors);
         }
-        
         if (config.dropOffBoard && !this.isValidDropOffBoard(config.dropOffBoard)) {
             errors.push(ERROR_MESSAGES.invalid_dropOffBoard + config.dropOffBoard);
         }
-        
-        if (config.animationStyle && !this.isValidAnimationStyle(config.animationStyle)) {
-            errors.push(ERROR_MESSAGES.invalid_animationStyle + config.animationStyle);
-        }
-        
         // Validate callbacks
         const callbacks = ['onMove', 'onMoveEnd', 'onChange', 'onDragStart', 'onDragMove', 'onDrop', 'onSnapbackEnd'];
         for (const callback of callbacks) {
@@ -921,7 +848,6 @@ class ValidationService {
                 errors.push(`Invalid ${callback} callback`);
             }
         }
-        
         // Validate colors
         const colorFields = ['whiteSquare', 'blackSquare', 'highlight', 'hintColor'];
         for (const field of colorFields) {
@@ -929,15 +855,13 @@ class ValidationService {
                 errors.push(`Invalid ${field} color: ${config[field]}`);
             }
         }
-        
         if (errors.length > 0) {
             throw new ValidationError(
-                `Configuration validation failed: ${errors.join(', ')}`, 
-                'config', 
+                `Configuration validation failed: ${errors.join(', ')}`,
+                'config',
                 config
             );
         }
-        
         return config;
     }
 
@@ -953,7 +877,6 @@ class ValidationService {
             const firstKey = this._validationCache.keys().next().value;
             this._validationCache.delete(firstKey);
         }
-        
         this._validationCache.set(key, result);
     }
 
@@ -985,7 +908,6 @@ class ValidationService {
         return validations.map(validation => {
             try {
                 const { type, value } = validation;
-                
                 switch (type) {
                     case 'square':
                         return { valid: this.isValidSquare(value), value };
@@ -1091,8 +1013,7 @@ const DEFAULT_CONFIG$1 = Object.freeze({
     fadeAnimation: 'ease',
     ratio: 0.9,
     piecesPath: '../assets/themes/default',
-    animationStyle: 'simultaneous',
-    simultaneousAnimationDelay: 0,
+    simultaneousAnimationDelay: 100,
     onMove: () => true,
     onMoveEnd: () => true,
     onChange: () => true,
@@ -1126,19 +1047,19 @@ class ChessboardConfig {
     constructor(settings = {}) {
         // Initialize validation service
         this._validationService = new ValidationService();
-        
+
         // Validate input
         this._validateInput(settings);
-        
+
         // Merge with defaults
         const config = this._mergeWithDefaults(settings);
-        
+
         // Process and validate configuration
         this._processConfiguration(config);
-        
+
         // Set CSS properties
         this._setCSSProperties(config);
-        
+
         // Configure mode-specific settings
         this._configureModeSettings();
     }
@@ -1153,7 +1074,7 @@ class ChessboardConfig {
         if (settings !== null && typeof settings !== 'object') {
             throw new ConfigurationError('Settings must be an object', 'settings', settings);
         }
-        
+
         // Validate using validation service
         try {
             this._validationService.validateConfig(settings);
@@ -1187,7 +1108,7 @@ class ChessboardConfig {
         this.size = config.size;
         this.movableColors = config.movableColors;
         this.piecesPath = config.piecesPath;
-        
+
         // Event handlers
         this.onMove = this._validateCallback(config.onMove);
         this.onMoveEnd = this._validateCallback(config.onMoveEnd);
@@ -1215,9 +1136,8 @@ class ChessboardConfig {
         this.snapbackTime = this._setTime(config.snapbackTime);
         this.dropCenterTime = this._setTime(config.dropCenterTime);
         this.fadeTime = this._setTime(config.fadeTime);
-        
+
         // Animation style properties
-        this.animationStyle = this._validateAnimationStyle(config.animationStyle);
         this.simultaneousAnimationDelay = this._validateDelay(config.simultaneousAnimationDelay);
     }
 
@@ -1278,19 +1198,6 @@ class ChessboardConfig {
         return callback;
     }
 
-    /**
-     * Validates animation style
-     * @private
-     * @param {string} style - Animation style
-     * @returns {string} Validated style
-     * @throws {ConfigurationError} If style is invalid
-     */
-    _validateAnimationStyle(style) {
-        if (!this._validationService.isValidAnimationStyle(style)) {
-            throw new ConfigurationError('Invalid animation style', 'animationStyle', style);
-        }
-        return style;
-    }
 
     /**
      * Validates animation delay
@@ -1348,11 +1255,11 @@ class ChessboardConfig {
             }
             return value;
         }
-        
+
         if (typeof value === 'string' && value in ANIMATION_TIMES) {
             return ANIMATION_TIMES[value];
         }
-        
+
         throw new ConfigurationError('Invalid time value', 'time', value);
     }
 
@@ -1367,11 +1274,11 @@ class ChessboardConfig {
         if (typeof value === 'boolean') {
             return value;
         }
-        
+
         if (value in BOOLEAN_VALUES) {
             return BOOLEAN_VALUES[value];
         }
-        
+
         throw new ConfigurationError('Invalid boolean value', 'boolean', value);
     }
 
@@ -1387,17 +1294,17 @@ class ChessboardConfig {
         if (typeof value === 'boolean') {
             return value ? TRANSITION_FUNCTIONS.ease : null;
         }
-        
+
         // Handle string values
         if (typeof value === 'string' && value in TRANSITION_FUNCTIONS) {
             return TRANSITION_FUNCTIONS[value];
         }
-        
+
         // Handle null/undefined
         if (value === null || value === undefined) {
             return null;
         }
-        
+
         throw new ConfigurationError('Invalid transition function', 'transitionFunction', value);
     }
 
@@ -1428,7 +1335,6 @@ class ChessboardConfig {
             fadeTime: this.fadeTime,
             fadeAnimation: this.fadeAnimation,
             piecesPath: this.piecesPath,
-            animationStyle: this.animationStyle,
             simultaneousAnimationDelay: this.simultaneousAnimationDelay,
             onlyLegalMoves: this.onlyLegalMoves
         };
@@ -1450,7 +1356,7 @@ class ChessboardConfig {
 
         // Apply updates
         const newConfig = Object.assign({}, this.toObject(), updates);
-        
+
         // Re-process configuration
         this._processConfiguration(newConfig);
         this._setCSSProperties(newConfig);
@@ -1673,22 +1579,10 @@ class Piece {
 
     setDrag(f) {
         if (!this.element) { console.debug(`[Piece] setDrag: ${this.id} - element is null`); return; }
-        // Remove previous handlers
-        this.element.onmousedown = null;
-        this.element.ontouchstart = null;
-        this.element.ondragstart = null;
-        if (window.PointerEvent) {
-            this.element.onpointerdown = null;
-        }
-        // Set new handlers
         this.element.ondragstart = (e) => { e.preventDefault(); };
         this.element.onmousedown = f;
         this.element.ontouchstart = f; // Drag touch
-        if (window.PointerEvent) {
-            this.element.onpointerdown = f;
-            console.debug(`[Piece] setDrag: pointerdown set for ${this.id}`);
-        }
-        console.debug(`[Piece] setDrag: mousedown/ontouchstart set for ${this.id}`);
+        console.debug(`[Piece] setDrag: ${this.id}`);
     }
 
     destroy() {
@@ -2028,180 +1922,155 @@ let Move$1 = class Move {
 };
 
 /**
- * Service for managing animations and transitions
+ * AnimationService - Gestione centralizzata delle animazioni e transizioni per la scacchiera
  * @module services/AnimationService
  * @since 2.0.0
  */
 
 /**
- * Service responsible for coordinating animations and transitions
- * @class
+ * Service responsabile del coordinamento delle animazioni e delle transizioni
+ * @class AnimationService
  */
 class AnimationService {
     /**
-     * Creates a new AnimationService instance
-     * @param {ChessboardConfig} config - Board configuration
+     * Crea una nuova istanza di AnimationService
+     * @param {Object} config - Configurazione della scacchiera
      */
     constructor(config) {
+        /** @type {Object} */
         this.config = config;
+        /** @type {Map<number, {element: HTMLElement, animate: Function, callback?: Function}>} */
         this.activeAnimations = new Map();
+        /** @type {number} */
         this.animationId = 0;
     }
 
     /**
-     * Creates a timing function for animations
-     * @param {string} [type='ease'] - Animation type
-     * @returns {Function} Timing function
+     * Crea una funzione di timing per le animazioni
+     * @param {string} [type='ease'] - Tipo di easing
+     * @returns {Function} Funzione di timing
      */
     createTimingFunction(type = 'ease') {
         return (elapsed, duration) => {
-            const x = elapsed / duration;
-
+            const x = duration > 0 ? Math.max(0, Math.min(1, elapsed / duration)) : 1;
             switch (type) {
-                case 'linear':
-                    return x;
-                case 'ease':
-                    return (x ** 2) * (3 - 2 * x);
-                case 'ease-in':
-                    return x ** 2;
-                case 'ease-out':
-                    return -1 * (x - 1) ** 2 + 1;
-                case 'ease-in-out':
-                    return (x < 0.5) ? 2 * x ** 2 : 4 * x - 2 * x ** 2 - 1;
-                default:
-                    return x;
+                case 'linear': return x;
+                case 'ease': return (x ** 2) * (3 - 2 * x);
+                case 'ease-in': return x ** 2;
+                case 'ease-out': return -1 * (x - 1) ** 2 + 1;
+                case 'ease-in-out': return (x < 0.5) ? 2 * x ** 2 : 4 * x - 2 * x ** 2 - 1;
+                default: return x;
             }
         };
     }
 
     /**
-     * Animates an element with given properties
-     * @param {HTMLElement} element - Element to animate
-     * @param {Object} properties - Properties to animate
-     * @param {number} duration - Animation duration in milliseconds
-     * @param {string} [easing='ease'] - Easing function
-     * @param {Function} [callback] - Callback when animation completes
-     * @returns {number} Animation ID
+     * Anima un elemento HTML con le proprietà specificate
+     * @param {HTMLElement} element - Elemento da animare
+     * @param {Object} properties - Proprietà da animare (es: {left: 100, top: 50, opacity: 1})
+     * @param {number} duration - Durata in ms
+     * @param {string} [easing='ease'] - Tipo di easing
+     * @param {Function} [callback] - Callback al termine
+     * @returns {number} ID dell'animazione
      */
     animate(element, properties, duration, easing = 'ease', callback) {
+        if (!element || typeof properties !== 'object' || typeof duration !== 'number') {
+            throw new Error('AnimationService.animate: parametri non validi');
+        }
         const animationId = ++this.animationId;
         const timingFunction = this.createTimingFunction(easing);
         const startTime = performance.now();
         const startValues = {};
-
-        // Store initial values
         Object.keys(properties).forEach(prop => {
             startValues[prop] = this._getInitialValue(element, prop);
         });
-
         const animate = (currentTime) => {
             const elapsed = currentTime - startTime;
             const progress = Math.min(elapsed / duration, 1);
             const easedProgress = timingFunction(elapsed, duration);
-
-            // Apply animated values
             Object.keys(properties).forEach(prop => {
                 const startValue = startValues[prop];
                 const endValue = properties[prop];
                 const currentValue = this._interpolateValue(startValue, endValue, easedProgress);
                 this._applyValue(element, prop, currentValue);
             });
-
             if (progress < 1 && this.activeAnimations.has(animationId)) {
                 requestAnimationFrame(animate);
             } else {
                 this.activeAnimations.delete(animationId);
-                if (callback) callback();
+                if (typeof callback === 'function') callback();
             }
         };
-
         this.activeAnimations.set(animationId, { element, animate, callback });
         requestAnimationFrame(animate);
-
         return animationId;
     }
 
     /**
-     * Cancels an animation
-     * @param {number} animationId - Animation ID to cancel
+     * Annulla una animazione attiva
+     * @param {number} animationId - ID dell'animazione
      */
     cancel(animationId) {
-        if (this.activeAnimations.has(animationId)) {
-            this.activeAnimations.delete(animationId);
-        }
+        this.activeAnimations.delete(animationId);
     }
 
     /**
-     * Cancels all animations
+     * Annulla tutte le animazioni attive
      */
     cancelAll() {
         this.activeAnimations.clear();
     }
 
     /**
-     * Gets initial value for a property
+     * Ottiene il valore iniziale di una proprietà
      * @private
-     * @param {HTMLElement} element - Element
-     * @param {string} property - Property name
-     * @returns {number} Initial value
+     * @param {HTMLElement} element
+     * @param {string} property
+     * @returns {number}
      */
     _getInitialValue(element, property) {
         if (!element || !element.style) return 0;
         switch (property) {
-            case 'opacity':
-                return parseFloat(getComputedStyle(element).opacity) || 1;
-            case 'left':
-                return parseFloat(element.style.left) || 0;
-            case 'top':
-                return parseFloat(element.style.top) || 0;
-            case 'scale':
-                return 1;
-            default:
-                return 0;
+            case 'opacity': return parseFloat(getComputedStyle(element).opacity) || 1;
+            case 'left': return parseFloat(element.style.left) || 0;
+            case 'top': return parseFloat(element.style.top) || 0;
+            case 'scale': return 1;
+            default: return 0;
         }
     }
 
     /**
-     * Interpolates between two values
+     * Interpola tra due valori
      * @private
-     * @param {number} start - Start value
-     * @param {number} end - End value
-     * @param {number} progress - Progress (0-1)
-     * @returns {number} Interpolated value
+     * @param {number} start
+     * @param {number} end
+     * @param {number} progress
+     * @returns {number}
      */
     _interpolateValue(start, end, progress) {
         return start + (end - start) * progress;
     }
 
     /**
-     * Applies animated value to element
+     * Applica il valore animato all'elemento
      * @private
-     * @param {HTMLElement} element - Element
-     * @param {string} property - Property name
-     * @param {number} value - Value to apply
+     * @param {HTMLElement} element
+     * @param {string} property
+     * @param {number} value
      */
     _applyValue(element, property, value) {
         if (!element || !element.style) return;
         switch (property) {
-            case 'opacity':
-                element.style.opacity = value;
-                break;
-            case 'left':
-                element.style.left = value + 'px';
-                break;
-            case 'top':
-                element.style.top = value + 'px';
-                break;
-            case 'scale':
-                element.style.transform = `scale(${value})`;
-                break;
-            default:
-                element.style[property] = value;
+            case 'opacity': element.style.opacity = value; break;
+            case 'left': element.style.left = value + 'px'; break;
+            case 'top': element.style.top = value + 'px'; break;
+            case 'scale': element.style.transform = `scale(${value})`; break;
+            default: element.style[property] = value;
         }
     }
 
     /**
-     * Cleans up resources
+     * Cleanup risorse e animazioni
      */
     destroy() {
         this.cancelAll();
@@ -2209,7 +2078,7 @@ class AnimationService {
 }
 
 /**
- * Service for managing board setup and DOM operations
+ * BoardService - Handles board DOM setup, manipulation, and resource management
  * @module services/BoardService
  * @since 2.0.0
  */
@@ -2217,45 +2086,45 @@ class AnimationService {
 
 /**
  * Service responsible for board DOM manipulation and setup
- * @class
+ * @class BoardService
  */
 class BoardService {
     /**
-     * Creates a new BoardService instance
-     * @param {ChessboardConfig} config - Board configuration
+     * Create a new BoardService instance
+     * @param {Object} config - Board configuration
      */
     constructor(config) {
+        /** @type {Object} */
         this.config = config;
+        /** @type {HTMLElement|null} */
         this.element = null;
+        /** @type {Object.<string, Square>} */
         this.squares = {};
     }
 
     /**
-     * Builds the board DOM element and attaches it to the configured container
-     * @throws {DOMError} When the container element cannot be found
+     * Build the board DOM element and attach it to the configured container
+     * @throws {DOMError} If the container element cannot be found
      */
     buildBoard() {
-        console.log('BoardService.buildBoard: Looking for element with ID:', this.config.id_div);
-
         this.element = document.getElementById(this.config.id_div);
         if (!this.element) {
             throw new DOMError(ERROR_MESSAGES.invalid_id_div + this.config.id_div, this.config.id_div);
         }
-
         this.resize(this.config.size);
-        this.element.className = "board";
+        this.element.className = 'board';
     }
 
     /**
-     * Creates all 64 squares and adds them to the board
+     * Create all 64 squares and add them to the board
      * @param {Function} coordConverter - Function to convert row/col to real coordinates
      */
     buildSquares(coordConverter) {
+        if (!this.element) throw new DOMError('Board element not initialized', this.config.id_div);
         for (let row = 0; row < BOARD_SIZE.ROWS; row++) {
             for (let col = 0; col < BOARD_SIZE.COLS; col++) {
                 const [squareRow, squareCol] = coordConverter(row, col);
                 const square = new Square(squareRow, squareCol);
-
                 this.squares[square.getId()] = square;
                 this.element.appendChild(square.element);
             }
@@ -2263,20 +2132,17 @@ class BoardService {
     }
 
     /**
-     * Removes all squares from the board and cleans up their resources
-     * Best practice: always destroy JS objects and DOM nodes, and clear references.
+     * Remove all squares from the board and clean up their resources
      */
     removeSquares() {
         for (const square of Object.values(this.squares)) {
-            // Always call destroy to remove DOM and clear piece reference
             square.destroy();
         }
         this.squares = {};
     }
 
     /**
-     * Removes all content from the board element
-     * Best practice: clear DOM and force element to be re-fetched on next build.
+     * Remove all content from the board element
      */
     removeBoard() {
         if (this.element) {
@@ -2286,9 +2152,9 @@ class BoardService {
     }
 
     /**
-     * Resizes the board to the specified size
+     * Resize the board to the specified size
      * @param {number|string} value - Size in pixels or 'auto'
-     * @throws {ValidationError} When size value is invalid
+     * @throws {ValidationError} If size value is invalid
      */
     resize(value) {
         if (value === 'auto') {
@@ -2302,15 +2168,13 @@ class BoardService {
     }
 
     /**
-     * Calculates the optimal size when 'auto' is specified
+     * Calculate the optimal size when 'auto' is specified
      * @private
      * @returns {number} Calculated size in pixels
      */
     _calculateAutoSize() {
-        if (!this.element) return 400; // Default fallback
-
+        if (!this.element) return 400;
         const { offsetWidth, offsetHeight } = this.element;
-
         if (offsetWidth === 0) {
             return offsetHeight || 400;
         } else if (offsetHeight === 0) {
@@ -2321,8 +2185,8 @@ class BoardService {
     }
 
     /**
-     * Gets a square by its ID
-     * @param {string} squareId - Square identifier (API pubblica)
+     * Get a square by its ID
+     * @param {string} squareId - Square identifier
      * @returns {Square|null} The square or null if not found
      */
     getSquare(squareId) {
@@ -2330,26 +2194,37 @@ class BoardService {
     }
 
     /**
-     * Highlight a square (solo oggetto)
+     * Highlight a square
      * @param {Square} square
      * @param {Object} [opts]
      */
     highlightSquare(square, opts = {}) {
-        if (!square) throw new Error('highlightSquare richiede oggetto Square');
-        // ... logica esistente ...
+        if (!square) throw new Error('highlightSquare requires a Square object');
+        // Implement highlight logic or call square.highlight() if available
+        if (typeof square.highlight === 'function') {
+            square.highlight(opts);
+        } else {
+            square.element.classList.add('highlighted');
+        }
     }
+
     /**
-     * Dehighlight a square (solo oggetto)
+     * Remove highlight from a square
      * @param {Square} square
      * @param {Object} [opts]
      */
     dehighlightSquare(square, opts = {}) {
-        if (!square) throw new Error('dehighlightSquare richiede oggetto Square');
-        // ... logica esistente ...
+        if (!square) throw new Error('dehighlightSquare requires a Square object');
+        // Implement dehighlight logic or call square.dehighlight() if available
+        if (typeof square.dehighlight === 'function') {
+            square.dehighlight(opts);
+        } else {
+            square.element.classList.remove('highlighted');
+        }
     }
 
     /**
-     * Gets all squares
+     * Get all squares
      * @returns {Object.<string, Square>} All squares indexed by ID
      */
     getAllSquares() {
@@ -2357,7 +2232,7 @@ class BoardService {
     }
 
     /**
-     * Applies a method to all squares
+     * Apply a method to all squares
      * @param {string} methodName - Name of the method to call on each square
      * @param {...*} args - Arguments to pass to the method
      */
@@ -2370,7 +2245,7 @@ class BoardService {
     }
 
     /**
-     * Cleans up all resources
+     * Clean up all resources
      */
     destroy() {
         this.removeSquares();
@@ -2381,7 +2256,7 @@ class BoardService {
 }
 
 /**
- * Service for managing coordinate conversions and board orientation
+ * CoordinateService - Handles coordinate conversions and board orientation logic
  * @module services/CoordinateService
  * @since 2.0.0
  */
@@ -2389,19 +2264,20 @@ class BoardService {
 
 /**
  * Service responsible for coordinate conversions and board orientation
- * @class
+ * @class CoordinateService
  */
 class CoordinateService {
     /**
-     * Creates a new CoordinateService instance
-     * @param {ChessboardConfig} config - Board configuration
+     * Create a new CoordinateService instance
+     * @param {Object} config - Board configuration
      */
     constructor(config) {
+        /** @type {Object} */
         this.config = config;
     }
 
     /**
-     * Converts logical coordinates to real coordinates based on board orientation
+     * Convert logical coordinates to real coordinates based on board orientation
      * @param {number} row - Row index (0-7)
      * @param {number} col - Column index (0-7)
      * @returns {Array<number>} Real coordinates [row, col] (1-8)
@@ -2409,18 +2285,16 @@ class CoordinateService {
     realCoord(row, col) {
         let realRow = row;
         let realCol = col;
-        
         if (this.isWhiteOriented()) {
             realRow = 7 - row;
         } else {
             realCol = 7 - col;
         }
-        
         return [realRow + 1, realCol + 1];
     }
 
     /**
-     * Converts board coordinates to square ID
+     * Convert board coordinates to square ID
      * @param {number} row - Row index (0-7)
      * @param {number} col - Column index (0-7)
      * @returns {string} Square ID (e.g., 'e4')
@@ -2428,7 +2302,6 @@ class CoordinateService {
     getSquareID(row, col) {
         row = parseInt(row);
         col = parseInt(col);
-        
         if (this.isWhiteOriented()) {
             row = 8 - row;
             col = col + 1;
@@ -2436,7 +2309,6 @@ class CoordinateService {
             row = row + 1;
             col = 8 - col;
         }
-        
         if (col < 1 || col > 8 || row < 1 || row > 8) {
             throw new ValidationError(
                 `Invalid board coordinates: row=${row}, col=${col}`,
@@ -2444,13 +2316,12 @@ class CoordinateService {
                 { row, col }
             );
         }
-        
         const letter = BOARD_LETTERS[col - 1];
         return letter + row;
     }
 
     /**
-     * Converts square ID to board coordinates
+     * Convert square ID to board coordinates
      * @param {string} squareId - Square ID (e.g., 'e4')
      * @returns {Array<number>} Board coordinates [row, col] (0-7)
      */
@@ -2462,10 +2333,8 @@ class CoordinateService {
                 squareId
             );
         }
-        
         const letter = squareId[0];
         const number = parseInt(squareId[1]);
-        
         const col = BOARD_LETTERS.indexOf(letter);
         if (col === -1) {
             throw new ValidationError(
@@ -2474,7 +2343,6 @@ class CoordinateService {
                 squareId
             );
         }
-        
         if (number < 1 || number > 8) {
             throw new ValidationError(
                 ERROR_MESSAGES.invalid_square + squareId,
@@ -2482,9 +2350,7 @@ class CoordinateService {
                 squareId
             );
         }
-        
         let row, boardCol;
-        
         if (this.isWhiteOriented()) {
             row = 8 - number;
             boardCol = col;
@@ -2492,12 +2358,11 @@ class CoordinateService {
             row = number - 1;
             boardCol = 7 - col;
         }
-        
         return [row, boardCol];
     }
 
     /**
-     * Converts pixel coordinates to square ID
+     * Convert pixel coordinates to square ID
      * @param {number} x - X coordinate in pixels
      * @param {number} y - Y coordinate in pixels
      * @param {HTMLElement} boardElement - Board DOM element
@@ -2505,21 +2370,15 @@ class CoordinateService {
      */
     pixelToSquareID(x, y, boardElement) {
         if (!boardElement) return null;
-        
         const rect = boardElement.getBoundingClientRect();
         const { width, height } = rect;
-        
-        // Check if coordinates are within board bounds
         if (x < 0 || x >= width || y < 0 || y >= height) {
             return null;
         }
-        
         const squareWidth = width / 8;
         const squareHeight = height / 8;
-        
         const col = Math.floor(x / squareWidth);
         const row = Math.floor(y / squareHeight);
-        
         try {
             return this.getSquareID(row, col);
         } catch (error) {
@@ -2528,25 +2387,21 @@ class CoordinateService {
     }
 
     /**
-     * Converts square ID to pixel coordinates
+     * Convert square ID to pixel coordinates
      * @param {string} squareId - Square ID (e.g., 'e4')
      * @param {HTMLElement} boardElement - Board DOM element
      * @returns {Object|null} Pixel coordinates {x, y} or null if invalid
      */
     squareIDToPixel(squareId, boardElement) {
         if (!boardElement) return null;
-        
         try {
             const [row, col] = this.getCoordinatesFromSquareID(squareId);
             const rect = boardElement.getBoundingClientRect();
             const { width, height } = rect;
-            
             const squareWidth = width / 8;
             const squareHeight = height / 8;
-            
             const x = col * squareWidth;
             const y = row * squareHeight;
-            
             return { x, y };
         } catch (error) {
             return null;
@@ -2554,7 +2409,7 @@ class CoordinateService {
     }
 
     /**
-     * Gets the center pixel coordinates of a square
+     * Get the center pixel coordinates of a square
      * @param {string} squareId - Square ID (e.g., 'e4')
      * @param {HTMLElement} boardElement - Board DOM element
      * @returns {Object|null} Center coordinates {x, y} or null if invalid
@@ -2562,11 +2417,9 @@ class CoordinateService {
     getSquareCenter(squareId, boardElement) {
         const coords = this.squareIDToPixel(squareId, boardElement);
         if (!coords) return null;
-        
         const rect = boardElement.getBoundingClientRect();
         const squareWidth = rect.width / 8;
         const squareHeight = rect.height / 8;
-        
         return {
             x: coords.x + squareWidth / 2,
             y: coords.y + squareHeight / 2
@@ -2574,7 +2427,7 @@ class CoordinateService {
     }
 
     /**
-     * Calculates the distance between two squares
+     * Calculate the distance between two squares
      * @param {string} fromSquare - Source square ID
      * @param {string} toSquare - Target square ID
      * @returns {number} Distance between squares
@@ -2583,10 +2436,8 @@ class CoordinateService {
         try {
             const [fromRow, fromCol] = this.getCoordinatesFromSquareID(fromSquare);
             const [toRow, toCol] = this.getCoordinatesFromSquareID(toSquare);
-            
             const rowDiff = Math.abs(toRow - fromRow);
             const colDiff = Math.abs(toCol - fromCol);
-            
             return Math.sqrt(rowDiff * rowDiff + colDiff * colDiff);
         } catch (error) {
             return 0;
@@ -2594,7 +2445,7 @@ class CoordinateService {
     }
 
     /**
-     * Checks if the board is oriented from white's perspective
+     * Check if the board is oriented from white's perspective
      * @returns {boolean} True if white-oriented
      */
     isWhiteOriented() {
@@ -2602,7 +2453,7 @@ class CoordinateService {
     }
 
     /**
-     * Checks if the board is oriented from black's perspective
+     * Check if the board is oriented from black's perspective
      * @returns {boolean} True if black-oriented
      */
     isBlackOriented() {
@@ -2610,31 +2461,31 @@ class CoordinateService {
     }
 
     /**
-     * Flips the board orientation
+     * Flip the board orientation
      */
     flipOrientation() {
         this.config.orientation = this.isWhiteOriented() ? 'b' : 'w';
     }
 
     /**
-     * Sets the board orientation
-     * @param {string} orientation - 'w' for white, 'b' for black
-     * @throws {ValidationError} When orientation is invalid
+     * Set the board orientation
+     * @param {string} orientation - 'w', 'b', 'white', or 'black'
+     * @throws {ValidationError} If orientation is invalid
      */
     setOrientation(orientation) {
-        if (orientation !== 'w' && orientation !== 'b') {
+        const normalized = orientation === 'white' ? 'w' : orientation === 'black' ? 'b' : orientation;
+        if (normalized !== 'w' && normalized !== 'b') {
             throw new ValidationError(
                 ERROR_MESSAGES.invalid_orientation + orientation,
                 'orientation',
                 orientation
             );
         }
-        
-        this.config.orientation = orientation;
+        this.config.orientation = normalized;
     }
 
     /**
-     * Gets the current orientation
+     * Get the current orientation
      * @returns {string} Current orientation ('w' or 'b')
      */
     getOrientation() {
@@ -2642,50 +2493,21 @@ class CoordinateService {
     }
 
     /**
-     * Sets the orientation
-     * @param {string} orientation - New orientation ('w', 'b', 'white', 'black')
-     */
-    setOrientation(orientation) {
-        // Normalize orientation
-        const normalizedOrientation = orientation === 'white' ? 'w' : 
-                                     orientation === 'black' ? 'b' : orientation;
-        
-        if (normalizedOrientation !== 'w' && normalizedOrientation !== 'b') {
-            throw new ValidationError(
-                ERROR_MESSAGES.invalid_orientation + orientation,
-                'orientation',
-                orientation
-            );
-        }
-        
-        this.config.orientation = normalizedOrientation;
-    }
-
-    /**
-     * Flips the board orientation
-     */
-    flipOrientation() {
-        this.config.orientation = this.isWhiteOriented() ? 'b' : 'w';
-    }
-
-    /**
-     * Gets all square IDs in order
+     * Get all square IDs in order
      * @returns {Array<string>} Array of all square IDs
      */
     getAllSquareIDs() {
         const squares = [];
-        
         for (let row = 0; row < 8; row++) {
             for (let col = 0; col < 8; col++) {
                 squares.push(this.getSquareID(row, col));
             }
         }
-        
         return squares;
     }
 
     /**
-     * Gets squares in a specific rank (row)
+     * Get all squares in a specific rank (row)
      * @param {number} rank - Rank number (1-8)
      * @returns {Array<string>} Array of square IDs in the rank
      */
@@ -2697,19 +2519,16 @@ class CoordinateService {
                 rank
             );
         }
-        
         const squares = [];
-        
         for (let col = 0; col < 8; col++) {
             const row = this.isWhiteOriented() ? 8 - rank : rank - 1;
             squares.push(this.getSquareID(row, col));
         }
-        
         return squares;
     }
 
     /**
-     * Gets squares in a specific file (column)
+     * Get all squares in a specific file (column)
      * @param {string} file - File letter (a-h)
      * @returns {Array<string>} Array of square IDs in the file
      */
@@ -2722,13 +2541,10 @@ class CoordinateService {
                 file
             );
         }
-        
         const squares = [];
-        
         for (let row = 0; row < 8; row++) {
             squares.push(this.getSquareID(row, col));
         }
-        
         return squares;
     }
 }
@@ -3108,6 +2924,67 @@ const DragOptimizations = {
     }
 };
 
+/**
+ * ListenerManager - Utility per la gestione centralizzata dei listener DOM
+ * Permette di aggiungere, rimuovere e pulire tutti i listener in modo sicuro e senza duplicazioni.
+ * @module utils/listenerManager
+ * @since 2.0.0
+ */
+
+class ListenerManager {
+    constructor() {
+        /**
+         * Lista di tutti i listener registrati
+         * @type {Array<{element: EventTarget, type: string, handler: Function, options?: any}>}
+         */
+        this.listeners = [];
+    }
+
+    /**
+     * Aggiunge un listener e lo traccia per la rimozione automatica
+     * @param {EventTarget} element - Elemento su cui aggiungere il listener
+     * @param {string} type - Tipo di evento
+     * @param {Function} handler - Funzione handler
+     * @param {Object|boolean} [options] - Opzioni per addEventListener
+     */
+    add(element, type, handler, options) {
+        if (!element || !type || !handler) return;
+        element.addEventListener(type, handler, options);
+        this.listeners.push({ element, type, handler, options });
+    }
+
+    /**
+     * Rimuove un listener specifico
+     * @param {EventTarget} element
+     * @param {string} type
+     * @param {Function} handler
+     */
+    remove(element, type, handler) {
+        if (!element || !type || !handler) return;
+        element.removeEventListener(type, handler);
+        this.listeners = this.listeners.filter(
+            l => !(l.element === element && l.type === type && l.handler === handler)
+        );
+    }
+
+    /**
+     * Rimuove tutti i listener registrati
+     */
+    removeAll() {
+        for (const { element, type, handler, options } of this.listeners) {
+            element.removeEventListener(type, handler, options);
+        }
+        this.listeners = [];
+    }
+
+    /**
+     * Pulizia risorse
+     */
+    destroy() {
+        this.removeAll();
+    }
+}
+
 /**
  * Service for managing events and user interactions
  * @module services/EventService
@@ -3140,8 +3017,8 @@ class EventService {
         this.promoting = false;
         this.isAnimating = false;
 
-        // Event listeners storage for cleanup
-        this.eventListeners = new Map();
+        // Listener manager per gestione centralizzata
+        this.listenerManager = new ListenerManager();
     }
 
     /**
@@ -3151,8 +3028,8 @@ class EventService {
      * @param {Function} onPieceLeave - Callback for piece leave
      */
     addListeners(onSquareClick, onPieceHover, onPieceLeave) {
-        // Remove existing listeners to avoid duplicates
-        this.removeListeners();
+        // Rimuovi tutti i listener esistenti
+        this.listenerManager.removeAll();
 
         const squares = this.boardService.getAllSquares();
 
@@ -3170,8 +3047,6 @@ class EventService {
      * @param {Function} onPieceLeave - Leave callback
      */
     _addSquareListeners(square, onSquareClick, onPieceHover, onPieceLeave) {
-        const listeners = [];
-
         // Throttled hover handlers for performance
         const throttledHover = rafThrottle((e) => {
             if (!this.clicked && this.config.hints) {
@@ -3241,26 +3116,13 @@ class EventService {
             }
         };
 
-        // Add listeners
-        square.element.addEventListener('mouseover', throttledHover);
-        square.element.addEventListener('mouseout', throttledLeave);
-        square.element.addEventListener('click', handleClick);
-        // Touch: separa tap e drag
-        square.element.addEventListener('touchstart', handleTouchStart);
-        square.element.addEventListener('touchmove', handleTouchMove);
-        square.element.addEventListener('touchend', handleTouchEnd);
-
-        // Store listeners for cleanup
-        listeners.push(
-            { element: square.element, type: 'mouseover', handler: throttledHover },
-            { element: square.element, type: 'mouseout', handler: throttledLeave },
-            { element: square.element, type: 'click', handler: handleClick },
-            { element: square.element, type: 'touchstart', handler: handleTouchStart },
-            { element: square.element, type: 'touchmove', handler: handleTouchMove },
-            { element: square.element, type: 'touchend', handler: handleTouchEnd }
-        );
-
-        this.eventListeners.set(square.id, listeners);
+        // Usa ListenerManager per aggiungere tutti i listener
+        this.listenerManager.add(square.element, 'mouseover', throttledHover);
+        this.listenerManager.add(square.element, 'mouseout', throttledLeave);
+        this.listenerManager.add(square.element, 'click', handleClick);
+        this.listenerManager.add(square.element, 'touchstart', handleTouchStart);
+        this.listenerManager.add(square.element, 'touchmove', handleTouchMove);
+        this.listenerManager.add(square.element, 'touchend', handleTouchEnd);
     }
 
     /**
@@ -3277,18 +3139,14 @@ class EventService {
      */
     createDragFunction(square, piece, onDragStart, onDragMove, onDrop, onSnapback, onMove, onRemove) {
         return (event) => {
-            event.preventDefault();
-
             if (!this.config.draggable || !piece || this.isAnimating) {
                 return;
             }
 
             const originalFrom = square;
-            let isDragging = false;
             let from = originalFrom;
             let to = square;
             let previousHighlight = null;
-
             const img = piece.element;
 
             if (!this.moveService.canMove(from)) {
@@ -3299,6 +3157,15 @@ class EventService {
             const isTouch = event.type && event.type.startsWith('touch');
             const startX = event.clientX || (event.touches && event.touches[0]?.clientX) || 0;
             const startY = event.clientY || (event.touches && event.touches[0]?.clientY) || 0;
+            let dragStarted = false;
+
+            // --- Calculate offset between cursor/finger and piece top-left at drag start ---
+            const pieceRect = img.getBoundingClientRect();
+            const boardElement = this.boardService.element;
+            const boardRect = boardElement.getBoundingClientRect();
+            // Offset from cursor/finger to top-left of piece
+            const offsetX = startX - pieceRect.left;
+            const offsetY = startY - pieceRect.top;
 
             // --- Touch scroll lock helper ---
             const addScrollLock = () => {
@@ -3310,10 +3177,6 @@ class EventService {
 
             // --- MOVE HANDLER (mouse + touch unified) ---
             const moveAt = (event) => {
-                const boardElement = this.boardService.element;
-                const squareSize = boardElement.offsetWidth / 8;
-
-                // Get mouse/touch coordinates
                 let clientX, clientY;
                 if (event.touches && event.touches[0]) {
                     clientX = event.touches[0].clientX;
@@ -3322,77 +3185,54 @@ class EventService {
                     clientX = event.clientX;
                     clientY = event.clientY;
                 }
-
-                // Calculate position relative to board
-                const boardRect = boardElement.getBoundingClientRect();
-                const x = clientX - boardRect.left - (squareSize / 2);
-                const y = clientY - boardRect.top - (squareSize / 2);
-
+                // Position the piece so the cursor/finger stays at the same relative point
+                const x = clientX - boardRect.left - offsetX;
+                const y = clientY - boardRect.top - offsetY;
                 img.style.left = x + 'px';
                 img.style.top = y + 'px';
-
                 return true;
             };
 
             // --- DRAG MOVE (mouse + touch) ---
+            const moveThreshold = 5; // px
             const onPointerMove = (event) => {
-                // For touch, only handle the first finger
                 if (event.touches && event.touches.length > 1) return;
                 if (event.touches && !event.touches[0]) return;
-                if (event.type && event.type.startsWith('touch')) event.preventDefault();
-
                 const currentX = event.clientX || (event.touches && event.touches[0]?.clientX) || 0;
                 const currentY = event.clientY || (event.touches && event.touches[0]?.clientY) || 0;
                 const deltaX = Math.abs(currentX - startX);
                 const deltaY = Math.abs(currentY - startY);
-
-                // Start dragging if mouse/touch moved enough
-                if (!isDragging && (deltaX > 3 || deltaY > 3)) {
-                    isDragging = true;
-                    // Inizio drag: blocca update board
+                if (!dragStarted && (deltaX > moveThreshold || deltaY > moveThreshold)) {
+                    dragStarted = true;
+                    if (isTouch) addScrollLock();
                     if (this.chessboard) this.chessboard._isDragging = true;
-
-                    // Mostra hint all'inizio del drag se attivi
                     if (this.config.hints && typeof this.chessboard._boundOnPieceHover === 'function') {
                         this.chessboard._boundOnPieceHover(from);
                     }
-
-                    // Set up drag state
                     if (!this.config.clickable) {
                         this.clicked = null;
                         this.clicked = from;
                     } else if (!this.clicked) {
                         this.clicked = from;
                     }
-
-                    // Visual feedback
                     if (this.config.clickable) {
                         from.select();
                     }
-
-                    // Prepare piece for dragging
                     img.style.position = 'absolute';
                     img.style.zIndex = '100';
                     img.classList.add('dragging');
-
                     DragOptimizations.enableForDrag(img);
-
-                    // Lock scroll for touch
-                    if (isTouch) addScrollLock();
-
-                    // Call drag start callback
                     if (!onDragStart(square, piece)) {
                         return;
                     }
                 }
-
-                if (!isDragging) return;
-
+                // Only block scroll and call preventDefault after drag has started
+                if (dragStarted && isTouch && event.cancelable) {
+                    event.preventDefault();
+                }
+                if (!dragStarted) return;
                 if (!moveAt(event)) ;
-
                 // Update target square
-                const boardElement = this.boardService.element;
-                const boardRect = boardElement.getBoundingClientRect();
                 let clientX, clientY;
                 if (event.touches && event.touches[0]) {
                     clientX = event.touches[0].clientX;
@@ -3403,22 +3243,16 @@ class EventService {
                 }
                 const x = clientX - boardRect.left;
                 const y = clientY - boardRect.top;
-
                 let newTo = null;
                 if (x >= 0 && x <= boardRect.width && y >= 0 && y <= boardRect.height) {
                     const squareId = this.coordinateService.pixelToSquareID(x, y, boardElement);
                     newTo = squareId ? this.boardService.getSquare(squareId) : null;
                 }
-
                 to = newTo;
                 onDragMove(from, to, piece);
-
-                // Update visual feedback
-                if (to !== previousHighlight) {
-                    to?.highlight();
-                    previousHighlight?.dehighlight();
-                    previousHighlight = to;
-                }
+                if (to) to.highlight();
+                if (previousHighlight && previousHighlight !== to) previousHighlight.dehighlight();
+                previousHighlight = to;
             };
 
             // --- DRAG END (mouse + touch) ---
@@ -3429,26 +3263,19 @@ class EventService {
                 document.removeEventListener('touchmove', onPointerMove);
                 window.removeEventListener('touchend', onPointerUp);
                 if (isTouch) removeScrollLock();
-                // Fine drag: sblocca update board
                 if (this.chessboard) this.chessboard._isDragging = false;
-
-                // Rimuovi hint alla fine del drag se attivi
                 if (this.config.hints && typeof this.chessboard._boundOnPieceLeave === 'function') {
                     this.chessboard._boundOnPieceLeave(from);
                 }
-
-                if (!isDragging) {
+                if (!dragStarted) {
                     return;
                 }
-
                 img.style.zIndex = '20';
                 img.classList.remove('dragging');
                 img.style.willChange = 'auto';
-
                 // Handle drop
                 const dropResult = onDrop(originalFrom, to, piece);
                 const isTrashDrop = !to && (this.config.dropOffBoard === 'trash' || dropResult === 'trash');
-
                 if (isTrashDrop) {
                     this._handleTrashDrop(originalFrom, onRemove);
                 } else if (!to) {
@@ -3462,16 +3289,12 @@ class EventService {
                 }
             };
 
-            // --- Attach listeners (mouse + touch) ---
+            // Attach listeners (mouse + touch)
             window.addEventListener('mouseup', onPointerUp, { once: true });
             document.addEventListener('mousemove', onPointerMove);
             img.addEventListener('mouseup', onPointerUp, { once: true });
-            // Touch events
             window.addEventListener('touchend', onPointerUp, { once: true });
             document.addEventListener('touchmove', onPointerMove, { passive: false });
-
-            // Per robustezza: se il drag parte da touch, blocca subito lo scroll
-            if (isTouch) addScrollLock();
         };
     }
 
@@ -3964,33 +3787,21 @@ class EventService {
      * Removes all existing event listeners
      */
     removeListeners() {
-        this.eventListeners.forEach((listeners, squareId) => {
-            listeners.forEach(({ element, type, handler }) => {
-                element.removeEventListener(type, handler);
-            });
-        });
-
-        this.eventListeners.clear();
+        this.listenerManager.removeAll();
     }
 
     /**
      * Removes all event listeners
      */
     removeAllListeners() {
-        this.eventListeners.forEach((listeners, squareId) => {
-            listeners.forEach(({ element, type, handler }) => {
-                element.removeEventListener(type, handler);
-            });
-        });
-
-        this.eventListeners.clear();
+        this.listenerManager.removeAll();
     }
 
     /**
      * Cleans up resources
      */
     destroy() {
-        this.removeAllListeners();
+        this.listenerManager.destroy();
         this.clicked = null;
         this.promoting = false;
         this.isAnimating = false;
@@ -3998,7 +3809,7 @@ class EventService {
 }
 
 /**
- * Service for managing chess moves and move validation
+ * MoveService - Handles chess move management and validation
  * @module services/MoveService
  * @since 2.0.0
  */
@@ -4006,13 +3817,13 @@ class EventService {
 
 /**
  * Service responsible for move management and validation
- * @class
+ * @class MoveService
  */
 class MoveService {
     /**
-     * Creates a new MoveService instance
-     * @param {ChessboardConfig} config - Board configuration
-     * @param {PositionService} positionService - Position service instance
+     * Create a new MoveService instance
+     * @param {Object} config - Board configuration
+     * @param {Object} positionService - Position service instance
      */
     constructor(config, positionService) {
         this.config = config;
@@ -4022,43 +3833,32 @@ class MoveService {
     }
 
     /**
-     * Checks if a piece on a square can move
+     * Check if a piece on a square can move
      * @param {Square} square - Square to check
      * @returns {boolean} True if piece can move
      */
     canMove(square) {
         if (!square.piece) return false;
-
         const { movableColors, onlyLegalMoves } = this.config;
-
         if (movableColors === 'none') return false;
         if (movableColors === 'w' && square.piece.color === 'b') return false;
         if (movableColors === 'b' && square.piece.color === 'w') return false;
-
         if (!onlyLegalMoves) return true;
-
-        // Check if position service and game are available
-        if (!this.positionService || !this.positionService.getGame()) {
-            return false;
-        }
-
+        if (!this.positionService || !this.positionService.getGame()) return false;
         const game = this.positionService.getGame();
         return square.piece.color === game.turn();
     }
 
     /**
-     * Converts various move formats to a Move instance
+     * Convert various move formats to a Move instance
      * @param {string|Move|Object} move - Move in various formats
      * @param {Object} squares - All board squares
      * @returns {Move} Move instance
      * @throws {MoveError} When move format is invalid
      */
     convertMove(move, squares) {
-        if (move instanceof Move$1) {
-            return move;
-        }
+        if (move instanceof Move$1) return move;
         if (typeof move === 'object' && move.from && move.to) {
-            // Se sono id, converto in oggetti; se sono già oggetti, li uso direttamente
             const fromSquare = typeof move.from === 'string' ? squares[move.from] : move.from;
             const toSquare = typeof move.to === 'string' ? squares[move.to] : move.to;
             if (!fromSquare || !toSquare) throw new MoveError(ERROR_MESSAGES.invalid_move_format, move.from, move.to);
@@ -4077,13 +3877,12 @@ class MoveService {
     }
 
     /**
-     * Checks if a move is legal
+     * Check if a move is legal
      * @param {Move} move - Move to check
      * @returns {boolean} True if move is legal
      */
     isLegalMove(move) {
         const legalMoves = this.getLegalMoves(move.from.id);
-
         return legalMoves.some(legalMove =>
             legalMove.to === move.to.id &&
             move.promotion === legalMove.promotion
@@ -4091,180 +3890,100 @@ class MoveService {
     }
 
     /**
-     * Gets all legal moves for a square or the entire position
+     * Get all legal moves for a square or the entire position
      * @param {string} [from] - Square to get moves from (optional)
      * @param {boolean} [verbose=true] - Whether to return verbose move objects
      * @returns {Array} Array of legal moves
      */
     getLegalMoves(from = null, verbose = true) {
-        // Check if position service and game are available
-        if (!this.positionService || !this.positionService.getGame()) {
-            return [];
-        }
-
+        if (!this.positionService || !this.positionService.getGame()) return [];
         const game = this.positionService.getGame();
-
         if (!game) return [];
-
         const options = { verbose };
-        if (from) {
-            options.square = from;
-        }
-
+        if (from) options.square = from;
         return game.moves(options);
     }
 
     /**
-     * Gets legal moves with caching for performance
+     * Get legal moves with caching for performance
      * @param {Square} square - Square to get moves from
      * @returns {Array} Array of legal moves
      */
     getCachedLegalMoves(square) {
-        // Check if position service and game are available
-        if (!this.positionService || !this.positionService.getGame()) {
-            return [];
-        }
-
+        if (!this.positionService || !this.positionService.getGame()) return [];
         const game = this.positionService.getGame();
         if (!game) return [];
-
         const cacheKey = `${square.id}-${game.fen()}`;
         let moves = this._movesCache.get(cacheKey);
-
         if (!moves) {
             moves = game.moves({ square: square.id, verbose: true });
             this._movesCache.set(cacheKey, moves);
-
-            // Clear cache after a short delay to prevent memory buildup
-            if (this._cacheTimeout) {
-                clearTimeout(this._cacheTimeout);
-            }
-
+            if (this._cacheTimeout) clearTimeout(this._cacheTimeout);
             this._cacheTimeout = setTimeout(() => {
                 this._movesCache.clear();
             }, 1000);
         }
-
         return moves;
     }
 
     /**
-     * Executes a move on the game
-     * @param {Move} move - Move to execute (deve essere oggetto Move)
+     * Execute a move on the game
+     * @param {Move} move - Move to execute (must be a Move object)
      * @returns {Object|null} Move result from chess.js or null if invalid
      */
     executeMove(move) {
-        if (!(move instanceof Move$1)) throw new Error('executeMove richiede un oggetto Move');
-        if (!this.positionService || !this.positionService.getGame()) {
-            return null;
-        }
+        if (!(move instanceof Move$1)) throw new Error('executeMove requires a Move object');
+        if (!this.positionService || !this.positionService.getGame()) return null;
         const game = this.positionService.getGame();
         if (!game) return null;
-        const moveOptions = {
-            from: move.from.id,
-            to: move.to.id
-        };
-        if (move.hasPromotion()) {
-            moveOptions.promotion = move.promotion;
-        }
+        const moveOptions = { from: move.from.id, to: move.to.id };
+        if (move.hasPromotion()) moveOptions.promotion = move.promotion;
         const result = game.move(moveOptions);
         return result;
     }
 
     /**
-     * Determina se una mossa richiede promozione
-     * @param {Move} move - Deve essere oggetto Move
+     * Determine if a move requires promotion
+     * @param {Move} move - Must be a Move object
      * @returns {boolean}
      */
     requiresPromotion(move) {
-        if (!(move instanceof Move$1)) throw new Error('requiresPromotion richiede un oggetto Move');
-        console.log('Checking if move requires promotion:', move.from.id, '->', move.to.id);
-
-        if (!this.config.onlyLegalMoves) {
-            console.log('Not in legal moves mode, no promotion required');
-            return false;
-        }
-
+        if (!(move instanceof Move$1)) throw new Error('requiresPromotion requires a Move object');
+        if (!this.config.onlyLegalMoves) return false;
         const game = this.positionService.getGame();
-        if (!game) {
-            console.log('No game instance available');
-            return false;
-        }
-
+        if (!game) return false;
         const piece = game.get(move.from.id);
-        if (!piece || piece.type !== 'p') {
-            console.log('Not a pawn move, no promotion required');
-            return false;
-        }
-
+        if (!piece || piece.type !== 'p') return false;
         const targetRank = move.to.row;
-        if (targetRank !== 1 && targetRank !== 8) {
-            console.log('Not reaching promotion rank, no promotion required');
-            return false;
-        }
-
-        console.log('Pawn reaching promotion rank, validating move...');
-
-        // Additional validation: check if the pawn can actually reach this square
-        if (!this._isPawnMoveValid(move.from, move.to, piece.color)) {
-            console.log('Pawn move not valid, no promotion required');
-            return false;
-        }
-
-        // First check if the move is legal without promotion
-        const simpleMoveObj = {
-            from: move.from.id,
-            to: move.to.id
-        };
-
+        if (targetRank !== 1 && targetRank !== 8) return false;
+        if (!this._isPawnMoveValid(move.from, move.to, piece.color)) return false;
+        // Try move without promotion
+        const simpleMoveObj = { from: move.from.id, to: move.to.id };
         try {
-            console.log('Testing move without promotion:', simpleMoveObj);
-            // Test if the move is legal without promotion first
             const testMove = game.move(simpleMoveObj);
             if (testMove) {
-                // Move was successful, but check if it was a promotion
                 const wasPromotion = testMove.promotion;
-
-                // Undo the test move
                 game.undo();
-
-                console.log('Move successful without promotion, was promotion:', wasPromotion !== undefined);
-
-                // If it was a promotion, return true
                 return wasPromotion !== undefined;
             }
         } catch (error) {
-            console.log('Move failed without promotion, trying with promotion:', error.message);
-
-            // If simple move fails, try with promotion
-            const promotionMoveObj = {
-                from: move.from.id,
-                to: move.to.id,
-                promotion: 'q' // test with queen
-            };
-
+            // Try with promotion
+            const promotionMoveObj = { from: move.from.id, to: move.to.id, promotion: 'q' };
             try {
-                console.log('Testing move with promotion:', promotionMoveObj);
                 const testMove = game.move(promotionMoveObj);
                 if (testMove) {
-                    // Undo the test move
                     game.undo();
-                    console.log('Move successful with promotion, promotion required');
                     return true;
                 }
             } catch (promotionError) {
-                console.log('Move failed even with promotion:', promotionError.message);
-                // Move is not legal even with promotion
                 return false;
             }
         }
-
-        console.log('Move validation complete, no promotion required');
         return false;
     }
 
     /**
-     * Validates if a pawn move is theoretically possible
+     * Validate if a pawn move is theoretically possible
      * @private
      * @param {Square} from - Source square
      * @param {Square} to - Target square
@@ -4276,48 +3995,21 @@ class MoveService {
         const toRank = to.row;
         const fromFile = from.col;
         const toFile = to.col;
-
-        console.log(`Validating pawn move: ${from.id} -> ${to.id} (${color})`);
-        console.log(`Ranks: ${fromRank} -> ${toRank}, Files: ${fromFile} -> ${toFile}`);
-
-        // Direction of pawn movement
         const direction = color === 'w' ? 1 : -1;
         const rankDiff = toRank - fromRank;
         const fileDiff = Math.abs(toFile - fromFile);
-
-        // Pawn can only move forward
-        if (rankDiff * direction <= 0) {
-            console.log('Invalid: Pawn cannot move backward or stay in place');
-            return false;
-        }
-
-        // Pawn can only move 1 rank at a time (except for double move from starting position)
-        if (Math.abs(rankDiff) > 2) {
-            console.log('Invalid: Pawn cannot move more than 2 ranks');
-            return false;
-        }
-
-        // If moving 2 ranks, must be from starting position
+        if (rankDiff * direction <= 0) return false;
+        if (Math.abs(rankDiff) > 2) return false;
         if (Math.abs(rankDiff) === 2) {
             const startingRank = color === 'w' ? 2 : 7;
-            if (fromRank !== startingRank) {
-                console.log(`Invalid: Pawn cannot move 2 ranks from rank ${fromRank}`);
-                return false;
-            }
-        }
-
-        // Pawn can only move to adjacent files (diagonal capture) or same file (forward move)
-        if (fileDiff > 1) {
-            console.log('Invalid: Pawn cannot move more than 1 file');
-            return false;
+            if (fromRank !== startingRank) return false;
         }
-
-        console.log('Pawn move validation passed');
+        if (fileDiff > 1) return false;
         return true;
     }
 
     /**
-     * Handles promotion UI setup
+     * Handle promotion UI setup
      * @param {Move} move - Move requiring promotion
      * @param {Object} squares - All board squares
      * @param {Function} onPromotionSelect - Callback when promotion piece is selected
@@ -4326,55 +4018,33 @@ class MoveService {
      */
     setupPromotion(move, squares, onPromotionSelect, onPromotionCancel) {
         if (!this.requiresPromotion(move)) return false;
-
-        // Check if position service and game are available
-        if (!this.positionService || !this.positionService.getGame()) {
-            return false;
-        }
-
+        if (!this.positionService || !this.positionService.getGame()) return false;
         const game = this.positionService.getGame();
         const piece = game.get(move.from.id);
         const targetSquare = move.to;
-
-        // Clear any existing promotion UI
         Object.values(squares).forEach(square => {
             square.removePromotion();
             square.removeCover();
         });
-
-        // Always show promotion choices in a column
         this._showPromotionInColumn(targetSquare, piece, squares, onPromotionSelect, onPromotionCancel);
-
         return true;
     }
 
     /**
-     * Shows promotion choices in a column
+     * Show promotion choices in a column
      * @private
      */
     _showPromotionInColumn(targetSquare, piece, squares, onPromotionSelect, onPromotionCancel) {
-        console.log('Setting up promotion for', targetSquare.id, 'piece color:', piece.color);
-
-        // Set up promotion choices starting from border row
         PROMOTION_PIECES.forEach((pieceType, index) => {
             const choiceSquare = this._findPromotionSquare(targetSquare, index, squares);
-
             if (choiceSquare) {
                 const pieceId = pieceType + piece.color;
                 const piecePath = this._getPiecePathForPromotion(pieceId);
-
-                console.log('Setting up promotion choice:', pieceType, 'on square:', choiceSquare.id);
-
                 choiceSquare.putPromotion(piecePath, () => {
-                    console.log('Promotion choice selected:', pieceType);
                     onPromotionSelect(pieceType);
                 });
-            } else {
-                console.log('Could not find square for promotion choice:', pieceType, 'index:', index);
             }
         });
-
-        // Set up cover squares (for cancellation)
         Object.values(squares).forEach(square => {
             if (!square.hasPromotion()) {
                 square.putCover(() => {
@@ -4382,181 +4052,119 @@ class MoveService {
                 });
             }
         });
-
         return true;
     }
 
     /**
-     * Finds the appropriate square for a promotion piece
+     * Find the appropriate square for a promotion piece
      * @private
      * @param {Square} targetSquare - Target square of the promotion move
-     * @param {number} distance - Distance from target square
+     * @param {number} index - Distance from target square
      * @param {Object} squares - All board squares
      * @returns {Square|null} Square for promotion piece or null
      */
     _findPromotionSquare(targetSquare, index, squares) {
         const col = targetSquare.col;
         const baseRow = targetSquare.row;
-
-        console.log('Looking for promotion square - target:', targetSquare.id, 'index:', index, 'col:', col, 'baseRow:', baseRow);
-
-        // Calculate row based on index and promotion direction
-        // Start from the border row (1 or 8) and go inward
         let row;
         if (baseRow === 8) {
-            // White promotion: start from row 8 and go down
             row = 8 - index;
         } else if (baseRow === 1) {
-            // Black promotion: start from row 1 and go up
             row = 1 + index;
         } else {
-            console.log('Invalid promotion row:', baseRow);
             return null;
         }
-
-        console.log('Calculated row:', row);
-
-        // Ensure row is within bounds
-        if (row < 1 || row > 8) {
-            console.log('Row out of bounds:', row);
-            return null;
-        }
-
-        // Find square by row/col
+        if (row < 1 || row > 8) return null;
         for (const square of Object.values(squares)) {
             if (square.col === col && square.row === row) {
-                console.log('Found promotion square:', square.id);
                 return square;
             }
         }
-
-        console.log('No square found for col:', col, 'row:', row);
         return null;
     }
 
     /**
-     * Gets piece path for promotion UI
+     * Get piece path for promotion UI
      * @private
      * @param {string} pieceId - Piece identifier
      * @returns {string} Path to piece asset
      */
     _getPiecePathForPromotion(pieceId) {
-        // This would typically use the PieceService
-        // For now, we'll use a simple implementation
         const { piecesPath } = this.config;
-
         if (typeof piecesPath === 'string') {
             return `${piecesPath}/${pieceId}.svg`;
         }
-
-        // Fallback for other path types
         return `assets/pieces/${pieceId}.svg`;
     }
 
     /**
-     * Parses a move string into a move object
+     * Parse a move string into a move object
      * @param {string} moveString - Move string (e.g., 'e2e4', 'e7e8q')
      * @returns {Object|null} Move object or null if invalid
      */
     parseMove(moveString) {
-        if (typeof moveString !== 'string' || moveString.length < 4 || moveString.length > 5) {
-            return null;
-        }
-
+        if (typeof moveString !== 'string' || moveString.length < 4 || moveString.length > 5) return null;
         const from = moveString.slice(0, 2);
         const to = moveString.slice(2, 4);
         const promotion = moveString.slice(4, 5);
-
-        // Basic validation
-        if (!/^[a-h][1-8]$/.test(from) || !/^[a-h][1-8]$/.test(to)) {
-            return null;
-        }
-
-        if (promotion && !['q', 'r', 'b', 'n'].includes(promotion.toLowerCase())) {
-            return null;
-        }
-
-        return {
-            from: from,
-            to: to,
-            promotion: promotion || null
-        };
+        if (!/^[a-h][1-8]$/.test(from) || !/^[a-h][1-8]$/.test(to)) return null;
+        if (promotion && !['q', 'r', 'b', 'n'].includes(promotion.toLowerCase())) return null;
+        return { from, to, promotion: promotion || null };
     }
 
     /**
-     * Checks if a move is a castle move
+     * Check if a move is a castle move
      * @param {Object} gameMove - Game move object from chess.js
      * @returns {boolean} True if move is castle
      */
     isCastle(gameMove) {
-        return gameMove && (gameMove.isKingsideCastle() || gameMove.isQueensideCastle());
+        return gameMove && (gameMove.isKingsideCastle && gameMove.isKingsideCastle() || gameMove.isQueensideCastle && gameMove.isQueensideCastle());
     }
 
     /**
-     * Gets the rook move for a castle move
+     * Get the rook move for a castle move
      * @param {Object} gameMove - Game move object from chess.js
      * @returns {Object|null} Rook move object or null if not castle
      */
     getCastleRookMove(gameMove) {
-        if (!this.isCastle(gameMove)) {
-            return null;
-        }
-
+        if (!this.isCastle(gameMove)) return null;
         const isKingSide = gameMove.isKingsideCastle();
         const isWhite = gameMove.color === 'w';
-
         if (isKingSide) {
-            // King side castle
-            if (isWhite) {
-                return { from: 'h1', to: 'f1' };
-            } else {
-                return { from: 'h8', to: 'f8' };
-            }
+            return isWhite ? { from: 'h1', to: 'f1' } : { from: 'h8', to: 'f8' };
         } else {
-            // Queen side castle
-            if (isWhite) {
-                return { from: 'a1', to: 'd1' };
-            } else {
-                return { from: 'a8', to: 'd8' };
-            }
+            return isWhite ? { from: 'a1', to: 'd1' } : { from: 'a8', to: 'd8' };
         }
     }
 
     /**
-     * Checks if a move is en passant
+     * Check if a move is en passant
      * @param {Object} gameMove - Game move object from chess.js
      * @returns {boolean} True if move is en passant
      */
     isEnPassant(gameMove) {
-        return gameMove && gameMove.isEnPassant();
+        return gameMove && gameMove.isEnPassant && gameMove.isEnPassant();
     }
 
     /**
-     * Gets the captured pawn square for en passant
+     * Get the captured pawn square for en passant
      * @param {Object} gameMove - Game move object from chess.js
      * @returns {string|null} Square of captured pawn or null if not en passant
      */
     getEnPassantCapturedSquare(gameMove) {
-        if (!this.isEnPassant(gameMove)) {
-            return null;
-        }
-
+        if (!this.isEnPassant(gameMove)) return null;
         const toSquare = gameMove.to;
         const rank = parseInt(toSquare[1]);
         const file = toSquare[0];
-
-        // The captured pawn is on the same file but different rank
         if (gameMove.color === 'w') {
-            // White captures black pawn one rank below
             return file + (rank - 1);
         } else {
-            // Black captures white pawn one rank above
             return file + (rank + 1);
         }
     }
 
     /**
-     * Clears the moves cache
+     * Clear the moves cache
      */
     clearCache() {
         this._movesCache.clear();
@@ -4567,7 +4175,7 @@ class MoveService {
     }
 
     /**
-     * Cleans up resources
+     * Clean up resources
      */
     destroy() {
         this.clearCache();
@@ -4576,7 +4184,7 @@ class MoveService {
 }
 
 /**
- * Service for managing chess pieces and their operations
+ * PieceService - Handles chess piece management and operations
  * @module services/PieceService
  * @since 2.0.0
  */
@@ -4584,11 +4192,11 @@ class MoveService {
 
 /**
  * Service responsible for piece management and operations
- * @class
+ * @class PieceService
  */
 class PieceService {
     /**
-     * Creates a new PieceService instance
+     * Create a new PieceService instance
      * @param {ChessboardConfig} config - Board configuration
      */
     constructor(config) {
@@ -4596,14 +4204,13 @@ class PieceService {
     }
 
     /**
-     * Gets the path to a piece asset
+     * Get the path to a piece asset
      * @param {string} piece - Piece identifier (e.g., 'wK', 'bP')
      * @returns {string} Path to piece asset
      * @throws {ValidationError} When piecesPath configuration is invalid
      */
     getPiecePath(piece) {
         const { piecesPath } = this.config;
-
         if (typeof piecesPath === 'string') {
             return `${piecesPath}/${piece}.svg`;
         } else if (typeof piecesPath === 'object' && piecesPath !== null) {
@@ -4616,7 +4223,7 @@ class PieceService {
     }
 
     /**
-     * Converts various piece formats to a Piece instance
+     * Convert various piece formats to a Piece instance
      * @param {string|Piece} piece - Piece in various formats
      * @returns {Piece} Piece instance
      * @throws {PieceError} When piece format is invalid
@@ -4625,54 +4232,41 @@ class PieceService {
         if (piece instanceof Piece) {
             return piece;
         }
-
         if (typeof piece === 'string' && piece.length === 2) {
             const [first, second] = piece.split('');
             let type, color;
-
-            // Check format: [type][color] (e.g., 'pw')
             if (PIECE_TYPES.includes(first.toLowerCase()) && PIECE_COLORS.includes(second)) {
                 type = first.toLowerCase();
                 color = second;
-            }
-            // Check format: [color][type] (e.g., 'wP')
-            else if (PIECE_COLORS.includes(first) && PIECE_TYPES.includes(second.toLowerCase())) {
+            } else if (PIECE_COLORS.includes(first) && PIECE_TYPES.includes(second.toLowerCase())) {
                 color = first;
                 type = second.toLowerCase();
             } else {
                 throw new PieceError(ERROR_MESSAGES.invalid_piece + piece, piece);
             }
-
             const piecePath = this.getPiecePath(type + color);
             return new Piece(color, type, piecePath);
         }
-
         throw new PieceError(ERROR_MESSAGES.invalid_piece + piece, piece);
     }
 
     /**
-     * Adds a piece to a square with optional fade-in animation
-     * @param {Square} square - Target square (oggetto)
-     * @param {Piece} piece - Piece to add (oggetto)
+     * Add a piece to a square with optional fade-in animation
+     * @param {Square} square - Target square
+     * @param {Piece} piece - Piece to add
      * @param {boolean} [fade=true] - Whether to fade in the piece
      * @param {Function} dragFunction - Function to handle drag events
      * @param {Function} [callback] - Callback when animation completes
      */
     addPieceOnSquare(square, piece, fade = true, dragFunction, callback) {
-        if (!square || !piece) throw new Error('addPieceOnSquare richiede oggetti Square e Piece');
-        console.debug(`[PieceService] addPieceOnSquare: ${piece.id} to ${square.id}`);
+        if (!square || !piece) throw new Error('addPieceOnSquare requires Square and Piece objects');
         square.putPiece(piece);
-
-        // Imposta sempre il drag (touch e mouse)
         if (dragFunction) {
             piece.setDrag(dragFunction(square, piece));
         }
-        // Forza il drag touch se manca (debug/robustezza)
         if (!piece.element.ontouchstart) {
             piece.element.ontouchstart = dragFunction ? dragFunction(square, piece) : () => { };
-            console.debug(`[PieceService] Forzato ontouchstart su ${piece.id}`);
         }
-
         if (fade && this.config.fadeTime > 0) {
             piece.fadeIn(
                 this.config.fadeTime,
@@ -4683,28 +4277,24 @@ class PieceService {
         } else {
             if (callback) callback();
         }
-
         piece.visible();
     }
 
     /**
-     * Rimuove un pezzo da una casella
-     * @param {Square} square - Oggetto Square
+     * Remove a piece from a square
+     * @param {Square} square - Square object
      * @param {boolean} [fade=true]
      * @param {Function} [callback]
-     * @returns {Piece} Il pezzo rimosso
+     * @returns {Piece} The removed piece
      */
     removePieceFromSquare(square, fade = true, callback) {
-        if (!square) throw new Error('removePieceFromSquare richiede oggetto Square');
-        console.debug(`[PieceService] removePieceFromSquare: ${square.id}`);
+        if (!square) throw new Error('removePieceFromSquare requires a Square object');
         square.check();
-
         const piece = square.piece;
         if (!piece) {
             if (callback) callback();
             throw new PieceError(ERROR_MESSAGES.square_no_piece, null, square.getId());
         }
-
         if (fade && this.config.fadeTime > 0) {
             piece.fadeOut(
                 this.config.fadeTime,
@@ -4715,26 +4305,22 @@ class PieceService {
         } else {
             if (callback) callback();
         }
-
         square.removePiece();
         return piece;
     }
 
     /**
-     * Moves a piece to a new position with animation
+     * Move a piece to a new position with animation
      * @param {Piece} piece - Piece to move
      * @param {Square} targetSquare - Target square
      * @param {number} duration - Animation duration
      * @param {Function} [callback] - Callback function when animation completes
      */
     movePiece(piece, targetSquare, duration, callback) {
-        console.debug(`[PieceService] movePiece: ${piece.id} to ${targetSquare.id}`);
         if (!piece || !piece.element) {
-            console.warn(`[PieceService] movePiece: piece or element is null, skipping animation`);
             if (callback) callback();
             return;
         }
-
         piece.translate(
             targetSquare,
             duration,
@@ -4745,7 +4331,7 @@ class PieceService {
     }
 
     /**
-     * Handles piece translation with optional capture
+     * Handle piece translation with optional capture
      * @param {Move} move - Move object containing from/to squares and piece
      * @param {boolean} removeTarget - Whether to remove piece from target square
      * @param {boolean} animate - Whether to animate the move
@@ -4753,54 +4339,37 @@ class PieceService {
      * @param {Function} [callback] - Callback function when complete
      */
     translatePiece(move, removeTarget, animate, dragFunction = null, callback = null) {
-        console.debug(`[PieceService] translatePiece: ${move.piece.id} from ${move.from.id} to ${move.to.id}`);
         if (!move.piece) {
-            console.warn('PieceService.translatePiece: move.piece is null, skipping translation');
             if (callback) callback();
             return;
         }
-
         if (removeTarget) {
-            // Deselect the captured piece before removing it
             move.to.deselect();
             this.removePieceFromSquare(move.to, false);
         }
-
         const changeSquareCallback = () => {
-            // Check if piece still exists and is on the source square
             if (move.from.piece === move.piece) {
-                move.from.removePiece(true); // Preserve the piece when moving
+                move.from.removePiece(true);
             }
-
-            // Only put piece if destination square doesn't already have it
             if (move.to.piece !== move.piece) {
                 move.to.putPiece(move.piece);
-
-                // Re-attach drag handler if provided
                 if (dragFunction && this.config.draggable && move.piece.element) {
                     move.piece.setDrag(dragFunction(move.to, move.piece));
                 }
             }
-
             if (callback) callback();
         };
-
-        // Check if piece is currently being dragged
         const isDragging = move.piece.element && move.piece.element.classList.contains('dragging');
-
         if (isDragging) {
-            // If piece is being dragged, don't animate - just move it immediately
-            // The piece is already visually in the correct position from the drag
             changeSquareCallback();
         } else {
-            // Normal animation
             const duration = animate ? this.config.moveTime : 0;
             this.movePiece(move.piece, move.to, duration, changeSquareCallback);
         }
     }
 
     /**
-     * Snaps a piece back to its original position
+     * Snap a piece back to its original position
      * @param {Square} square - Square containing the piece
      * @param {boolean} [animate=true] - Whether to animate the snapback
      */
@@ -4810,7 +4379,6 @@ class PieceService {
         }
         const piece = square.piece;
         const duration = animate ? this.config.snapbackTime : 0;
-        console.debug(`[PieceService] snapbackPiece: ${piece.id} on ${square.id}`);
         piece.translate(
             square,
             duration,
@@ -4820,7 +4388,7 @@ class PieceService {
     }
 
     /**
-     * Centers a piece in its square with animation (after successful drop)
+     * Center a piece in its square with animation (after successful drop)
      * @param {Square} square - Square containing the piece to center
      * @param {boolean} animate - Whether to animate the centering
      */
@@ -4830,14 +4398,12 @@ class PieceService {
         }
         const piece = square.piece;
         const duration = animate ? this.config.dropCenterTime : 0;
-        console.debug(`[PieceService] centerPiece: ${piece.id} on ${square.id}`);
         piece.translate(
             square,
             duration,
             this._getTransitionTimingFunction(),
             this.config.dropCenterAnimation,
             () => {
-                // After animation, reset all drag-related styles
                 if (!piece.element) return;
                 piece.element.style.position = '';
                 piece.element.style.left = '';
@@ -4849,14 +4415,13 @@ class PieceService {
     }
 
     /**
-     * Gets the transition timing function for animations
+     * Get the transition timing function for animations
      * @private
      * @returns {Function} Timing function
      */
     _getTransitionTimingFunction() {
         return (elapsed, duration, type = 'ease') => {
             const x = elapsed / duration;
-
             switch (type) {
                 case 'linear':
                     return x;
@@ -4875,7 +4440,7 @@ class PieceService {
     }
 
     /**
-     * Cleans up resources
+     * Clean up resources
      */
     destroy() {
         // Cleanup any cached pieces or references
@@ -6866,7 +6431,7 @@ class Chess {
 }
 
 /**
- * Service for managing chess positions and FEN conversion
+ * PositionService - Handles chess position management and FEN conversion
  * @module services/PositionService
  * @since 2.0.0
  */
@@ -6874,11 +6439,11 @@ class Chess {
 
 /**
  * Service responsible for position management and FEN operations
- * @class
+ * @class PositionService
  */
 class PositionService {
     /**
-     * Creates a new PositionService instance
+     * Create a new PositionService instance
      * @param {ChessboardConfig} config - Board configuration
      */
     constructor(config) {
@@ -6887,7 +6452,7 @@ class PositionService {
     }
 
     /**
-     * Converts various position formats to FEN string
+     * Convert various position formats to FEN string
      * @param {string|Object} position - Position in various formats
      * @returns {string} FEN string representation
      * @throws {ValidationError} When position format is invalid
@@ -6903,7 +6468,7 @@ class PositionService {
     }
 
     /**
-     * Converts string position to FEN
+     * Convert string position to FEN
      * @private
      * @param {string} position - String position
      * @returns {string} FEN string
@@ -6912,35 +6477,29 @@ class PositionService {
         if (position === 'start') {
             return DEFAULT_STARTING_POSITION;
         }
-        
         if (this.validateFen(position)) {
             return position;
         }
-        
         if (STANDARD_POSITIONS[position]) {
             return STANDARD_POSITIONS[position];
         }
-        
         throw new ValidationError(ERROR_MESSAGES.invalid_position + position, 'position', position);
     }
 
     /**
-     * Converts object position to FEN
+     * Convert object position to FEN
      * @private
      * @param {Object} position - Object with square->piece mapping
      * @returns {string} FEN string
      */
     _convertObjectPosition(position) {
         const parts = [];
-        
         for (let row = 0; row < 8; row++) {
             const rowParts = [];
             let empty = 0;
-            
             for (let col = 0; col < 8; col++) {
                 const square = this._getSquareID(row, col);
                 const piece = position[square];
-                
                 if (piece) {
                     if (empty > 0) {
                         rowParts.push(empty);
@@ -6953,25 +6512,21 @@ class PositionService {
                     empty++;
                 }
             }
-            
             if (empty > 0) {
                 rowParts.push(empty);
             }
-            
             parts.push(rowParts.join(''));
         }
-        
         return parts.join('/') + ' w KQkq - 0 1';
     }
 
     /**
-     * Sets up the game with the given position
+     * Set up the game with the given position
      * @param {string|Object} position - Position to set
      * @param {Object} [options] - Additional options for game setup
      */
     setGame(position, options = {}) {
         const fen = this.convertFen(position);
-        
         if (this.game) {
             this.game.load(fen, options);
         } else {
@@ -6980,7 +6535,7 @@ class PositionService {
     }
 
     /**
-     * Gets the current game instance
+     * Get the current game instance
      * @returns {Chess} Current chess.js game instance
      */
     getGame() {
@@ -6988,7 +6543,7 @@ class PositionService {
     }
 
     /**
-     * Validates a FEN string
+     * Validate a FEN string
      * @param {string} fen - FEN string to validate
      * @returns {boolean} True if valid, false otherwise
      */
@@ -6997,7 +6552,7 @@ class PositionService {
     }
 
     /**
-     * Gets piece information for a specific square
+     * Get piece information for a specific square
      * @param {string} squareId - Square identifier
      * @returns {string|null} Piece ID or null if no piece
      */
@@ -7008,7 +6563,7 @@ class PositionService {
     }
 
     /**
-     * Checks if a specific piece is on a specific square
+     * Check if a specific piece is on a specific square
      * @param {string} piece - Piece ID to check
      * @param {string} square - Square to check
      * @returns {boolean} True if piece is on square
@@ -7018,7 +6573,7 @@ class PositionService {
     }
 
     /**
-     * Converts board coordinates to square ID
+     * Convert board coordinates to square ID
      * @private
      * @param {number} row - Row index (0-7)
      * @param {number} col - Column index (0-7)
@@ -7027,7 +6582,6 @@ class PositionService {
     _getSquareID(row, col) {
         row = parseInt(row);
         col = parseInt(col);
-        
         if (this.config.orientation === 'w') {
             row = 8 - row;
             col = col + 1;
@@ -7035,13 +6589,12 @@ class PositionService {
             row = row + 1;
             col = 8 - col;
         }
-        
         const letter = BOARD_LETTERS[col - 1];
         return letter + row;
     }
 
     /**
-     * Changes the turn in a FEN string
+     * Change the turn in a FEN string
      * @param {string} fen - Original FEN string
      * @param {string} color - New turn color ('w' or 'b')
      * @returns {string} Modified FEN string
@@ -7053,35 +6606,33 @@ class PositionService {
     }
 
     /**
-     * Gets the current position as an object
+     * Get the current position as an object
      * @returns {Object} Position object with piece placements
      */
     getPosition() {
         const position = {};
         const game = this.getGame();
-        
-        // Convert chess.js board to position object
-        const squares = ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1', 'h1',
-                        'a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2', 'h2',
-                        'a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', 'h3',
-                        'a4', 'b4', 'c4', 'd4', 'e4', 'f4', 'g4', 'h4',
-                        'a5', 'b5', 'c5', 'd5', 'e5', 'f5', 'g5', 'h5',
-                        'a6', 'b6', 'c6', 'd6', 'e6', 'f6', 'g6', 'h6',
-                        'a7', 'b7', 'c7', 'd7', 'e7', 'f7', 'g7', 'h7',
-                        'a8', 'b8', 'c8', 'd8', 'e8', 'f8', 'g8', 'h8'];
-        
+        const squares = [
+            'a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1', 'h1',
+            'a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2', 'h2',
+            'a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', 'h3',
+            'a4', 'b4', 'c4', 'd4', 'e4', 'f4', 'g4', 'h4',
+            'a5', 'b5', 'c5', 'd5', 'e5', 'f5', 'g5', 'h5',
+            'a6', 'b6', 'c6', 'd6', 'e6', 'f6', 'g6', 'h6',
+            'a7', 'b7', 'c7', 'd7', 'e7', 'f7', 'g7', 'h7',
+            'a8', 'b8', 'c8', 'd8', 'e8', 'f8', 'g8', 'h8'
+        ];
         for (const square of squares) {
             const piece = game.get(square);
             if (piece) {
                 position[square] = piece.type + piece.color;
             }
         }
-        
         return position;
     }
 
     /**
-     * Toggles the turn in a FEN string
+     * Toggle the turn in a FEN string
      * @param {string} fen - Original FEN string
      * @returns {string} Modified FEN string
      */
@@ -7092,7 +6643,7 @@ class PositionService {
     }
 
     /**
-     * Cleans up resources
+     * Clean up resources
      */
     destroy() {
         this.game = null;
@@ -7100,7 +6651,8 @@ class PositionService {
 }
 
 /**
- * Main Chessboard class - Orchestrates all services and components
+ * Chessboard - Main class orchestrating all services and components
+ * Implements the Facade pattern for the chessboard API
  * @module core/Chessboard
  * @since 2.0.0
  */
@@ -7108,12 +6660,11 @@ class PositionService {
 
 /**
  * Main Chessboard class responsible for coordinating all services
- * Implements the Facade pattern to provide a unified interface
- * @class
+ * @class Chessboard
  */
-class Chessboard {
+let Chessboard$1 = class Chessboard {
     /**
-     * Creates a new Chessboard instance
+     * Create a new Chessboard instance
      * @param {Object} config - Configuration object
      * @throws {ConfigurationError} If configuration is invalid
      */
@@ -7136,6 +6687,8 @@ class Chessboard {
         } catch (error) {
             this._handleConstructorError(error);
         }
+        this._undoneMoves = [];
+        this._updateBoardPieces(true, true); // Forza popolamento DOM subito
     }
 
     /**
@@ -7179,6 +6732,31 @@ class Chessboard {
         }
     }
 
+    /**
+     * Cleans up any partially initialized resources (safe to call multiple times)
+     * @private
+     */
+    _cleanup() {
+        // Remove event listeners if present
+        if (this.eventService && typeof this.eventService.removeListeners === 'function') {
+            this.eventService.removeListeners();
+        }
+        // Clear timeouts
+        if (this._updateTimeout) {
+            clearTimeout(this._updateTimeout);
+            this._updateTimeout = null;
+        }
+        // Null all services
+        this.validationService = null;
+        this.coordinateService = null;
+        this.positionService = null;
+        this.boardService = null;
+        this.pieceService = null;
+        this.animationService = null;
+        this.moveService = null;
+        this.eventService = null;
+    }
+
     /**
      * Initializes all services
      * @private
@@ -7247,8 +6825,23 @@ class Chessboard {
     /**
      * Builds the board DOM structure
      * @private
+     * Best practice: always remove squares (destroy JS/DOM) before clearing the board container.
      */
     _buildBoard() {
+        console.log('CHIAMATO: _buildBoard');
+        if (this._isUndoRedo) {
+            console.log('SKIP _buildBoard per undo/redo');
+            return;
+        }
+        // Forza la pulizia completa del contenitore board (DOM)
+        const boardContainer = document.getElementById(this.config.id_div);
+        if (boardContainer) boardContainer.innerHTML = '';
+        // Force remove all pieces from all squares (no animation, best practice)
+        if (this.boardService && this.boardService.squares) {
+            Object.values(this.boardService.squares).forEach(sq => sq && sq.forceRemoveAllPieces && sq.forceRemoveAllPieces());
+        }
+        if (this.boardService && this.boardService.removeSquares) this.boardService.removeSquares();
+        if (this.boardService && this.boardService.removeBoard) this.boardService.removeBoard();
         this.boardService.buildBoard();
     }
 
@@ -7257,6 +6850,14 @@ class Chessboard {
      * @private
      */
     _buildSquares() {
+        console.log('CHIAMATO: _buildSquares');
+        if (this._isUndoRedo) {
+            console.log('SKIP _buildSquares per undo/redo');
+            return;
+        }
+        if (this.boardService && this.boardService.removeSquares) {
+            this.boardService.removeSquares();
+        }
         this.boardService.buildSquares((row, col) => {
             return this.coordinateService.realCoord(row, col);
         });
@@ -7461,7 +7062,7 @@ class Chessboard {
                 const capturedPiece = move.to.piece;
 
                 // For castle moves in simultaneous mode, we need to coordinate both animations
-                if (isCastleMove && this.config.animationStyle === 'simultaneous') {
+                if (isCastleMove) {
                     // Start king animation
                     this.pieceService.translatePiece(
                         move,
@@ -7626,6 +7227,7 @@ class Chessboard {
      * @param {boolean} [isPositionLoad=false] - Whether this is a position load
      */
     _updateBoardPieces(animation = false, isPositionLoad = false) {
+        console.log('CHIAMATO: _updateBoardPieces', { animation, isPositionLoad, isUndoRedo: this._isUndoRedo });
         // Check if services are available
         if (!this.positionService || !this.moveService || !this.eventService) {
             console.log('Cannot update board pieces - services not available');
@@ -7685,112 +7287,125 @@ class Chessboard {
     }
 
     /**
-     * Performs the actual board update
+     * Aggiorna i pezzi sulla scacchiera con animazione e delay configurabile (greedy matching)
      * @private
-     * @param {boolean} [animation=false] - Whether to animate
-     * @param {boolean} [isPositionLoad=false] - Whether this is a position load (affects delay)
+     * @param {boolean} [animation=false] - Se animare
+     * @param {boolean} [isPositionLoad=false] - Se è un caricamento posizione (delay 0)
      */
     _doUpdateBoardPieces(animation = false, isPositionLoad = false) {
-        // Skip update if we're in the middle of a promotion
-        if (this._isPromoting) {
-            console.log('Skipping board update during promotion');
-            return;
-        }
-
-        // Check if services are available
-        if (!this.positionService || !this.positionService.getGame()) {
-            console.log('Cannot update board pieces - position service not available');
-            return;
-        }
-
+        if (this._isDragging) return;
+        if (this._isPromoting) return;
+        if (!this.positionService || !this.positionService.getGame()) return;
         const squares = this.boardService.getAllSquares();
         const gameStateBefore = this.positionService.getGame().fen();
-
-        console.log('_doUpdateBoardPieces - current FEN:', gameStateBefore);
-        console.log('_doUpdateBoardPieces - animation:', animation, 'style:', this.config.animationStyle, 'isPositionLoad:', isPositionLoad);
-
-        // Determine which animation style to use
-        const useSimultaneous = this.config.animationStyle === 'simultaneous';
-        console.log('_doUpdateBoardPieces - useSimultaneous:', useSimultaneous);
-
-        if (useSimultaneous) {
-            console.log('Using simultaneous animation');
-            this._doSimultaneousUpdate(squares, gameStateBefore, isPositionLoad);
-        } else {
-            console.log('Using sequential animation');
-            this._doSequentialUpdate(squares, gameStateBefore, animation);
+        if (/^8\/8\/8\/8\/8\/8\/8\/8/.test(gameStateBefore)) {
+            const boardContainer = document.getElementById(this.config.id_div);
+            if (boardContainer) {
+                const pieceElements = boardContainer.querySelectorAll('.piece');
+                pieceElements.forEach(element => element.remove());
+            }
+            Object.values(squares).forEach(sq => { if (sq && sq.piece) sq.piece = null; });
+            this._clearVisualState();
+            this._addListeners();
+            if (this.config.onChange) this.config.onChange(gameStateBefore);
+            return;
         }
-    }
 
-    /**
-     * Performs sequential piece updates (original behavior)
-     * @private
-     * @param {Object} squares - All squares
-     * @param {string} gameStateBefore - Game state before update
-     * @param {boolean} animation - Whether to animate
-     */
-    _doSequentialUpdate(squares, gameStateBefore, animation) {
-        // Update each square sequentially
+        // --- Matching greedy tra attuale e atteso ---
+        const currentMap = {};
+        const expectedMap = {};
         Object.values(squares).forEach(square => {
-            const expectedPieceId = this.positionService.getGamePieceId(square.id);
             const currentPiece = square.piece;
-            const currentPieceId = currentPiece ? currentPiece.getId() : null;
-
-            // Log only for squares that are changing
-            if (currentPieceId !== expectedPieceId) {
-                console.log(`_doSequentialUpdate - ${square.id}: ${currentPieceId} -> ${expectedPieceId}`);
-
-                // Check if we already have the correct piece (from promotion)
-                if (currentPiece && currentPiece.getId() === expectedPieceId) {
-                    console.log(`Piece ${expectedPieceId} already correctly placed on ${square.id}`);
-                } else {
-                    // Remove current piece if exists
-                    if (currentPiece) {
-                        this.pieceService.removePieceFromSquare(square, animation);
-                    }
+            const expectedPieceId = this.positionService.getGamePieceId(square.id);
+            if (currentPiece) {
+                const key = (currentPiece.color + currentPiece.type).toLowerCase();
+                if (!currentMap[key]) currentMap[key] = [];
+                currentMap[key].push({ square, id: square.id, piece: currentPiece });
+            }
+            if (expectedPieceId) {
+                const key = expectedPieceId.toLowerCase();
+                if (!expectedMap[key]) expectedMap[key] = [];
+                expectedMap[key].push({ square, id: square.id });
+            }
+        });
+        const animationDelay = isPositionLoad ? 0 : this.config.simultaneousAnimationDelay || 0;
+        let totalAnimations = 0;
+        let animationsCompleted = 0;
 
-                    // Add new piece if needed
-                    if (expectedPieceId) {
-                        const newPiece = this.pieceService.convertPiece(expectedPieceId);
-                        this.pieceService.addPieceOnSquare(
-                            square,
-                            newPiece,
-                            animation,
-                            this._createDragFunction.bind(this)
-                        );
+        // 1. Matching greedy: trova i movimenti
+        const moves = [];
+        const fromMatched = {};
+        const toMatched = {};
+        const unchanged = [];
+        Object.keys(expectedMap).forEach(key => {
+            const fromList = (currentMap[key] || []).slice();
+            const toList = expectedMap[key].slice();
+            const localFromMatched = new Array(fromList.length).fill(false);
+            const localToMatched = new Array(toList.length).fill(false);
+            // Matrice delle distanze
+            const distances = [];
+            for (let i = 0; i < fromList.length; i++) {
+                distances[i] = [];
+                for (let j = 0; j < toList.length; j++) {
+                    distances[i][j] = Math.abs(fromList[i].square.row - toList[j].square.row) +
+                        Math.abs(fromList[i].square.col - toList[j].square.col);
+                }
+            }
+            while (true) {
+                let minDist = Infinity, minI = -1, minJ = -1;
+                for (let i = 0; i < fromList.length; i++) {
+                    if (localFromMatched[i]) continue;
+                    for (let j = 0; j < toList.length; j++) {
+                        if (localToMatched[j]) continue;
+                        if (distances[i][j] < minDist) {
+                            minDist = distances[i][j];
+                            minI = i;
+                            minJ = j;
+                        }
                     }
                 }
+                if (minI === -1 || minJ === -1) break;
+                // Se la posizione è la stessa E il Piece è lo stesso oggetto, non fare nulla (pezzo unchanged)
+                if (fromList[minI].square === toList[minJ].square && squares[toList[minJ].square.id].piece === fromList[minI].piece) {
+                    unchanged.push({ square: fromList[minI].square, piece: fromList[minI].piece });
+                    localFromMatched[minI] = true;
+                    localToMatched[minJ] = true;
+                    fromMatched[fromList[minI].square.id] = true;
+                    toMatched[toList[minJ].square.id] = true;
+                    continue;
+                }
+                // Altrimenti, sposta il pezzo
+                moves.push({ from: fromList[minI].square, to: toList[minJ].square, piece: fromList[minI].piece });
+                localFromMatched[minI] = true;
+                localToMatched[minJ] = true;
+                fromMatched[fromList[minI].square.id] = true;
+                toMatched[toList[minJ].square.id] = true;
             }
         });
 
-        // Re-add listeners after updating pieces to ensure hover events work correctly
-        this._addListeners();
-
-        // Trigger change event if position changed
-        const gameStateAfter = this.positionService.getGame().fen();
-        if (gameStateBefore !== gameStateAfter) {
-            this.config.onChange(gameStateAfter);
-        }
-    }
+        // 2. Rimozione: pezzi presenti solo in attuale (non matched)
+        const removes = [];
+        Object.keys(currentMap).forEach(key => {
+            currentMap[key].forEach(({ square, piece }) => {
+                if (!fromMatched[square.id]) {
+                    removes.push({ square, piece });
+                }
+            });
+        });
 
-    /**
-     * Performs simultaneous piece updates
-     * @private
-     * @param {Object} squares - All squares
-     * @param {string} gameStateBefore - Game state before update
-     * @param {boolean} [isPositionLoad=false] - Whether this is a position load
-     */
-    _doSimultaneousUpdate(squares, gameStateBefore, isPositionLoad = false) {
-        console.log('_doSimultaneousUpdate - Starting simultaneous update');
-
-        // Analyze what changes need to be made
-        const changeAnalysis = this._analyzePositionChanges(squares);
+        // 3. Aggiunta: pezzi presenti solo in atteso (non matched)
+        const adds = [];
+        Object.keys(expectedMap).forEach(key => {
+            expectedMap[key].forEach(({ square, id }) => {
+                if (!toMatched[square.id]) {
+                    adds.push({ square, pieceId: key });
+                }
+            });
+        });
 
-        if (changeAnalysis.totalChanges === 0) {
-            console.log('_doSimultaneousUpdate - No changes needed, returning');
+        totalAnimations = moves.length + removes.length + adds.length;
+        if (totalAnimations === 0) {
             this._addListeners();
-
-            // Trigger change event if position changed
             const gameStateAfter = this.positionService.getGame().fen();
             if (gameStateBefore !== gameStateAfter) {
                 this.config.onChange(gameStateAfter);
@@ -7798,10 +7413,64 @@ class Chessboard {
             return;
         }
 
-        console.log('_doSimultaneousUpdate - Change analysis:', changeAnalysis);
+        // Debug: logga i pezzi unchanged
+        if (unchanged.length > 0) {
+            console.debug('[Chessboard] Unchanged pieces:', unchanged.map(u => u.piece.id + '@' + u.square.id));
+        }
 
-        // Execute all changes simultaneously
-        this._executeSimultaneousChanges(changeAnalysis, gameStateBefore, isPositionLoad);
+        const onAnimationComplete = () => {
+            animationsCompleted++;
+            if (animationsCompleted === totalAnimations) {
+                // Pulizia finale robusta: rimuovi tutti i pezzi orfani dal DOM e dal riferimento JS
+                Object.values(this.boardService.getAllSquares()).forEach(square => {
+                    const expectedPieceId = this.positionService.getGamePieceId(square.id);
+                    if (!expectedPieceId && typeof square.forceRemoveAllPieces === 'function') {
+                        square.forceRemoveAllPieces();
+                    }
+                });
+                this._addListeners();
+                const gameStateAfter = this.positionService.getGame().fen();
+                if (gameStateBefore !== gameStateAfter) {
+                    this.config.onChange(gameStateAfter);
+                }
+            }
+        };
+
+        // 4. Esegui tutte le animazioni con delay
+        let idx = 0;
+        moves.forEach(move => {
+            setTimeout(() => {
+                this.pieceService.translatePiece(
+                    move,
+                    false,
+                    animation,
+                    this._createDragFunction.bind(this),
+                    onAnimationComplete
+                );
+            }, idx++ * animationDelay);
+        });
+        removes.forEach(op => {
+            setTimeout(() => {
+                if (typeof op.square.forceRemoveAllPieces === 'function') {
+                    op.square.forceRemoveAllPieces();
+                    onAnimationComplete();
+                } else {
+                    this.pieceService.removePieceFromSquare(op.square, animation, onAnimationComplete);
+                }
+            }, idx++ * animationDelay);
+        });
+        adds.forEach(op => {
+            setTimeout(() => {
+                const newPiece = this.pieceService.convertPiece(op.pieceId);
+                this.pieceService.addPieceOnSquare(
+                    op.square,
+                    newPiece,
+                    animation,
+                    this._createDragFunction.bind(this),
+                    onAnimationComplete
+                );
+            }, idx++ * animationDelay);
+        });
     }
 
     /**
@@ -8127,99 +7796,418 @@ class Chessboard {
     }
 
     // -------------------
-    // Public API Methods
+    // Public API Methods (Refactored)
     // -------------------
 
+    // --- POSITION & STATE ---
     /**
-     * Gets the current position as FEN
-     * @returns {string} FEN string
+     * Get the current position as FEN
+     * @returns {string}
      */
-    fen() {
-        return this.positionService.getGame().fen();
+    getPosition() { return this.fen(); }
+    /**
+     * Set the board position (FEN or object)
+     * @param {string|Object} position
+     * @param {Object} [opts]
+     * @param {boolean} [opts.animate=true]
+     * @returns {boolean}
+     */
+    setPosition(position, opts = {}) {
+        const animate = opts.animate !== undefined ? opts.animate : true;
+        // Remove highlights and selections
+        if (this.boardService && this.boardService.applyToAllSquares) {
+            this.boardService.applyToAllSquares('removeHint');
+            this.boardService.applyToAllSquares('deselect');
+            this.boardService.applyToAllSquares('unmoved');
+        }
+        if (this.positionService && this.positionService.setGame) {
+            this.positionService.setGame(position);
+        }
+        if (this._updateBoardPieces) {
+            this._updateBoardPieces(animate, true);
+        }
+        // Forza la sincronizzazione dopo setPosition
+        this._updateBoardPieces(true, false);
+        return true;
+    }
+    /**
+     * Reset the board to the starting position
+     * @param {Object} [opts]
+     * @param {boolean} [opts.animate=true]
+     * @returns {boolean}
+     */
+    reset(opts = {}) {
+        const animate = opts.animate !== undefined ? opts.animate : true;
+        // Use the default starting position from config or fallback
+        const startPosition = this.config && this.config.position ? this.config.position : 'start';
+        this._updateBoardPieces(animate);
+        const result = this.setPosition(startPosition, { animate });
+        // Forza la sincronizzazione dopo reset
+        this._updateBoardPieces(true, false);
+        return result;
+    }
+    /**
+     * Clear the board
+     * @param {Object} [opts]
+     * @param {boolean} [opts.animate=true]
+     * @returns {boolean}
+     */
+    clear(opts = {}) {
+        const animate = opts.animate !== undefined ? opts.animate : true;
+        if (!this.positionService || !this.positionService.getGame()) {
+            return false;
+        }
+        if (this._clearVisualState) this._clearVisualState();
+        this.positionService.getGame().clear();
+        // Forza la rimozione di tutti i pezzi dal DOM
+        if (this.boardService && this.boardService.squares) {
+            Object.values(this.boardService.squares).forEach(sq => {
+                if (sq && sq.piece) sq.piece = null;
+            });
+        }
+        if (this._updateBoardPieces) {
+            this._updateBoardPieces(animate, true);
+        }
+        // Forza la sincronizzazione dopo clear
+        this._updateBoardPieces(true, false);
+        return true;
     }
 
+    // --- MOVE MANAGEMENT ---
     /**
-     * Gets current turn
-     * @returns {string} 'w' or 'b'
+     * Undo last move
+     * @param {Object} [opts]
+     * @param {boolean} [opts.animate=true]
+     * @returns {boolean}
      */
-    turn() {
-        return this.positionService.getGame().turn();
+    undoMove(opts = {}) {
+        const undone = this.positionService.getGame().undo();
+        if (undone) {
+            this._undoneMoves.push(undone);
+            // Forza refresh completo di tutti i pezzi dopo undo
+            this._updateBoardPieces(true, true);
+            return undone;
+        }
+        return null;
     }
+    /**
+     * Redo last undone move
+     * @param {Object} [opts]
+     * @param {boolean} [opts.animate=true]
+     * @returns {boolean}
+     */
+    redoMove(opts = {}) {
+        if (this._undoneMoves && this._undoneMoves.length > 0) {
+            const move = this._undoneMoves.pop();
+            const moveObj = { from: move.from, to: move.to };
+            if (move.promotion) moveObj.promotion = move.promotion;
+            const result = this.positionService.getGame().move(moveObj);
+            // Forza refresh completo di tutti i pezzi dopo redo
+            this._updateBoardPieces(true, true);
+            return result;
+        }
+        return false;
+    }
+    /**
+     * Get legal moves for a square
+     * @param {string} square
+     * @returns {Array}
+     */
+    getLegalMoves(square) { return this.legalMoves(square); }
 
+    // --- PIECE MANAGEMENT ---
     /**
-     * Loads a new position
-     * @param {string|Object} position - Position to load
-     * @param {Object} [options={}] - Loading options
-     * @param {boolean} [animation=true] - Whether to animate
+     * Get the piece at a square
+     * @param {string} square
+     * @returns {string|null}
      */
-    load(position, options = {}, animation = true) {
-        this.boardService.applyToAllSquares('removeHint');
-        this.boardService.applyToAllSquares('deselect');
-        this.boardService.applyToAllSquares('unmoved');
+    getPiece(square) {
+        // Sempre leggi lo stato aggiornato dal boardService
+        const squareObj = typeof square === 'string' ? this.boardService.getSquare(square) : square;
+        if (!squareObj || typeof squareObj !== 'object' || !('id' in squareObj)) throw new Error('[getPiece] Parameter square is invalid');
+        // Forza sync prima di leggere
+        this._updateBoardPieces(false, false);
+        const piece = squareObj.piece;
+        if (!piece) return null;
+        return (piece.color + piece.type).toLowerCase();
+    }
+    /**
+     * Put a piece on a square
+     * @param {string|Piece} piece
+     * @param {string|Square} square
+     * @param {Object} [opts]
+     * @param {boolean} [opts.animate=true]
+     * @returns {boolean}
+     */
+    putPiece(piece, square, opts = {}) {
+        const animate = opts.animate !== undefined ? opts.animate : true;
+        let pieceStr = piece;
+        if (typeof piece === 'object' && piece.type && piece.color) {
+            pieceStr = (piece.color + piece.type).toLowerCase();
+        } else if (typeof piece === 'string' && piece.length === 2) {
+            const a = piece[0].toLowerCase();
+            const b = piece[1].toLowerCase();
+            const types = 'kqrbnp';
+            const colors = 'wb';
+            if (types.includes(a) && colors.includes(b)) {
+                pieceStr = b + a;
+            } else if (colors.includes(a) && types.includes(b)) {
+                pieceStr = a + b;
+            } else {
+                throw new Error(`[putPiece] Invalid piece: ${piece}`);
+            }
+        }
+        const squareObj = typeof square === 'string' ? this.boardService.getSquare(square) : square;
+        if (!squareObj || typeof squareObj !== 'object' || !('id' in squareObj)) throw new Error('[putPiece] Parameter square is invalid');
+        const pieceObj = this.pieceService.convertPiece(pieceStr);
+        if (!pieceObj || typeof pieceObj !== 'object' || !('type' in pieceObj)) throw new Error('[putPiece] Parameter piece is invalid');
+        // Aggiorna solo il motore chess.js
+        const chessJsPiece = { type: pieceObj.type, color: pieceObj.color };
+        const game = this.positionService.getGame();
+        const result = game.put(chessJsPiece, squareObj.id);
+        if (!result) throw new Error(`[putPiece] Game.put failed for ${pieceStr} on ${squareObj.id}`);
+        // Non aggiornare direttamente square.piece!
+        // Riallinea la board JS allo stato del motore
+        this._updateBoardPieces(animate);
+        return true;
+    }
+    /**
+     * Remove a piece from a square
+     * @param {string|Square} square
+     * @param {Object} [opts]
+     * @param {boolean} [opts.animate=true]
+     * @returns {string|null}
+     */
+    removePiece(square, opts = {}) {
+        const animate = opts.animate !== undefined ? opts.animate : true;
+        const squareObj = typeof square === 'string' ? this.boardService.getSquare(square) : square;
+        if (!squareObj || typeof squareObj !== 'object' || !('id' in squareObj)) throw new Error('[removePiece] Parameter square is invalid');
+        // Aggiorna solo il motore chess.js
+        const game = this.positionService.getGame();
+        game.remove(squareObj.id);
+        // Non aggiornare direttamente square.piece!
+        // Riallinea la board JS allo stato del motore
+        this._updateBoardPieces(animate);
+        return true;
+    }
 
-        this.positionService.setGame(position, options);
-        this._updateBoardPieces(animation, true); // Position load
+    // --- BOARD CONTROL ---
+    /**
+     * Flip the board orientation
+     * @param {Object} [opts]
+     * @param {boolean} [opts.animate=true]
+     */
+    flipBoard(opts = {}) {
+        if (this.coordinateService && this.coordinateService.flipOrientation) {
+            this.coordinateService.flipOrientation();
+        }
+        if (this._buildBoard) this._buildBoard();
+        if (this._buildSquares) this._buildSquares();
+        if (this._addListeners) this._addListeners();
+        if (this._updateBoardPieces) this._updateBoardPieces(opts.animate !== false);
+        console.log('FEN dopo flip:', this.fen(), 'Orientamento:', this.coordinateService.getOrientation());
+    }
+    /**
+     * Set the board orientation
+     * @param {'w'|'b'} color
+     * @param {Object} [opts]
+     * @param {boolean} [opts.animate=true]
+     */
+    setOrientation(color, opts = {}) {
+        if (this.validationService.isValidOrientation(color)) {
+            this.coordinateService.setOrientation(color);
+            if (this._buildBoard) this._buildBoard();
+            if (this._buildSquares) this._buildSquares();
+            if (this._addListeners) this._addListeners();
+            if (this._updateBoardPieces) this._updateBoardPieces(opts.animate !== false);
+        }
+        return this.coordinateService.getOrientation();
+    }
+    /**
+     * Get the current orientation
+     * @returns {'w'|'b'}
+     */
+    getOrientation() { return this.orientation(); }
+    /**
+     * Resize the board
+     * @param {number|string} size
+     */
+    resizeBoard(size) {
+        if (size === 'auto') {
+            this.config.size = 'auto';
+            document.documentElement.style.setProperty('--dimBoard', 'auto');
+            this._updateBoardPieces(false);
+            return true;
+        }
+        if (typeof size !== 'number' || size < 50 || size > 3000) {
+            throw new Error(`[resizeBoard] Invalid size: ${size}`);
+        }
+        this.config.size = size;
+        document.documentElement.style.setProperty('--dimBoard', `${size}px`);
+        this._updateBoardPieces(false);
+        return true;
     }
 
+    // --- HIGHLIGHTING & UI ---
     /**
-     * Destroys the board and cleans up resources
+     * Highlight a square
+     * @param {string|Square} square
+     * @param {Object} [opts]
      */
-    destroy() {
-        this.eventService.destroy();
-        this.boardService.destroy();
-        this.positionService.destroy();
-        this.pieceService.destroy();
-        this.moveService.destroy();
-        this.animationService.destroy();
-        this.validationService.destroy();
+    highlight(square, opts = {}) {
+        // API: accetta id, converte subito in oggetto
+        const squareObj = typeof square === 'string' ? this.boardService.getSquare(square) : square;
+        if (!squareObj || typeof squareObj !== 'object' || !('id' in squareObj)) throw new Error('[highlight] Parameter square is invalid');
+        if (this.boardService && this.boardService.highlightSquare) {
+            this.boardService.highlightSquare(squareObj, opts);
+        } else if (this.eventService && this.eventService.highlightSquare) {
+            this.eventService.highlightSquare(squareObj, opts);
+        }
+    }
+    /**
+     * Remove highlight from a square
+     * @param {string|Square} square
+     * @param {Object} [opts]
+     */
+    dehighlight(square, opts = {}) {
+        // API: accetta id, converte subito in oggetto
+        const squareObj = typeof square === 'string' ? this.boardService.getSquare(square) : square;
+        if (!squareObj || typeof squareObj !== 'object' || !('id' in squareObj)) throw new Error('[dehighlight] Parameter square is invalid');
+        if (this.boardService && this.boardService.dehighlightSquare) {
+            this.boardService.dehighlightSquare(squareObj, opts);
+        } else if (this.eventService && this.eventService.dehighlightSquare) {
+            this.eventService.dehighlightSquare(squareObj, opts);
+        }
+    }
+
+    // --- GAME INFO ---
+    /**
+     * Get FEN string
+     * @returns {string}
+     */
+    fen() {
+        // Avoid recursion: call the underlying game object's fen()
+        const game = this.positionService.getGame();
+        if (!game || typeof game.fen !== 'function') return '';
+        return game.fen();
+    }
+    /**
+     * Get current turn
+     * @returns {'w'|'b'}
+     */
+    turn() { return this.positionService.getGame().turn(); }
+    /**
+     * Is the game over?
+     * @returns {boolean}
+     */
+    isGameOver() {
+        // Forza sync prima di interrogare il motore
+        this._updateBoardPieces(false, false);
+        const game = this.positionService.getGame();
+        if (!game) return false;
+        if (game.isGameOver) return game.isGameOver();
+        // Fallback: checkmate or draw
+        if (game.isCheckmate && game.isCheckmate()) return true;
+        if (game.isDraw && game.isDraw()) return true;
+        return false;
+    }
+    /**
+     * Is it checkmate?
+     * @returns {boolean}
+     */
+    isCheckmate() {
+        const game = this.positionService.getGame();
+        if (!game) return false;
+        return game.isCheckmate ? game.isCheckmate() : false;
+    }
+    /**
+     * Is it draw?
+     * @returns {boolean}
+     */
+    isDraw() {
+        const game = this.positionService.getGame();
+        if (!game) return false;
+        return game.isDraw ? game.isDraw() : false;
+    }
+    /**
+     * Get move history
+     * @returns {Array}
+     */
+    getHistory() {
+        const game = this.positionService.getGame();
+        if (!game) return [];
+        return game.history ? game.history() : [];
+    }
 
+    // --- LIFECYCLE ---
+    /**
+     * Destroy the board and cleanup all resources
+     */
+    destroy() {
+        // Remove event listeners
+        if (this.eventService && typeof this.eventService.removeListeners === 'function') {
+            this.eventService.removeListeners();
+        }
+        // Clear timeouts
         if (this._updateTimeout) {
             clearTimeout(this._updateTimeout);
             this._updateTimeout = null;
         }
+        // Destroy all services
+        [
+            'validationService',
+            'coordinateService',
+            'positionService',
+            'boardService',
+            'pieceService',
+            'animationService',
+            'moveService',
+            'eventService',
+        ].forEach(service => {
+            if (this[service] && typeof this[service].destroy === 'function') {
+                this[service].destroy();
+            }
+            this[service] = null;
+        });
+        // Nullify DOM references
+        this._performanceMonitor = null;
+        this._boundUpdateBoardPieces = null;
+        this._boundOnSquareClick = null;
+        this._boundOnPieceHover = null;
+        this._boundOnPieceLeave = null;
+        this._undoneMoves = null;
+        // Remove board DOM if possible
+        const boardContainer = document.getElementById(this.config?.id_div);
+        if (boardContainer) {
+            boardContainer.innerHTML = '';
+        }
     }
-
     /**
-     * Resizes the board
-     * @param {number|string} size - New size
+     * Rebuild the board
      */
-    resize(size) {
-        this.boardService.resize(size);
-        this._updateBoardPieces();
-    }
+    rebuild() { this._initialize(); }
 
+    // --- CONFIGURATION ---
     /**
-     * Flips the board orientation
+     * Get current config
+     * @returns {Object}
      */
-    flip() {
-        this.coordinateService.flipOrientation();
-
-        // Save current position before destroying
-        let currentPosition = null;
-        try {
-            // Check if there are any pieces on the board
-            const position = this.positionService.getPosition();
-            const hasPieces = Object.keys(position).length > 0;
-
-            if (hasPieces) {
-                currentPosition = this.positionService.getGame().fen();
-            }
-        } catch (error) {
-            console.log('No valid position to save during flip');
-        }
+    getConfig() { return this.config; }
+    /**
+     * Set new config
+     * @param {Object} newConfig
+     */
+    setConfig(newConfig) { this.setConfig(newConfig); }
 
-        this.destroy();
-        this._initializeServices(); // Recreate all services
-        this._initParams();
+    // --- ALIASES/DEPRECATED ---
+    // Note: These methods are now implemented as aliases at the end of the class
 
-        // Restore position after rebuilding if we had one
-        if (currentPosition) {
-            this._setGame(currentPosition);
-        }
-        this._buildBoard();
-        this._buildSquares();
-        this._addListeners();
-        this._updateBoardPieces(true, true);
+    /**
+     * Alias for flipBoard (for backward compatibility)
+     */
+    flip(opts = {}) {
+        this._updateBoardPieces(opts.animate !== false);
+        return this.flipBoard(opts);
     }
 
     /**
@@ -8242,51 +8230,19 @@ class Chessboard {
         this.load(position, {}, animate); // load() already handles isPositionLoad=true
     }
 
-    /**
-     * Makes a move on the board
-     * @param {string|Object} move - Move to make
-     * @param {boolean} [animate=true] - Whether to animate
-     * @returns {boolean} True if move was successful
-     */
-    move(move, animate = true) {
-        if (typeof move === 'string') {
-            // Parse move string (e.g., 'e2e4')
-            const moveObj = this.moveService.parseMove(move);
-            if (!moveObj) return false;
-
-            const fromSquare = this.boardService.getSquare(moveObj.from);
-            const toSquare = this.boardService.getSquare(moveObj.to);
-
-            if (!fromSquare || !toSquare) return false;
-
-            return this._onMove(fromSquare, toSquare, moveObj.promotion, animate);
-        } else if (move && move.from && move.to) {
-            // Handle move object
-            const fromSquare = this.boardService.getSquare(move.from);
-            const toSquare = this.boardService.getSquare(move.to);
-
-            if (!fromSquare || !toSquare) return false;
-
-            return this._onMove(fromSquare, toSquare, move.promotion, animate);
-        }
-
-        return false;
-    }
-
     /**
      * Undoes the last move
      * @param {boolean} [animate=true] - Whether to animate
      * @returns {boolean} True if undo was successful
      */
     undo(animate = true) {
-        if (this.positionService.getGame().undo) {
-            const undoResult = this.positionService.getGame().undo();
-            if (undoResult) {
-                this._updateBoardPieces(animate, true); // Position change
-                return true;
-            }
+        const undone = this.positionService.getGame().undo();
+        if (undone) {
+            this._undoneMoves.push(undone);
+            this._updateBoardPieces(animate);
+            return undone;
         }
-        return false;
+        return null;
     }
 
     /**
@@ -8295,12 +8251,13 @@ class Chessboard {
      * @returns {boolean} True if redo was successful
      */
     redo(animate = true) {
-        if (this.positionService.getGame().redo) {
-            const redoResult = this.positionService.getGame().redo();
-            if (redoResult) {
-                this._updateBoardPieces(animate, true); // Position change
-                return true;
-            }
+        if (this._undoneMoves && this._undoneMoves.length > 0) {
+            const move = this._undoneMoves.pop();
+            const moveObj = { from: move.from, to: move.to };
+            if (move.promotion) moveObj.promotion = move.promotion;
+            const result = this.positionService.getGame().move(moveObj);
+            this._updateBoardPieces(animate);
+            return result;
         }
         return false;
     }
@@ -8462,112 +8419,6 @@ class Chessboard {
         }
     }
 
-    /**
-     * Clears the board
-     * @param {boolean} [animate=true] - Whether to animate
-     */
-    clear(animate = true) {
-        // Check if services are available
-        if (!this.positionService || !this.positionService.getGame()) {
-            console.log('Cannot clear - position service not available');
-            return;
-        }
-
-        // Clear visual state first
-        this._clearVisualState();
-
-        // Clear game state
-        this.positionService.getGame().clear();
-
-        // Update board visually
-        this._updateBoardPieces(animate, true); // Position change
-    }
-
-    /**
-     * Resets the board to starting position
-     * @param {boolean} [animate=true] - Whether to animate
-     */
-    reset(animate = true) {
-        // Check if services are available
-        if (!this.positionService || !this.positionService.getGame()) {
-            console.log('Cannot reset - position service not available');
-            return;
-        }
-
-        this.positionService.getGame().reset();
-        this._updateBoardPieces(animate, true); // Position change
-    }
-
-    /**
-     * Puts a piece on a square
-     * @param {string} square - Square to put piece on
-     * @param {string} piece - Piece to put
-     * @param {boolean} [animate=true] - Whether to animate
-     * @returns {boolean} True if successful
-     */
-    put(square, piece, animate = true) {
-        console.log(`put() called with square: ${square}, piece: ${piece}`);
-
-        if (!this.validationService.isValidSquare(square) || !this.validationService.isValidPiece(piece)) {
-            console.log('Validation failed');
-            return false;
-        }
-
-        // Check if services are available
-        if (!this.positionService || !this.positionService.getGame()) {
-            console.log('Cannot put piece - position service not available');
-            return false;
-        }
-
-        const pieceObj = this.pieceService.convertPiece(piece);
-        console.log(`Converted piece:`, pieceObj);
-        console.log(`Piece type: ${pieceObj.type}, color: ${pieceObj.color}`);
-
-        const squareObj = this.boardService.getSquare(square);
-
-        if (!squareObj) {
-            console.log('Square not found');
-            return false;
-        }
-
-        // Update game state - note: chess.js expects (piece, square) order
-        const chessJsPiece = { type: pieceObj.type.toLowerCase(), color: pieceObj.color.toLowerCase() };
-        console.log(`Chess.js piece:`, chessJsPiece);
-
-        const result = this.positionService.getGame().put(chessJsPiece, square);
-        console.log(`Chess.js put result:`, result);
-
-        if (result) {
-            // Update visual representation
-            this._updateBoardPieces(animate, true); // Position change
-        }
-
-        return result;
-    }
-
-    /**
-     * Removes a piece from a square
-     * @param {string} square - Square to remove piece from
-     * @param {boolean} [animate=true] - Whether to animate
-     * @returns {boolean} True if successful
-     */
-    remove(square, animate = true) {
-        if (!this.validationService.isValidSquare(square)) {
-            return false;
-        }
-
-        const squareObj = this.boardService.getSquare(square);
-        if (!squareObj) return false;
-
-        // Update game state
-        this.positionService.getGame().remove(square);
-
-        // Update visual representation
-        this._updateBoardPieces(animate, true); // Position change
-
-        return true;
-    }
-
     /**
      * Gets configuration options
      * @returns {Object} Configuration object
@@ -8593,23 +8444,6 @@ class Chessboard {
         }
     }
 
-    /**
-     * Gets or sets the animation style
-     * @param {string} [style] - New animation style ('sequential' or 'simultaneous')
-     * @returns {string} Current animation style
-     */
-    animationStyle(style) {
-        if (style === undefined) {
-            return this.config.animationStyle;
-        }
-
-        if (this.validationService.isValidAnimationStyle(style)) {
-            this.config.animationStyle = style;
-        }
-
-        return this.config.animationStyle;
-    }
-
     /**
      * Gets or sets the simultaneous animation delay
      * @param {number} [delay] - New delay in milliseconds
@@ -8629,7 +8463,97 @@ class Chessboard {
 
     // Additional API methods would be added here following the same pattern
     // This is a good starting point for the refactored architecture
-}
+
+    // Additional API methods and aliases for backward compatibility
+    insert(square, piece) { return this.putPiece(piece, square); }
+    build() { return this._initialize(); }
+    ascii() { return this.positionService.getGame().ascii(); }
+    board() { return this.positionService.getGame().board(); }
+    getCastlingRights(color) { return this.positionService.getGame().getCastlingRights(color); }
+    getComment() { return this.positionService.getGame().getComment(); }
+    getComments() { return this.positionService.getGame().getComments(); }
+    lastMove() { return this.positionService.getGame().lastMove(); }
+    moveNumber() { return this.positionService.getGame().moveNumber(); }
+    moves(options = {}) { return this.positionService.getGame().moves(options); }
+    squareColor(squareId) { return this.boardService.getSquare(squareId).isWhite() ? 'light' : 'dark'; }
+    isDrawByFiftyMoves() { return this.positionService.getGame().isDrawByFiftyMoves(); }
+    isInsufficientMaterial() { return this.positionService.getGame().isInsufficientMaterial(); }
+    removeComment() { return this.positionService.getGame().removeComment(); }
+    removeComments() { return this.positionService.getGame().removeComments(); }
+    removeHeader(field) { return this.positionService.getGame().removeHeader(field); }
+    setCastlingRights(color, rights) { return this.positionService.getGame().setCastlingRights(color, rights); }
+    setComment(comment) { return this.positionService.getGame().setComment(comment); }
+    setHeader(key, value) { return this.positionService.getGame().setHeader(key, value); }
+    validateFen(fen) { return this.positionService.getGame().validateFen(fen); }
+
+    // Implementazioni reali per highlight/dehighlight
+    highlightSquare(square) {
+        return this.boardService.highlight(square);
+    }
+    dehighlightSquare(square) {
+        return this.boardService.dehighlight(square);
+    }
+    forceSync() { this._updateBoardPieces(true, true); this._updateBoardPieces(true, false); }
+
+    // Metodi mancanti che causano fallimenti nei test
+    /**
+     * Move a piece from one square to another
+     * @param {string|Object} move - Move in format 'e2e4' or {from: 'e2', to: 'e4'}
+     * @param {Object} [opts] - Options
+     * @param {boolean} [opts.animate=true] - Whether to animate
+     * @returns {boolean} True if move was successful
+     */
+    movePiece(move, opts = {}) {
+        const animate = opts.animate !== undefined ? opts.animate : true;
+
+        // --- API: accetta id/stringhe, ma converte subito in oggetti ---
+        let fromSquareObj, toSquareObj, promotion;
+        if (typeof move === 'string') {
+            if (move.length === 4) {
+                fromSquareObj = this.boardService.getSquare(move.substring(0, 2));
+                toSquareObj = this.boardService.getSquare(move.substring(2, 4));
+            } else if (move.length === 5) {
+                fromSquareObj = this.boardService.getSquare(move.substring(0, 2));
+                toSquareObj = this.boardService.getSquare(move.substring(2, 4));
+                promotion = move.substring(4, 5);
+            } else {
+                throw new Error(`Invalid move format: ${move}`);
+            }
+        } else if (typeof move === 'object' && move.from && move.to) {
+            // Se sono id, converto in oggetti; se sono già oggetti, li uso direttamente
+            fromSquareObj = typeof move.from === 'string' ? this.boardService.getSquare(move.from) : move.from;
+            toSquareObj = typeof move.to === 'string' ? this.boardService.getSquare(move.to) : move.to;
+            promotion = move.promotion;
+        } else {
+            throw new Error(`Invalid move: ${move}`);
+        }
+
+        if (!fromSquareObj || !toSquareObj) {
+            throw new Error(`Invalid squares: ${move.from || move.substring(0, 2)} or ${move.to || move.substring(2, 4)}`);
+        }
+
+        // --- Internamente: lavora solo con oggetti ---
+        const result = this._onMove(fromSquareObj, toSquareObj, promotion, animate);
+        // Dopo ogni mossa, forza la sincronizzazione della board
+        this._updateBoardPieces(true, false);
+        return result;
+    }
+
+    // Aliases for backward compatibility
+    move(move, animate = true) {
+        // On any new move, clear the redo stack
+        this._undoneMoves = [];
+        return this.movePiece(move, { animate });
+    }
+    get(square) { return this.getPiece(square); }
+    piece(square) { return this.getPiece(square); }
+    put(piece, square, opts = {}) { return this.putPiece(piece, square, opts); }
+    remove(square, opts = {}) { return this.removePiece(square, opts); }
+    load(position, opts = {}) { return this.setPosition(position, opts); }
+    resize(size) { return this.resizeBoard(size); }
+    start(opts = {}) { return this.reset(opts); }
+    clearBoard(opts = {}) { return this.clear(opts); }
+};
 
 /**
  * Structured logging system for Chessboard.js
@@ -9087,7 +9011,6 @@ class ChessboardFactory {
             hints: true,
             clickable: true,
             moveHighlight: true,
-            animationStyle: 'simultaneous'
         });
 
         // Tournament template
@@ -9098,7 +9021,6 @@ class ChessboardFactory {
             clickable: true,
             moveHighlight: true,
             onlyLegalMoves: true,
-            animationStyle: 'sequential'
         });
 
         // Analysis template
@@ -9109,7 +9031,6 @@ class ChessboardFactory {
             clickable: true,
             moveHighlight: true,
             mode: 'analysis',
-            animationStyle: 'simultaneous'
         });
 
         // Puzzle template
@@ -9120,7 +9041,6 @@ class ChessboardFactory {
             clickable: true,
             moveHighlight: true,
             onlyLegalMoves: true,
-            animationStyle: 'sequential'
         });
 
         // Demo template
@@ -9130,7 +9050,6 @@ class ChessboardFactory {
             hints: false,
             clickable: false,
             moveHighlight: true,
-            animationStyle: 'simultaneous'
         });
     }
 
@@ -9176,7 +9095,7 @@ class ChessboardFactory {
             this.validationService.validateConfig(finalConfig);
 
             // Create chessboard instance
-            const chessboard = new Chessboard(finalConfig);
+            const chessboard = new Chessboard$1(finalConfig);
 
             // Store instance for management
             this.instances.set(containerId, {
@@ -9436,13 +9355,44 @@ function createChessboardFromTemplate(containerId, templateName, overrides = {})
  */
 
 
+/**
+ * Main Chessboard factory function for backward compatibility
+ * Supports both legacy and modern calling conventions
+ * @param {string|Object} containerElm - Container element ID or configuration object
+ * @param {Object} [config={}] - Configuration options (when first param is string)
+ * @returns {ChessboardClass} Chessboard instance
+ */
+function Chessboard(containerElm, config = {}) {
+    const factoryLogger = logger.child('ChessboardFactory');
+
+    try {
+        // If first parameter is an object, treat it as config
+        if (typeof containerElm === 'object' && containerElm !== null) {
+            factoryLogger.debug('Creating chessboard with config object');
+            return new Chessboard$1(containerElm);
+        }
+
+        // Otherwise, treat first parameter as element ID
+        if (typeof containerElm === 'string') {
+            factoryLogger.debug('Creating chessboard with element ID', { elementId: containerElm });
+            const fullConfig = { ...config, id: containerElm };
+            return new Chessboard$1(fullConfig);
+        }
+
+        throw new Error('Invalid parameters: first parameter must be string or object');
+    } catch (error) {
+        factoryLogger.error('Failed to create chessboard instance', { error });
+        throw error;
+    }
+}
+
 /**
  * Wrapper class that handles both calling conventions
  * Provides enhanced error handling and logging
  * @class
  * @extends ChessboardClass
  */
-class ChessboardWrapper extends Chessboard {
+class ChessboardWrapper extends Chessboard$1 {
     /**
      * Creates a new ChessboardWrapper instance
      * @param {string|Object} containerElm - Container element ID or configuration object
@@ -9471,32 +9421,53 @@ class ChessboardWrapper extends Chessboard {
     }
 }
 
-// Attach classes and utilities to the factory function for direct access
-Chessboard.Class = ChessboardWrapper;
-Chessboard.Chessboard = ChessboardWrapper;
-Chessboard.Config = ChessboardConfig;
-Chessboard.Factory = ChessboardFactory;
+/**
+ * Refactored Chessboard API - see Chessboard.js for full method docs
+ * @typedef {import('./Chessboard.js').Chessboard} Chessboard
+ */
 
-// Attach factory methods
+// --- STATIC/FACTORY METHODS ---
+/**
+ * Create a new Chessboard instance
+ * @param {string|Object} containerElm
+ * @param {Object} [config]
+ * @returns {Chessboard}
+ */
 Chessboard.create = createChessboard;
-Chessboard.createFromTemplate = createChessboardFromTemplate;
+/**
+ * Create a Chessboard from a template
+ * @param {string|Object} containerElm
+ * @param {string} templateName
+ * @param {Object} [config]
+ * @returns {Chessboard}
+ */
+Chessboard.fromTemplate = createChessboardFromTemplate;
 Chessboard.factory = chessboardFactory;
 
-// Static methods for instance management
+// --- INSTANCE MANAGEMENT ---
 Chessboard.getInstance = (containerId) => chessboardFactory.getInstance(containerId);
 Chessboard.destroyInstance = (containerId) => chessboardFactory.destroy(containerId);
 Chessboard.destroyAll = () => chessboardFactory.destroyAll();
 Chessboard.listInstances = () => chessboardFactory.listInstances();
 
-// Template management
+// --- TEMPLATE MANAGEMENT ---
 Chessboard.registerTemplate = (name, config) => chessboardFactory.registerTemplate(name, config);
 Chessboard.removeTemplate = (name) => chessboardFactory.removeTemplate(name);
 Chessboard.getTemplate = (name) => chessboardFactory.getTemplate(name);
 Chessboard.listTemplates = () => chessboardFactory.listTemplates();
 
-// Statistics and debugging
+// --- STATS & DEBUG ---
 Chessboard.getStats = () => chessboardFactory.getStats();
 
+// --- DEPRECATED/LEGACY ALIASES ---
+/**
+ * @deprecated Use Chessboard.create instead
+ */
+Chessboard.Class = ChessboardWrapper;
+Chessboard.Chessboard = ChessboardWrapper;
+Chessboard.Config = ChessboardConfig;
+Chessboard.Factory = ChessboardFactory;
+
 /**
  * Coordinate utilities for Chessboard.js
  */
@@ -9886,11 +9857,7 @@ function validateConfig(config) {
     if (config.moveAnimation && !isValidEasing(config.moveAnimation)) {
         errors.push('Invalid moveAnimation. Must be a valid easing function');
     }
-    
-    if (config.animationStyle && !['sequential', 'simultaneous'].includes(config.animationStyle)) {
-        errors.push('Invalid animationStyle. Must be "sequential" or "simultaneous"');
-    }
-    
+        
     return {
         success: errors.length === 0,
         errors