Implement dynamic percentage compatibility system across all games

Major architectural update to replace fixed 50%/100% scoring with true dynamic percentages based on content volume:

• Replace old interpolation system with Math.min(100, (count/optimal)*100) formula
• Add embedded compatibility methods to all 14 game modules with static requirements
• Remove compatibility cache system for real-time calculation
• Fix content loading to pass complete modules with vocabulary (not just metadata)
• Clean up duplicate syntax errors in adventure-reader and grammar-discovery
• Update navigation.js module mapping to match actual exported class names

Examples of new dynamic scoring:
- 15 words / 20 optimal = 75% (was 87.5% with old interpolation)
- 5 words / 10 minimum = 50% (was 25% with old linear system)
- 30 words / 20 optimal = 100% (unchanged)

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

js/core/navigation.js

@@ -9,6 +9,8 @@ const AppNavigation = {
     compatibilityChecker: null,
 
     init() {
+        // Clear any existing compatibility cache in localStorage
+        this.clearExistingCache();
         this.loadGamesConfig();
         this.initContentScanner();
         this.initCompatibilityChecker();
@@ -16,6 +18,33 @@ const AppNavigation = {
         this.handleInitialRoute();
     },
 
+    // Clear existing cache from localStorage and sessionStorage
+    clearExistingCache() {
+        try {
+            // Clear any compatibility-related cache
+            const keysToRemove = [];
+            for (let i = 0; i < localStorage.length; i++) {
+                const key = localStorage.key(i);
+                if (key && (key.includes('compatibility') || key.includes('cache'))) {
+                    keysToRemove.push(key);
+                }
+            }
+            keysToRemove.forEach(key => localStorage.removeItem(key));
+
+            // Also clear sessionStorage
+            for (let i = 0; i < sessionStorage.length; i++) {
+                const key = sessionStorage.key(i);
+                if (key && (key.includes('compatibility') || key.includes('cache'))) {
+                    sessionStorage.removeItem(key);
+                }
+            }
+
+            logSh('🗑️ Existing compatibility cache cleared from browser storage', 'DEBUG');
+        } catch (error) {
+            logSh(`⚠️ Error clearing cache: ${error.message}`, 'WARN');
+        }
+    },
+
     async loadGamesConfig() {
         // Direct use of default config (no fetch)
         logSh('📁 Using default configuration', 'INFO');
@@ -460,22 +489,14 @@ const AppNavigation = {
         const compatibleGames = [];
         const incompatibleGames = [];
 
-        enabledGames.forEach(([key, game]) => {
+        // Process games sequentially to avoid overwhelming the system
+        for (const [key, game] of enabledGames) {
             let compatibility = null;
 
-            if (contentInfo && this.compatibilityChecker) {
-                // Récupérer le module JavaScript réel pour le test de compatibilité
-                const moduleName = this.getModuleName(contentType);
-                const actualContentModule = window.ContentModules?.[moduleName];
-
-                if (actualContentModule) {
-                    compatibility = this.compatibilityChecker.checkCompatibility(actualContentModule, key);
-                    logSh(`🎯 ${game.name} compatibility: ${compatibility.compatible ? '✅' : '❌'} (score: ${compatibility.score}%) - ${compatibility.reason}`, 'DEBUG');
-                } else {
-                    logSh(`⚠️ Module JavaScript non trouvé: ${moduleName}`, 'WARN');
-                    // Pas de compatibilité = compatible par défaut (comportement de fallback)
-                    compatibility = { compatible: true, score: 50, reason: "Module not loaded - default compatibility" };
-                }
+            if (contentInfo) {
+                // Use embedded compatibility system with async loading and caching
+                compatibility = await this.checkGameCompatibilityEmbedded(key, contentInfo);
+                logSh(`🎯 ${game.name} compatibility: ${compatibility.compatible ? '✅' : '❌'} (score: ${compatibility.score}%) - ${compatibility.reason}`, 'DEBUG');
             }
 
             const gameData = { key, game, compatibility };
@@ -485,7 +506,7 @@ const AppNavigation = {
             } else {
                 incompatibleGames.push(gameData);
             }
-        });
+        }
 
         // Afficher d'abord les jeux compatibles
         if (compatibleGames.length > 0) {
@@ -817,6 +838,135 @@ const AppNavigation = {
         }
         
         return item;
+    },
+
+    // Check game compatibility using embedded system (no caching)
+    async checkGameCompatibilityEmbedded(gameKey, contentInfo) {
+
+        try {
+            // Map game keys to module names and file paths
+            const moduleMapping = {
+                'whack-a-mole': { name: 'WhackAMole', file: 'whack-a-mole.js' },
+                'whack-a-mole-hard': { name: 'WhackAMoleHard', file: 'whack-a-mole-hard.js' },
+                'memory-match': { name: 'MemoryMatch', file: 'memory-match.js' },
+                'quiz-game': { name: 'QuizGame', file: 'quiz-game.js' },
+                'fill-the-blank': { name: 'FillTheBlank', file: 'fill-the-blank.js' },
+                'word-discovery': { name: 'WordDiscovery', file: 'word-discovery.js' },
+                'river-run': { name: 'RiverRun', file: 'river-run.js' },
+                'story-reader': { name: 'StoryReader', file: 'story-reader.js' },
+                'adventure-reader': { name: 'AdventureReader', file: 'adventure-reader.js' },
+                'letter-discovery': { name: 'LetterDiscovery', file: 'letter-discovery.js' },
+                'chinese-study': { name: 'ChineseStudy', file: 'chinese-study.js' },
+                'grammar-discovery': { name: 'GrammarDiscovery', file: 'grammar-discovery.js' },
+                'word-storm': { name: 'WordStorm', file: 'word-storm.js' },
+                'story-builder': { name: 'StoryBuilder', file: 'story-builder.js' }
+            };
+
+            const moduleInfo = moduleMapping[gameKey];
+            if (!moduleInfo) {
+                return { compatible: true, score: 50, reason: "Unknown game type - default compatibility" };
+            }
+
+            // Check if module is already loaded
+            let GameModule = window.GameModules?.[moduleInfo.name];
+
+            // If not loaded, load it dynamically
+            if (!GameModule) {
+                logSh(`📥 Loading game module: ${moduleInfo.file}`, 'DEBUG');
+                await this.loadGameModule(moduleInfo.file);
+                GameModule = window.GameModules?.[moduleInfo.name];
+            }
+
+            if (!GameModule) {
+                return { compatible: true, score: 50, reason: "Failed to load game module - default compatibility" };
+            }
+
+            // Check if the game has embedded compatibility methods
+            if (!GameModule.checkContentCompatibility) {
+                return { compatible: true, score: 50, reason: "No embedded compatibility system - default compatibility" };
+            }
+
+            // Load the actual content module to get vocabulary, not just metadata
+            let actualContent = contentInfo;
+            if (contentInfo.filename && !contentInfo.vocabulary) {
+                console.log(`📥 Loading actual content module: ${contentInfo.filename}`);
+                try {
+                    // Load the content module script dynamically
+                    await this.loadContentModule(contentInfo.filename);
+
+                    // Get the actual loaded content from window.ContentModules
+                    const moduleKey = Object.keys(window.ContentModules || {}).find(key => {
+                        const module = window.ContentModules[key];
+                        return module.id === contentInfo.id || module.name === contentInfo.name;
+                    });
+
+                    if (moduleKey && window.ContentModules[moduleKey]) {
+                        actualContent = window.ContentModules[moduleKey];
+                        console.log(`✅ Loaded actual content with vocabulary:`, actualContent.vocabulary ? 'YES' : 'NO');
+                    }
+                } catch (error) {
+                    console.warn(`⚠️ Failed to load content module: ${error.message}`);
+                }
+            }
+
+            // Use the game's embedded compatibility check
+            console.log(`🎯 Calling embedded compatibility for ${gameKey} with content:`, actualContent.name || 'Unknown');
+            console.log(`🎯 Content has vocabulary:`, actualContent.vocabulary ? 'YES' : 'NO');
+            const result = GameModule.checkContentCompatibility(actualContent);
+            console.log(`🎯 Embedded result for ${gameKey}:`, result);
+
+            // Convert to navigation format
+            const minScore = 50; // Minimum score for compatibility
+            const finalResult = {
+                compatible: result.score >= minScore,
+                score: result.score,
+                reason: result.score >= minScore ?
+                    `Compatible (${result.score}%)` :
+                    `Incompatible (${result.score}% < ${minScore}%)`,
+                details: result.details,
+                recommendations: result.recommendations
+            };
+            console.log(`🎯 Final result for ${gameKey}:`, finalResult);
+            return finalResult;
+
+        } catch (error) {
+            logSh(`❌ Error checking compatibility for ${gameKey}: ${error.message}`, 'ERROR');
+            return { compatible: true, score: 50, reason: "Compatibility check error - default compatibility" };
+        }
+    },
+
+    // Dynamically load a game module
+    async loadGameModule(filename) {
+        return new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = `js/games/${filename}`;
+            script.onload = () => {
+                logSh(`✅ Game module loaded: ${filename}`, 'DEBUG');
+                resolve();
+            };
+            script.onerror = () => {
+                logSh(`❌ Failed to load game module: ${filename}`, 'ERROR');
+                reject(new Error(`Failed to load ${filename}`));
+            };
+            document.head.appendChild(script);
+        });
+    },
+
+    // Dynamically load a content module
+    async loadContentModule(filename) {
+        return new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = `js/content/${filename}`;
+            script.onload = () => {
+                logSh(`✅ Content module loaded: ${filename}`, 'DEBUG');
+                resolve();
+            };
+            script.onerror = () => {
+                logSh(`❌ Failed to load content module: ${filename}`, 'ERROR');
+                reject(new Error(`Failed to load ${filename}`));
+            };
+            document.head.appendChild(script);
+        });
     }
 };
 

js/games/adventure-reader.js

@@ -1280,6 +1280,200 @@ class AdventureReaderGame {
         }
         this.container.innerHTML = '';
     }
+
+    // === COMPATIBILITY SYSTEM ===
+    static getCompatibilityRequirements() {
+        return {
+            minimum: {
+                stories: 1,
+                vocabulary: 15
+            },
+            optimal: {
+                stories: 2,
+                vocabulary: 30
+            },
+            name: "Adventure Reader",
+            description: "Interactive RPG-style reading with vocabulary learning and TTS support"
+        };
+    }
+
+    static checkContentCompatibility(content) {
+        const requirements = AdventureReaderGame.getCompatibilityRequirements();
+
+        // Extract stories and vocabulary using same method as instance
+        const stories = AdventureReaderGame.extractStoriesStatic(content);
+        const vocabulary = AdventureReaderGame.extractVocabularyStatic(content);
+
+        const storyCount = stories.length;
+        const vocabCount = vocabulary.length;
+
+        // Calculate score based on both stories and vocabulary
+
+        // Dynamic percentage based on optimal volumes (1→2 stories, 15→30 vocab)
+        // Stories: 0=0%, 1=50%, 2=100%
+        // Vocabulary: 0=0%, 15=50%, 30=100%
+        const storyScore = Math.min(100, (storyCount / requirements.optimal.stories) * 100);
+        const vocabScore = Math.min(100, (vocabCount / requirements.optimal.vocabulary) * 100);
+
+        // Combined score (weighted average: 70% stories, 30% vocabulary)
+        const finalScore = (storyScore * 0.7) + (vocabScore * 0.3);
+
+        const recommendations = [];
+        if (storyCount < requirements.optimal.stories) {
+            recommendations.push(`Add ${requirements.optimal.stories - storyCount} more stories for optimal experience`);
+        }
+        if (vocabCount < requirements.optimal.vocabulary) {
+            recommendations.push(`Add ${requirements.optimal.vocabulary - vocabCount} more vocabulary words for enhanced learning`);
+        }
+
+        return {
+            score: Math.round(finalScore),
+            details: {
+                stories: {
+                    found: storyCount,
+                    minimum: requirements.minimum.stories,
+                    optimal: requirements.optimal.stories,
+                    status: storyCount >= requirements.minimum.stories ? 'sufficient' : 'insufficient'
+                },
+                vocabulary: {
+                    found: vocabCount,
+                    minimum: requirements.minimum.vocabulary,
+                    optimal: requirements.optimal.vocabulary,
+                    status: vocabCount >= requirements.minimum.vocabulary ? 'sufficient' : 'insufficient'
+                }
+            },
+            recommendations: recommendations
+        };
+    }
+
+    static extractStoriesStatic(content) {
+        let stories = [];
+
+        // Priority 1: Use raw module content
+        if (content.rawContent) {
+            // Extract from story object
+            if (content.rawContent.story && content.rawContent.story.chapters) {
+                stories.push(content.rawContent.story);
+            }
+
+            // Extract from additionalStories array
+            if (content.rawContent.additionalStories && Array.isArray(content.rawContent.additionalStories)) {
+                stories.push(...content.rawContent.additionalStories);
+            }
+        }
+
+        // Priority 2: Direct content properties
+        if (content.story && content.story.chapters) {
+            stories.push(content.story);
+        }
+
+        if (content.additionalStories && Array.isArray(content.additionalStories)) {
+            stories.push(...content.additionalStories);
+        }
+
+        // Filter valid stories
+        stories = stories.filter(story =>
+            story &&
+            typeof story === 'object' &&
+            story.chapters &&
+            Array.isArray(story.chapters) &&
+            story.chapters.length > 0
+        );
+
+        return stories;
+    }
+
+    static extractVocabularyStatic(content) {
+        let vocabulary = [];
+
+        // Priority 1: Use raw module content (simple format)
+        if (content.rawContent) {
+            return AdventureReaderGame.extractVocabularyFromRawStatic(content.rawContent);
+        }
+
+        // Priority 2: Ultra-modular format (vocabulary object) - ONLY format supported
+        if (content.vocabulary && typeof content.vocabulary === 'object' && !Array.isArray(content.vocabulary)) {
+            vocabulary = Object.entries(content.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        word: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        word: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return AdventureReaderGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static extractVocabularyFromRawStatic(rawContent) {
+        let vocabulary = [];
+
+        // Ultra-modular format (vocabulary object) - ONLY format supported
+        if (rawContent.vocabulary && typeof rawContent.vocabulary === 'object' && !Array.isArray(rawContent.vocabulary)) {
+            vocabulary = Object.entries(rawContent.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        word: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        word: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return AdventureReaderGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static finalizeVocabularyStatic(vocabulary) {
+        // Validation and cleanup for ultra-modular format
+        vocabulary = vocabulary.filter(word =>
+            word &&
+            typeof word.word === 'string' &&
+            typeof word.translation === 'string' &&
+            word.word.trim() !== '' &&
+            word.translation.trim() !== ''
+        );
+
+        return vocabulary;
+    }
 }
 
 // Module registration

js/games/chinese-study.js

@@ -1578,6 +1578,163 @@ class ChineseStudyGame {
         this.createGameInterface();
         logSh('Chinese Study Mode restarted', 'INFO');
     }
+
+    // === COMPATIBILITY SYSTEM ===
+    static getCompatibilityRequirements() {
+        return {
+            minimum: {
+                vocabulary: 10
+            },
+            optimal: {
+                vocabulary: 20
+            },
+            name: "Chinese Study",
+            description: "Chinese character and vocabulary learning with multiple study modes"
+        };
+    }
+
+    static checkContentCompatibility(content) {
+        const requirements = ChineseStudyGame.getCompatibilityRequirements();
+
+        // Extract vocabulary using same method as instance
+        const vocabulary = ChineseStudyGame.extractVocabularyStatic(content);
+        const vocabCount = vocabulary.length;
+
+        // Dynamic percentage based on optimal volume (10 min → 20 optimal)
+        // 0 words = 0%, 10 words = 50%, 20 words = 100%
+        const score = Math.min(100, (vocabCount / requirements.optimal.vocabulary) * 100);
+
+        const recommendations = [];
+        if (vocabCount < requirements.optimal.vocabulary) {
+            recommendations.push(`Add ${requirements.optimal.vocabulary - vocabCount} more vocabulary words for optimal experience`);
+        }
+
+        // Count Chinese-specific features for bonus recommendations
+        const hasChineseCharacters = vocabulary.some(word => word.chinese || /[\u4e00-\u9fff]/.test(word.original));
+        const hasPronunciation = vocabulary.some(word => word.pronunciation || word.pinyin);
+
+        if (!hasChineseCharacters) {
+            recommendations.push("Add Chinese characters for authentic Chinese study experience");
+        }
+        if (!hasPronunciation) {
+            recommendations.push("Add pronunciation (pinyin) for pronunciation practice");
+        }
+
+        return {
+            score: Math.round(score),
+            details: {
+                vocabulary: {
+                    found: vocabCount,
+                    minimum: requirements.minimum.vocabulary,
+                    optimal: requirements.optimal.vocabulary,
+                    status: vocabCount >= requirements.minimum.vocabulary ? 'sufficient' : 'insufficient'
+                },
+                chineseFeatures: {
+                    characters: hasChineseCharacters ? 'available' : 'missing',
+                    pronunciation: hasPronunciation ? 'available' : 'missing'
+                }
+            },
+            recommendations: recommendations
+        };
+    }
+
+    static extractVocabularyStatic(content) {
+        let vocabulary = [];
+
+        // Priority 1: Use raw module content (simple format)
+        if (content.rawContent) {
+            return ChineseStudyGame.extractVocabularyFromRawStatic(content.rawContent);
+        }
+
+        // Priority 2: Ultra-modular format (vocabulary object) - ONLY format supported
+        if (content.vocabulary && typeof content.vocabulary === 'object' && !Array.isArray(content.vocabulary)) {
+            vocabulary = Object.entries(content.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        original: word,
+                        chinese: word, // Use original as Chinese if it contains Chinese characters
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        pinyin: data.pronunciation, // Use pronunciation as pinyin
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        original: word,
+                        chinese: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return ChineseStudyGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static extractVocabularyFromRawStatic(rawContent) {
+        let vocabulary = [];
+
+        // Ultra-modular format (vocabulary object) - ONLY format supported
+        if (rawContent.vocabulary && typeof rawContent.vocabulary === 'object' && !Array.isArray(rawContent.vocabulary)) {
+            vocabulary = Object.entries(rawContent.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        original: word,
+                        chinese: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        pinyin: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        original: word,
+                        chinese: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return ChineseStudyGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static finalizeVocabularyStatic(vocabulary) {
+        // Validation and cleanup for ultra-modular format
+        vocabulary = vocabulary.filter(word =>
+            word &&
+            typeof word.original === 'string' &&
+            typeof word.translation === 'string' &&
+            word.original.trim() !== '' &&
+            word.translation.trim() !== ''
+        );
+
+        return vocabulary;
+    }
 }
 
 // Export to global scope

js/games/fill-the-blank.js

@@ -562,6 +562,228 @@ class FillTheBlankGame {
         this.isRunning = false;
         this.container.innerHTML = '';
     }
+
+    // === COMPATIBILITY SYSTEM ===
+    static getCompatibilityRequirements() {
+        return {
+            minimum: {
+                vocabulary: 5,
+                sentences: 3
+            },
+            optimal: {
+                vocabulary: 12,
+                sentences: 8
+            },
+            name: "Fill the Blank",
+            description: "Needs vocabulary and sentences/texts to create meaningful cloze exercises"
+        };
+    }
+
+    static checkContentCompatibility(content) {
+        const requirements = FillTheBlankGame.getCompatibilityRequirements();
+
+        // Extract vocabulary and sentences using same method as instance
+        const vocabulary = FillTheBlankGame.extractVocabularyStatic(content);
+        const sentences = FillTheBlankGame.extractSentencesStatic(content);
+
+        const vocabCount = vocabulary.length;
+        const sentenceCount = sentences.length;
+
+        // Dynamic percentage based on optimal volumes (5→12 vocab, 3→8 sentences)
+        // Vocabulary: 0=0%, 6=50%, 12=100%
+        // Sentences: 0=0%, 4=50%, 8=100%
+        const vocabScore = Math.min(100, (vocabCount / requirements.optimal.vocabulary) * 100);
+        const sentenceScore = Math.min(100, (sentenceCount / requirements.optimal.sentences) * 100);
+
+        // Combined score (weighted average: 60% vocabulary, 40% sentences)
+        const finalScore = (vocabScore * 0.6) + (sentenceScore * 0.4);
+
+        const recommendations = [];
+        if (vocabCount < requirements.optimal.vocabulary) {
+            recommendations.push(`Add ${requirements.optimal.vocabulary - vocabCount} more vocabulary words`);
+        }
+        if (sentenceCount < requirements.optimal.sentences) {
+            recommendations.push(`Add ${requirements.optimal.sentences - sentenceCount} more sentences/texts`);
+        }
+
+        return {
+            score: Math.round(finalScore),
+            details: {
+                vocabulary: {
+                    found: vocabCount,
+                    minimum: requirements.minimum.vocabulary,
+                    optimal: requirements.optimal.vocabulary,
+                    status: vocabCount >= requirements.minimum.vocabulary ? 'sufficient' : 'insufficient'
+                },
+                sentences: {
+                    found: sentenceCount,
+                    minimum: requirements.minimum.sentences,
+                    optimal: requirements.optimal.sentences,
+                    status: sentenceCount >= requirements.minimum.sentences ? 'sufficient' : 'insufficient'
+                }
+            },
+            recommendations: recommendations
+        };
+    }
+
+    static extractVocabularyStatic(content) {
+        let vocabulary = [];
+
+        // Priority 1: Use raw module content (simple format)
+        if (content.rawContent) {
+            return FillTheBlankGame.extractVocabularyFromRawStatic(content.rawContent);
+        }
+
+        // Priority 2: Ultra-modular format (vocabulary object) - ONLY format supported
+        if (content.vocabulary && typeof content.vocabulary === 'object' && !Array.isArray(content.vocabulary)) {
+            vocabulary = Object.entries(content.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        original: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        original: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return FillTheBlankGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static extractVocabularyFromRawStatic(rawContent) {
+        let vocabulary = [];
+
+        // Ultra-modular format (vocabulary object) - ONLY format supported
+        if (rawContent.vocabulary && typeof rawContent.vocabulary === 'object' && !Array.isArray(rawContent.vocabulary)) {
+            vocabulary = Object.entries(rawContent.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        original: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        original: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return FillTheBlankGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static finalizeVocabularyStatic(vocabulary) {
+        // Validation and cleanup for ultra-modular format
+        vocabulary = vocabulary.filter(word =>
+            word &&
+            typeof word.original === 'string' &&
+            typeof word.translation === 'string' &&
+            word.original.trim() !== '' &&
+            word.translation.trim() !== ''
+        );
+
+        return vocabulary;
+    }
+
+    static extractSentencesStatic(content) {
+        let sentences = [];
+
+        // Priority 1: Use raw module content
+        if (content.rawContent) {
+            // Extract from sentences array
+            if (content.rawContent.sentences && Array.isArray(content.rawContent.sentences)) {
+                content.rawContent.sentences.forEach(sentence => {
+                    if (sentence.english) {
+                        sentences.push(sentence.english);
+                    }
+                    if (sentence.chinese) {
+                        sentences.push(sentence.chinese);
+                    }
+                    if (sentence.french) {
+                        sentences.push(sentence.french);
+                    }
+                });
+            }
+
+            // Extract from texts array
+            if (content.rawContent.texts && Array.isArray(content.rawContent.texts)) {
+                content.rawContent.texts.forEach(text => {
+                    if (text.content) {
+                        // Split text content into sentences
+                        const textSentences = text.content.split(/[.!?]+/).filter(s => s.trim().length > 10);
+                        sentences.push(...textSentences);
+                    }
+                });
+            }
+        }
+
+        // Priority 2: Direct content properties
+        if (content.sentences && Array.isArray(content.sentences)) {
+            content.sentences.forEach(sentence => {
+                if (sentence.english) {
+                    sentences.push(sentence.english);
+                }
+                if (sentence.chinese) {
+                    sentences.push(sentence.chinese);
+                }
+                if (sentence.french) {
+                    sentences.push(sentence.french);
+                }
+            });
+        }
+
+        if (content.texts && Array.isArray(content.texts)) {
+            content.texts.forEach(text => {
+                if (text.content) {
+                    const textSentences = text.content.split(/[.!?]+/).filter(s => s.trim().length > 10);
+                    sentences.push(...textSentences);
+                }
+            });
+        }
+
+        // Filter and validate sentences
+        sentences = sentences.filter(sentence =>
+            sentence &&
+            typeof sentence === 'string' &&
+            sentence.trim().length > 5 &&
+            sentence.split(' ').length >= 3
+        );
+
+        return sentences;
+    }
 }
 
 // Module registration

js/games/grammar-discovery.js

@@ -1178,6 +1178,135 @@ class GrammarDiscovery {
             delete window.currentGrammarGame;
         }
     }
+
+    // === COMPATIBILITY SYSTEM ===
+    static getCompatibilityRequirements() {
+        return {
+            minimum: {
+                grammarRules: 1,
+                examples: 1
+            },
+            optimal: {
+                grammarRules: 2,
+                examples: 2,
+                exercises: 1
+            },
+            name: "Grammar Discovery",
+            description: "Grammar rule learning with examples and practice exercises"
+        };
+    }
+
+    static checkContentCompatibility(content) {
+        const requirements = GrammarDiscovery.getCompatibilityRequirements();
+
+        // Extract grammar data using same method as instance
+        const grammarData = GrammarDiscovery.extractGrammarDataStatic(content);
+
+        const ruleCount = grammarData.length;
+        const hasExamples = grammarData.some(rule => rule.examples && rule.examples.length > 0);
+        const hasExercises = grammarData.some(rule => rule.exercises && rule.exercises.length > 0);
+        const avgExamples = ruleCount > 0 ?
+            grammarData.reduce((sum, rule) => sum + (rule.examples ? rule.examples.length : 0), 0) / ruleCount : 0;
+
+        // Calculate score based on rules, examples, and exercises
+
+        // Dynamic percentage based on optimal volumes (1→2 rules, 1→2 examples, exercises bonus)
+        // Rules: 0=0%, 1=50%, 2=100%
+        // Examples: 0=0%, 1=50%, 2=100%
+        // Exercises: 0=0%, 1=100% (binary)
+        const ruleScore = Math.min(100, (ruleCount / requirements.optimal.grammarRules) * 100);
+        const exampleScore = Math.min(100, (avgExamples / requirements.optimal.examples) * 100);
+        const exerciseScore = hasExercises ? 100 : 0;
+
+        // Combined score (weighted: 50% rules, 30% examples, 20% exercises)
+        const finalScore = (ruleScore * 0.5) + (exampleScore * 0.3) + (exerciseScore * 0.2);
+
+        const recommendations = [];
+        if (ruleCount < requirements.optimal.grammarRules) {
+            recommendations.push(`Add ${requirements.optimal.grammarRules - ruleCount} more grammar rules`);
+        }
+        if (avgExamples < requirements.optimal.examples) {
+            recommendations.push("Add more examples for each grammar rule");
+        }
+        if (!hasExercises) {
+            recommendations.push("Add practice exercises for interactive learning");
+        }
+
+        return {
+            score: Math.round(finalScore),
+            details: {
+                grammarRules: {
+                    found: ruleCount,
+                    minimum: requirements.minimum.grammarRules,
+                    optimal: requirements.optimal.grammarRules,
+                    status: ruleCount >= requirements.minimum.grammarRules ? 'sufficient' : 'insufficient'
+                },
+                examples: {
+                    average: Math.round(avgExamples * 10) / 10,
+                    minimum: requirements.minimum.examples,
+                    optimal: requirements.optimal.examples,
+                    status: avgExamples >= requirements.minimum.examples ? 'sufficient' : 'insufficient'
+                },
+                exercises: {
+                    available: hasExercises ? 'yes' : 'no',
+                    status: hasExercises ? 'available' : 'missing'
+                }
+            },
+            recommendations: recommendations
+        };
+    }
+
+    static extractGrammarDataStatic(content) {
+        let grammarRules = [];
+
+        // Priority 1: Use raw module content
+        if (content.rawContent) {
+            // Extract from grammar object
+            if (content.rawContent.grammar && typeof content.rawContent.grammar === 'object') {
+                grammarRules = Object.entries(content.rawContent.grammar).map(([ruleKey, ruleData]) => {
+                    if (typeof ruleData === 'object') {
+                        return {
+                            key: ruleKey,
+                            title: ruleData.title || ruleKey,
+                            explanation: ruleData.explanation || '',
+                            examples: ruleData.examples || [],
+                            exercises: ruleData.exercises || [],
+                            category: ruleData.category || 'general'
+                        };
+                    }
+                    return null;
+                }).filter(Boolean);
+            }
+        }
+
+        // Priority 2: Direct content properties
+        if (content.grammar && typeof content.grammar === 'object') {
+            grammarRules = Object.entries(content.grammar).map(([ruleKey, ruleData]) => {
+                if (typeof ruleData === 'object') {
+                    return {
+                        key: ruleKey,
+                        title: ruleData.title || ruleKey,
+                        explanation: ruleData.explanation || '',
+                        examples: ruleData.examples || [],
+                        exercises: ruleData.exercises || [],
+                        category: ruleData.category || 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        // Filter and validate grammar rules
+        grammarRules = grammarRules.filter(rule =>
+            rule &&
+            typeof rule.title === 'string' &&
+            rule.title.trim() !== '' &&
+            typeof rule.explanation === 'string' &&
+            rule.explanation.trim() !== ''
+        );
+
+        return grammarRules;
+    }
 }
 
 // Export to global

js/games/letter-discovery.js

@@ -774,6 +774,164 @@ class LetterDiscovery {
             styleSheet.remove();
         }
     }
+
+    // === COMPATIBILITY SYSTEM ===
+    static getCompatibilityRequirements() {
+        return {
+            minimum: {
+                letters: 2,
+                wordsPerLetter: 3
+            },
+            optimal: {
+                letters: 8,
+                wordsPerLetter: 4
+            },
+            name: "Letter Discovery",
+            description: "Alphabet learning with words starting with each letter"
+        };
+    }
+
+    static checkContentCompatibility(content) {
+        const requirements = LetterDiscovery.getCompatibilityRequirements();
+
+        // Extract letter-based vocabulary using same method as instance
+        const letterData = LetterDiscovery.extractLetterDataStatic(content);
+
+        const letterCount = Object.keys(letterData).length;
+        const avgWordsPerLetter = letterCount > 0 ?
+            Object.values(letterData).reduce((sum, words) => sum + words.length, 0) / letterCount : 0;
+
+        // Dynamic percentage based on optimal volumes (2→8 letters, 3→4 words/letter)
+        // Letters: 0=0%, 4=50%, 8=100%
+        // Words per letter: 0=0%, 2=50%, 4=100%
+        const letterScore = Math.min(100, (letterCount / requirements.optimal.letters) * 100);
+        const wordsScore = Math.min(100, (avgWordsPerLetter / requirements.optimal.wordsPerLetter) * 100);
+
+        // Combined score (weighted average: 60% letters, 40% words per letter)
+        const finalScore = (letterScore * 0.6) + (wordsScore * 0.4);
+
+        const recommendations = [];
+        if (letterCount < requirements.optimal.letters) {
+            recommendations.push(`Add vocabulary for ${requirements.optimal.letters - letterCount} more letters`);
+        }
+        if (avgWordsPerLetter < requirements.optimal.wordsPerLetter) {
+            const wordsNeeded = Math.ceil((requirements.optimal.wordsPerLetter * letterCount) -
+                                        Object.values(letterData).reduce((sum, words) => sum + words.length, 0));
+            if (wordsNeeded > 0) {
+                recommendations.push(`Add ${wordsNeeded} more words for better letter coverage`);
+            }
+        }
+
+        return {
+            score: Math.round(finalScore),
+            details: {
+                letters: {
+                    found: letterCount,
+                    minimum: requirements.minimum.letters,
+                    optimal: requirements.optimal.letters,
+                    status: letterCount >= requirements.minimum.letters ? 'sufficient' : 'insufficient'
+                },
+                wordsPerLetter: {
+                    average: Math.round(avgWordsPerLetter * 10) / 10,
+                    minimum: requirements.minimum.wordsPerLetter,
+                    optimal: requirements.optimal.wordsPerLetter,
+                    status: avgWordsPerLetter >= requirements.minimum.wordsPerLetter ? 'sufficient' : 'insufficient'
+                }
+            },
+            recommendations: recommendations
+        };
+    }
+
+    static extractLetterDataStatic(content) {
+        const letterWords = {};
+
+        // Priority 1: Use raw module content (simple format)
+        if (content.rawContent) {
+            return LetterDiscovery.extractLetterDataFromRawStatic(content.rawContent);
+        }
+
+        // Priority 2: Ultra-modular format (vocabulary object) - ONLY format supported
+        if (content.vocabulary && typeof content.vocabulary === 'object' && !Array.isArray(content.vocabulary)) {
+            Object.entries(content.vocabulary).forEach(([word, data]) => {
+                let wordData;
+
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    wordData = {
+                        word: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    wordData = {
+                        word: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+
+                if (wordData && wordData.word && wordData.translation) {
+                    const firstLetter = wordData.word.charAt(0).toUpperCase();
+                    if (!letterWords[firstLetter]) {
+                        letterWords[firstLetter] = [];
+                    }
+                    letterWords[firstLetter].push(wordData);
+                }
+            });
+        }
+
+        return letterWords;
+    }
+
+    static extractLetterDataFromRawStatic(rawContent) {
+        const letterWords = {};
+
+        // Ultra-modular format (vocabulary object) - ONLY format supported
+        if (rawContent.vocabulary && typeof rawContent.vocabulary === 'object' && !Array.isArray(rawContent.vocabulary)) {
+            Object.entries(rawContent.vocabulary).forEach(([word, data]) => {
+                let wordData;
+
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    wordData = {
+                        word: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    wordData = {
+                        word: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+
+                if (wordData && wordData.word && wordData.translation) {
+                    const firstLetter = wordData.word.charAt(0).toUpperCase();
+                    if (!letterWords[firstLetter]) {
+                        letterWords[firstLetter] = [];
+                    }
+                    letterWords[firstLetter].push(wordData);
+                }
+            });
+        }
+
+        return letterWords;
+    }
 }
 
 // Register the game module

js/games/memory-match.js

@@ -488,6 +488,139 @@ class MemoryMatchGame {
     destroy() {
         this.container.innerHTML = '';
     }
+
+    // === COMPATIBILITY SYSTEM ===
+    static getCompatibilityRequirements() {
+        return {
+            minimum: {
+                vocabulary: 6
+            },
+            optimal: {
+                vocabulary: 15
+            },
+            name: "Memory Match",
+            description: "Needs vocabulary pairs for card matching (8 pairs optimal, 6 minimum)"
+        };
+    }
+
+    static checkContentCompatibility(content) {
+        const requirements = MemoryMatchGame.getCompatibilityRequirements();
+
+        // Extract vocabulary using same method as instance
+        const vocabulary = MemoryMatchGame.extractVocabularyStatic(content);
+        const vocabCount = vocabulary.length;
+
+        // Dynamic percentage based on optimal volume (6 min → 15 optimal)
+        // 0 words = 0%, 8 words = 53%, 15 words = 100%
+        const score = Math.min(100, (vocabCount / requirements.optimal.vocabulary) * 100);
+
+        return {
+            score: Math.round(score),
+            details: {
+                vocabulary: {
+                    found: vocabCount,
+                    minimum: requirements.minimum.vocabulary,
+                    optimal: requirements.optimal.vocabulary,
+                    status: vocabCount >= requirements.minimum.vocabulary ? 'sufficient' : 'insufficient'
+                }
+            },
+            recommendations: vocabCount < requirements.optimal.vocabulary ?
+                [`Add ${requirements.optimal.vocabulary - vocabCount} more vocabulary words for optimal experience`] :
+                []
+        };
+    }
+
+    static extractVocabularyStatic(content) {
+        let vocabulary = [];
+
+        // Use raw module content if available
+        if (content.rawContent) {
+            return MemoryMatchGame.extractVocabularyFromRawStatic(content.rawContent);
+        }
+
+        // Ultra-modular format (vocabulary object) - ONLY format supported
+        if (content.vocabulary && typeof content.vocabulary === 'object' && !Array.isArray(content.vocabulary)) {
+            vocabulary = Object.entries(content.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        original: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        original: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return MemoryMatchGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static extractVocabularyFromRawStatic(rawContent) {
+        let vocabulary = [];
+
+        // Ultra-modular format (vocabulary object) - ONLY format supported
+        if (rawContent.vocabulary && typeof rawContent.vocabulary === 'object' && !Array.isArray(rawContent.vocabulary)) {
+            vocabulary = Object.entries(rawContent.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        original: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        original: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return MemoryMatchGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static finalizeVocabularyStatic(vocabulary) {
+        // Filter and validate vocabulary for ultra-modular format
+        vocabulary = vocabulary.filter(item =>
+            item &&
+            typeof item.original === 'string' &&
+            typeof item.translation === 'string' &&
+            item.original.trim() !== '' &&
+            item.translation.trim() !== ''
+        );
+
+        return vocabulary;
+    }
 }
 
 // Module registration

js/games/quiz-game.js

@@ -522,6 +522,139 @@ class QuizGame {
     destroy() {
         this.container.innerHTML = '';
     }
+
+    // === COMPATIBILITY SYSTEM ===
+    static getCompatibilityRequirements() {
+        return {
+            minimum: {
+                vocabulary: 8
+            },
+            optimal: {
+                vocabulary: 16
+            },
+            name: "Quiz Game",
+            description: "Needs vocabulary with translations for multiple choice questions"
+        };
+    }
+
+    static checkContentCompatibility(content) {
+        const requirements = QuizGame.getCompatibilityRequirements();
+
+        // Extract vocabulary using same method as instance
+        const vocabulary = QuizGame.extractVocabularyStatic(content);
+        const vocabCount = vocabulary.length;
+
+        // Dynamic percentage based on optimal volume (8 min → 16 optimal)
+        // 0 words = 0%, 8 words = 50%, 16 words = 100%
+        const score = Math.min(100, (vocabCount / requirements.optimal.vocabulary) * 100);
+
+        return {
+            score: Math.round(score),
+            details: {
+                vocabulary: {
+                    found: vocabCount,
+                    minimum: requirements.minimum.vocabulary,
+                    optimal: requirements.optimal.vocabulary,
+                    status: vocabCount >= requirements.minimum.vocabulary ? 'sufficient' : 'insufficient'
+                }
+            },
+            recommendations: vocabCount < requirements.optimal.vocabulary ?
+                [`Add ${requirements.optimal.vocabulary - vocabCount} more vocabulary words for optimal experience`] :
+                []
+        };
+    }
+
+    static extractVocabularyStatic(content) {
+        let vocabulary = [];
+
+        // Priority 1: Use raw module content (simple format)
+        if (content.rawContent) {
+            return QuizGame.extractVocabularyFromRawStatic(content.rawContent);
+        }
+
+        // Priority 2: Ultra-modular format (vocabulary object) - ONLY format supported
+        if (content.vocabulary && typeof content.vocabulary === 'object' && !Array.isArray(content.vocabulary)) {
+            vocabulary = Object.entries(content.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        original: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        original: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return QuizGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static extractVocabularyFromRawStatic(rawContent) {
+        let vocabulary = [];
+
+        // Ultra-modular format (vocabulary object) - ONLY format supported
+        if (rawContent.vocabulary && typeof rawContent.vocabulary === 'object' && !Array.isArray(rawContent.vocabulary)) {
+            vocabulary = Object.entries(rawContent.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        original: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        original: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return QuizGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static finalizeVocabularyStatic(vocabulary) {
+        // Validation and cleanup for ultra-modular format
+        vocabulary = vocabulary.filter(word =>
+            word &&
+            typeof word.original === 'string' &&
+            typeof word.translation === 'string' &&
+            word.original.trim() !== '' &&
+            word.translation.trim() !== ''
+        );
+
+        return vocabulary;
+    }
 }
 
 // Module registration

js/games/river-run.js

@@ -964,6 +964,139 @@ class RiverRun {
             styleSheet.remove();
         }
     }
+
+    // === COMPATIBILITY SYSTEM ===
+    static getCompatibilityRequirements() {
+        return {
+            minimum: {
+                vocabulary: 10
+            },
+            optimal: {
+                vocabulary: 25
+            },
+            name: "River Run",
+            description: "Vocabulary collection game where player navigates river to collect target words"
+        };
+    }
+
+    static checkContentCompatibility(content) {
+        const requirements = RiverRun.getCompatibilityRequirements();
+
+        // Extract vocabulary using same method as instance
+        const vocabulary = RiverRun.extractVocabularyStatic(content);
+        const vocabCount = vocabulary.length;
+
+        // Dynamic percentage based on optimal volume (10 min → 25 optimal)
+        // 0 words = 0%, 12 words = 48%, 25 words = 100%
+        const score = Math.min(100, (vocabCount / requirements.optimal.vocabulary) * 100);
+
+        return {
+            score: Math.round(score),
+            details: {
+                vocabulary: {
+                    found: vocabCount,
+                    minimum: requirements.minimum.vocabulary,
+                    optimal: requirements.optimal.vocabulary,
+                    status: vocabCount >= requirements.minimum.vocabulary ? 'sufficient' : 'insufficient'
+                }
+            },
+            recommendations: vocabCount < requirements.optimal.vocabulary ?
+                [`Add ${requirements.optimal.vocabulary - vocabCount} more vocabulary words for optimal experience`] :
+                []
+        };
+    }
+
+    static extractVocabularyStatic(content) {
+        let vocabulary = [];
+
+        // Priority 1: Use raw module content (simple format)
+        if (content.rawContent) {
+            return RiverRun.extractVocabularyFromRawStatic(content.rawContent);
+        }
+
+        // Priority 2: Ultra-modular format (vocabulary object) - ONLY format supported
+        if (content.vocabulary && typeof content.vocabulary === 'object' && !Array.isArray(content.vocabulary)) {
+            vocabulary = Object.entries(content.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        word: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        word: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return RiverRun.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static extractVocabularyFromRawStatic(rawContent) {
+        let vocabulary = [];
+
+        // Ultra-modular format (vocabulary object) - ONLY format supported
+        if (rawContent.vocabulary && typeof rawContent.vocabulary === 'object' && !Array.isArray(rawContent.vocabulary)) {
+            vocabulary = Object.entries(rawContent.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        word: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        word: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return RiverRun.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static finalizeVocabularyStatic(vocabulary) {
+        // Validation and cleanup for ultra-modular format
+        vocabulary = vocabulary.filter(word =>
+            word &&
+            typeof word.word === 'string' &&
+            typeof word.translation === 'string' &&
+            word.word.trim() !== '' &&
+            word.translation.trim() !== ''
+        );
+
+        return vocabulary;
+    }
 }
 
 // Add CSS animations

js/games/story-builder.js

@@ -766,6 +766,36 @@ class StoryBuilderGame {
         this.endGame();
         this.container.innerHTML = '';
     }
+
+    // === COMPATIBILITY SYSTEM ===
+    static getCompatibilityRequirements() {
+        return {
+            minimum: {
+                // Story Builder is always 0% compatible - it's a mockup/prototype
+            },
+            optimal: {
+                // Story Builder is always 0% compatible - it's a mockup/prototype
+            },
+            name: "Story Builder",
+            description: "Interactive story construction game (prototype - not yet tested)"
+        };
+    }
+
+    static checkContentCompatibility(content) {
+        // Story Builder always returns 0% compatibility as specified
+        // This is a mockup/prototype that hasn't been thoroughly tested
+        return {
+            score: 0,
+            details: {
+                status: 'prototype',
+                reason: 'Story Builder is a prototype feature not yet ready for production use'
+            },
+            recommendations: [
+                "Story Builder is in development and not available for use yet",
+                "Please choose other games while this feature is being completed"
+            ]
+        };
+    }
 }
 
 // CSS pour Story Builder

js/games/story-reader.js

@@ -1359,6 +1359,135 @@ class StoryReader {
         }
         this.container.innerHTML = '';
     }
+
+    // === COMPATIBILITY SYSTEM ===
+    static getCompatibilityRequirements() {
+        return {
+            minimum: {
+                texts: 1
+            },
+            optimal: {
+                texts: 1,
+                stories: 1
+            },
+            name: "Story Reader",
+            description: "Needs text content or stories for guided reading experience"
+        };
+    }
+
+    static checkContentCompatibility(content) {
+        const requirements = StoryReader.getCompatibilityRequirements();
+
+        // Extract texts and stories using same method as instance
+        const texts = StoryReader.extractTextsStatic(content);
+        const stories = StoryReader.extractStoriesStatic(content);
+
+        const textCount = texts.length;
+        const storyCount = stories.length;
+        const totalContent = textCount + storyCount;
+
+        // Dynamic percentage based on content quality (1 text min → 1 story optimal)
+        // Stories are much better than texts for reading experience
+        let score = 0;
+        if (storyCount >= 1) {
+            score = 100;  // Perfect: has stories
+        } else if (textCount >= 3) {
+            score = 75;   // Good: multiple texts
+        } else if (textCount >= 1) {
+            score = 50;   // Basic: at least one text
+        } else {
+            score = 0;    // No content
+        }
+
+        const recommendations = [];
+        if (totalContent === 0) {
+            recommendations.push("Add text content or stories for reading");
+        } else if (storyCount === 0) {
+            recommendations.push("Add story content for optimal reading experience");
+        }
+
+        return {
+            score: Math.round(score),
+            details: {
+                texts: {
+                    found: textCount,
+                    minimum: requirements.minimum.texts,
+                    status: textCount >= requirements.minimum.texts ? 'sufficient' : 'insufficient'
+                },
+                stories: {
+                    found: storyCount,
+                    optimal: requirements.optimal.stories,
+                    status: storyCount >= requirements.optimal.stories ? 'available' : 'missing'
+                }
+            },
+            recommendations: recommendations
+        };
+    }
+
+    static extractTextsStatic(content) {
+        let texts = [];
+
+        // Priority 1: Use raw module content
+        if (content.rawContent) {
+            // Extract from texts array
+            if (content.rawContent.texts && Array.isArray(content.rawContent.texts)) {
+                texts.push(...content.rawContent.texts);
+            }
+        }
+
+        // Priority 2: Direct content properties
+        if (content.texts && Array.isArray(content.texts)) {
+            texts.push(...content.texts);
+        }
+
+        // Filter valid texts
+        texts = texts.filter(text =>
+            text &&
+            typeof text === 'object' &&
+            text.content &&
+            typeof text.content === 'string' &&
+            text.content.trim().length > 10
+        );
+
+        return texts;
+    }
+
+    static extractStoriesStatic(content) {
+        let stories = [];
+
+        // Priority 1: Use raw module content
+        if (content.rawContent) {
+            // Extract from story object
+            if (content.rawContent.story && content.rawContent.story.chapters) {
+                stories.push(content.rawContent.story);
+            }
+
+            // Extract from additionalStories array
+            if (content.rawContent.additionalStories && Array.isArray(content.rawContent.additionalStories)) {
+                stories.push(...content.rawContent.additionalStories);
+            }
+        }
+
+        // Priority 2: Direct content properties
+        if (content.story && content.story.chapters) {
+            stories.push(content.story);
+        }
+
+        if (content.additionalStories && Array.isArray(content.additionalStories)) {
+            stories.push(...content.additionalStories);
+        }
+
+        // Filter valid stories
+        stories = stories.filter(story =>
+            story &&
+            typeof story === 'object' &&
+            story.chapters &&
+            Array.isArray(story.chapters) &&
+            story.chapters.length > 0
+        );
+
+        return stories;
+    }
 }
 
 // Module registration

js/games/whack-a-mole-hard.js

@@ -696,6 +696,139 @@ class WhackAMoleHardGame {
         this.stop();
         this.container.innerHTML = '';
     }
+
+    // === COMPATIBILITY SYSTEM ===
+    static getCompatibilityRequirements() {
+        return {
+            minimum: {
+                vocabulary: 12
+            },
+            optimal: {
+                vocabulary: 25
+            },
+            name: "Whack-a-Mole Hard",
+            description: "Hard mode requires more vocabulary words for increased difficulty (3 moles at once)"
+        };
+    }
+
+    static checkContentCompatibility(content) {
+        const requirements = WhackAMoleHardGame.getCompatibilityRequirements();
+
+        // Extract vocabulary using same method as instance
+        const vocabulary = WhackAMoleHardGame.extractVocabularyStatic(content);
+        const vocabCount = vocabulary.length;
+
+        // Dynamic percentage based on optimal volume (12 min → 25 optimal)
+        // 0 words = 0%, 12 words = 48%, 25 words = 100%
+        const score = Math.min(100, (vocabCount / requirements.optimal.vocabulary) * 100);
+
+        return {
+            score: Math.round(score),
+            details: {
+                vocabulary: {
+                    found: vocabCount,
+                    minimum: requirements.minimum.vocabulary,
+                    optimal: requirements.optimal.vocabulary,
+                    status: vocabCount >= requirements.minimum.vocabulary ? 'sufficient' : 'insufficient'
+                }
+            },
+            recommendations: vocabCount < requirements.optimal.vocabulary ?
+                [`Add ${requirements.optimal.vocabulary - vocabCount} more vocabulary words for optimal experience`] :
+                []
+        };
+    }
+
+    static extractVocabularyStatic(content) {
+        let vocabulary = [];
+
+        // Priority 1: Use raw module content (simple format)
+        if (content.rawContent) {
+            return WhackAMoleHardGame.extractVocabularyFromRawStatic(content.rawContent);
+        }
+
+        // Priority 2: Ultra-modular format (vocabulary object) - ONLY format supported
+        if (content.vocabulary && typeof content.vocabulary === 'object' && !Array.isArray(content.vocabulary)) {
+            vocabulary = Object.entries(content.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        original: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        original: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return WhackAMoleHardGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static extractVocabularyFromRawStatic(rawContent) {
+        let vocabulary = [];
+
+        // Ultra-modular format (vocabulary object) - ONLY format supported
+        if (rawContent.vocabulary && typeof rawContent.vocabulary === 'object' && !Array.isArray(rawContent.vocabulary)) {
+            vocabulary = Object.entries(rawContent.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        original: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        original: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return WhackAMoleHardGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static finalizeVocabularyStatic(vocabulary) {
+        // Validation and cleanup for ultra-modular format
+        vocabulary = vocabulary.filter(word =>
+            word &&
+            typeof word.original === 'string' &&
+            typeof word.translation === 'string' &&
+            word.original.trim() !== '' &&
+            word.translation.trim() !== ''
+        );
+
+        return vocabulary;
+    }
 }
 
 // Module registration

js/games/whack-a-mole.js

@@ -1,6 +1,36 @@
 // === MODULE WHACK-A-MOLE ===
 
 class WhackAMoleGame {
+    // === EMBEDDED COMPATIBILITY SYSTEM ===
+    static getCompatibilityRequirements() {
+        return {
+            minimum: { vocabulary: 8 },
+            optimal: { vocabulary: 20 },
+            name: "Whack-a-Mole",
+            description: "Needs vocabulary words with translations for mole targets"
+        };
+    }
+
+
+    static extractVocabularyStatic(content) {
+        // Static version of vocabulary extraction for compatibility checking
+        let vocabulary = [];
+
+        if (content.rawContent?.vocabulary) {
+            vocabulary = Object.entries(content.rawContent.vocabulary).map(([word, data]) => ({
+                original: word,
+                translation: typeof data === 'string' ? data : data.user_language || data.translation
+            })).filter(item => item.translation);
+        } else if (content.vocabulary) {
+            vocabulary = Object.entries(content.vocabulary).map(([word, data]) => ({
+                original: word,
+                translation: typeof data === 'string' ? data : data.user_language || data.translation
+            })).filter(item => item.translation);
+        }
+
+        return vocabulary;
+    }
+
     constructor(options) {
         this.container = options.container;
         this.content = options.content;
@@ -678,6 +708,144 @@ class WhackAMoleGame {
         this.stop();
         this.container.innerHTML = '';
     }
+
+    // === COMPATIBILITY SYSTEM ===
+    static getCompatibilityRequirements() {
+        return {
+            minimum: {
+                vocabulary: 8
+            },
+            optimal: {
+                vocabulary: 20
+            },
+            name: "Whack-a-Mole",
+            description: "Needs vocabulary words with translations for mole targets"
+        };
+    }
+
+    static checkContentCompatibility(content) {
+        const requirements = WhackAMoleGame.getCompatibilityRequirements();
+
+        // Extract vocabulary using same method as instance
+        const vocabulary = WhackAMoleGame.extractVocabularyStatic(content);
+        const vocabCount = vocabulary.length;
+
+        // Dynamic percentage based on optimal volume (8 min → 20 optimal)
+        // 0 words = 0%, 10 words = 50%, 20 words = 100%
+        const score = Math.min(100, (vocabCount / requirements.optimal.vocabulary) * 100);
+
+        // DEBUG: Log calculation details
+        console.log(`🔍 WhackAMole DEBUG - Content: ${content.name || 'Unknown'}`);
+        console.log(`📊 Vocab found: ${vocabCount}, Min: ${requirements.minimum.vocabulary}, Optimal: ${requirements.optimal.vocabulary}`);
+        console.log(`🧮 Calculation: (${vocabCount} / ${requirements.optimal.vocabulary}) * 100 = ${score}`);
+
+        return {
+            score: Math.round(score),
+            details: {
+                vocabulary: {
+                    found: vocabCount,
+                    minimum: requirements.minimum.vocabulary,
+                    optimal: requirements.optimal.vocabulary,
+                    status: vocabCount >= requirements.minimum.vocabulary ? 'sufficient' : 'insufficient'
+                }
+            },
+            recommendations: vocabCount < requirements.optimal.vocabulary ?
+                [`Add ${requirements.optimal.vocabulary - vocabCount} more vocabulary words for optimal experience`] :
+                []
+        };
+    }
+
+    static extractVocabularyStatic(content) {
+        let vocabulary = [];
+
+        // Priority 1: Use raw module content (simple format)
+        if (content.rawContent) {
+            return WhackAMoleGame.extractVocabularyFromRawStatic(content.rawContent);
+        }
+
+        // Priority 2: Ultra-modular format (vocabulary object) - ONLY format supported
+        if (content.vocabulary && typeof content.vocabulary === 'object' && !Array.isArray(content.vocabulary)) {
+            vocabulary = Object.entries(content.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        original: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        original: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return WhackAMoleGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static extractVocabularyFromRawStatic(rawContent) {
+        let vocabulary = [];
+
+        // Ultra-modular format (vocabulary object) - ONLY format supported
+        if (rawContent.vocabulary && typeof rawContent.vocabulary === 'object' && !Array.isArray(rawContent.vocabulary)) {
+            vocabulary = Object.entries(rawContent.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        original: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        original: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return WhackAMoleGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static finalizeVocabularyStatic(vocabulary) {
+        // Validation and cleanup for ultra-modular format
+        vocabulary = vocabulary.filter(word =>
+            word &&
+            typeof word.original === 'string' &&
+            typeof word.translation === 'string' &&
+            word.original.trim() !== '' &&
+            word.translation.trim() !== ''
+        );
+
+        return vocabulary;
+    }
 }
 
 // Module registration

js/games/word-discovery.js

@@ -1039,6 +1039,155 @@ class WordDiscovery {
             styleSheet.remove();
         }
     }
+
+    // === COMPATIBILITY SYSTEM ===
+    static getCompatibilityRequirements() {
+        return {
+            minimum: {
+                vocabulary: 10
+            },
+            optimal: {
+                vocabulary: 20
+            },
+            name: "Word Discovery",
+            description: "Progressive vocabulary learning with discovery and practice phases"
+        };
+    }
+
+    static checkContentCompatibility(content) {
+        const requirements = WordDiscovery.getCompatibilityRequirements();
+
+        // Extract vocabulary using same method as instance
+        const vocabulary = WordDiscovery.extractVocabularyStatic(content);
+        const vocabCount = vocabulary.length;
+
+        // Dynamic percentage based on optimal volume (10 min → 20 optimal)
+        // 0 words = 0%, 10 words = 50%, 20 words = 100%
+        const score = Math.min(100, (vocabCount / requirements.optimal.vocabulary) * 100);
+
+        const recommendations = [];
+        if (vocabCount < requirements.optimal.vocabulary) {
+            recommendations.push(`Add ${requirements.optimal.vocabulary - vocabCount} more vocabulary words for optimal experience`);
+        }
+
+        // Count multimedia features for bonus recommendations
+        const hasImages = vocabulary.some(word => word.image);
+        const hasAudio = vocabulary.some(word => word.audioFile || word.pronunciation);
+
+        if (!hasImages) {
+            recommendations.push("Add images to vocabulary for visual learning challenges");
+        }
+        if (!hasAudio) {
+            recommendations.push("Add audio files or pronunciation guides for audio challenges");
+        }
+
+        return {
+            score: Math.round(score),
+            details: {
+                vocabulary: {
+                    found: vocabCount,
+                    minimum: requirements.minimum.vocabulary,
+                    optimal: requirements.optimal.vocabulary,
+                    status: vocabCount >= requirements.minimum.vocabulary ? 'sufficient' : 'insufficient'
+                },
+                multimedia: {
+                    images: hasImages ? 'available' : 'missing',
+                    audio: hasAudio ? 'available' : 'missing'
+                }
+            },
+            recommendations: recommendations
+        };
+    }
+
+    static extractVocabularyStatic(content) {
+        let vocabulary = [];
+
+        // Priority 1: Use raw module content (simple format)
+        if (content.rawContent) {
+            return WordDiscovery.extractVocabularyFromRawStatic(content.rawContent);
+        }
+
+        // Priority 2: Ultra-modular format (vocabulary object) - ONLY format supported
+        if (content.vocabulary && typeof content.vocabulary === 'object' && !Array.isArray(content.vocabulary)) {
+            vocabulary = Object.entries(content.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        word: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        image: data.image,
+                        audioFile: data.audio,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        word: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return WordDiscovery.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static extractVocabularyFromRawStatic(rawContent) {
+        let vocabulary = [];
+
+        // Ultra-modular format (vocabulary object) - ONLY format supported
+        if (rawContent.vocabulary && typeof rawContent.vocabulary === 'object' && !Array.isArray(rawContent.vocabulary)) {
+            vocabulary = Object.entries(rawContent.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        word: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        image: data.image,
+                        audioFile: data.audio,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        word: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return WordDiscovery.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static finalizeVocabularyStatic(vocabulary) {
+        // Validation and cleanup for ultra-modular format
+        vocabulary = vocabulary.filter(word =>
+            word &&
+            typeof word.word === 'string' &&
+            typeof word.translation === 'string' &&
+            word.word.trim() !== '' &&
+            word.translation.trim() !== ''
+        );
+
+        return vocabulary;
+    }
 }
 
 // Register the game module

js/games/word-storm.js

@@ -649,6 +649,149 @@ class WordStormGame {
 
         logSh('Word Storm destroyed', 'INFO');
     }
+
+    // === COMPATIBILITY SYSTEM ===
+    static getCompatibilityRequirements() {
+        return {
+            minimum: {
+                vocabulary: 8
+            },
+            optimal: {
+                vocabulary: 20
+            },
+            name: "Word Storm",
+            description: "Fast-paced vocabulary game with falling words to catch"
+        };
+    }
+
+    static checkContentCompatibility(content) {
+        const requirements = WordStormGame.getCompatibilityRequirements();
+
+        // DEBUG: Log content structure
+        console.log(`🔍 WordStorm DEBUG - Content received:`, content);
+        console.log(`🔍 WordStorm DEBUG - Content vocabulary:`, content.vocabulary);
+
+        // Extract vocabulary using same method as instance
+        const vocabulary = WordStormGame.extractVocabularyStatic(content);
+        const vocabCount = vocabulary.length;
+
+        // DEBUG: Log extraction results
+        console.log(`🔍 WordStorm DEBUG - Extracted vocabulary:`, vocabulary);
+        console.log(`🔍 WordStorm DEBUG - Vocab count: ${vocabCount}, Requirements:`, requirements);
+
+        // Dynamic percentage based on optimal volume (8 min → 20 optimal)
+        // 0 words = 0%, 10 words = 50%, 20 words = 100%
+        const score = Math.min(100, (vocabCount / requirements.optimal.vocabulary) * 100);
+
+        console.log(`🔍 WordStorm DEBUG - Final score: ${score}%`);
+
+        return {
+            score: Math.round(score),
+            details: {
+                vocabulary: {
+                    found: vocabCount,
+                    minimum: requirements.minimum.vocabulary,
+                    optimal: requirements.optimal.vocabulary,
+                    status: vocabCount >= requirements.minimum.vocabulary ? 'sufficient' : 'insufficient'
+                }
+            },
+            recommendations: vocabCount < requirements.optimal.vocabulary ?
+                [`Add ${requirements.optimal.vocabulary - vocabCount} more vocabulary words for optimal experience`] :
+                []
+        };
+    }
+
+    static extractVocabularyStatic(content) {
+        let vocabulary = [];
+
+        // Priority 1: Use raw module content (simple format)
+        if (content.rawContent) {
+            return WordStormGame.extractVocabularyFromRawStatic(content.rawContent);
+        }
+
+        // Priority 2: Ultra-modular format (vocabulary object) - ONLY format supported
+        if (content.vocabulary && typeof content.vocabulary === 'object' && !Array.isArray(content.vocabulary)) {
+            vocabulary = Object.entries(content.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        word: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        word: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return WordStormGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static extractVocabularyFromRawStatic(rawContent) {
+        let vocabulary = [];
+
+        // Ultra-modular format (vocabulary object) - ONLY format supported
+        if (rawContent.vocabulary && typeof rawContent.vocabulary === 'object' && !Array.isArray(rawContent.vocabulary)) {
+            vocabulary = Object.entries(rawContent.vocabulary).map(([word, data]) => {
+                // Support ultra-modular format ONLY
+                if (typeof data === 'object' && data.user_language) {
+                    return {
+                        word: word,
+                        translation: data.user_language.split('；')[0],
+                        fullTranslation: data.user_language,
+                        type: data.type || 'general',
+                        audio: data.audio,
+                        image: data.image,
+                        examples: data.examples,
+                        pronunciation: data.pronunciation,
+                        category: data.type || 'general'
+                    };
+                }
+                // Legacy fallback - simple string (temporary, will be removed)
+                else if (typeof data === 'string') {
+                    return {
+                        word: word,
+                        translation: data.split('；')[0],
+                        fullTranslation: data,
+                        type: 'general',
+                        category: 'general'
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+        }
+
+        return WordStormGame.finalizeVocabularyStatic(vocabulary);
+    }
+
+    static finalizeVocabularyStatic(vocabulary) {
+        // Validation and cleanup for ultra-modular format
+        vocabulary = vocabulary.filter(word =>
+            word &&
+            typeof word.word === 'string' &&
+            typeof word.translation === 'string' &&
+            word.word.trim() !== '' &&
+            word.translation.trim() !== ''
+        );
+
+        return vocabulary;
+    }
 }
 
 // Export to global namespace