feat: implement batch API processing for both passages

- Add processBothPassages method to handle both passages in single API call
- Preprocess word selection and contextualization for both passages upfront
- Reduce API calls from 4 to 1 per round to avoid rate limits
- Add fallback to sequential processing if batch fails
- Improve user experience with faster passage loading

src/aiService.js

@@ -183,6 +183,75 @@ Passage: "${passage}"`
     }
   }
 
+  async processBothPassages(passage1, book1, passage2, book2, blanksPerPassage) {
+    // Process both passages in a single API call to avoid rate limits
+    const currentKey = this.getApiKey();
+    if (currentKey && !this.apiKey) {
+      this.apiKey = currentKey;
+    }
+    
+    if (!this.apiKey) {
+      throw new Error('API key required for passage processing');
+    }
+
+    try {
+      const response = await fetch(this.apiUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`,
+          'HTTP-Referer': window.location.origin,
+          'X-Title': 'Cloze Reader'
+        },
+        body: JSON.stringify({
+          model: this.model,
+          messages: [{
+            role: 'system',
+            content: 'Process two passages for a cloze reading exercise. For each passage: 1) Select words for blanks, 2) Generate a contextual introduction. Return a JSON object with both passages\' data.'
+          }, {
+            role: 'user',
+            content: `Process these two passages for cloze exercises:
+
+PASSAGE 1:
+Title: "${book1.title}" by ${book1.author}
+Text: "${passage1}"
+Select ${blanksPerPassage} words for blanks.
+
+PASSAGE 2:
+Title: "${book2.title}" by ${book2.author}
+Text: "${passage2}"
+Select ${blanksPerPassage} words for blanks.
+
+For each passage return:
+- "words": array of selected words (exactly as they appear)
+- "context": one-sentence intro about the book/author
+
+Return as JSON: {"passage1": {...}, "passage2": {...}}`
+          }],
+          max_tokens: 500,
+          temperature: 0.3
+        })
+      });
+
+      if (!response.ok) {
+        throw new Error(`API request failed: ${response.status}`);
+      }
+
+      const data = await response.json();
+      const content = data.choices[0].message.content.trim();
+      
+      try {
+        return JSON.parse(content);
+      } catch (e) {
+        console.error('Failed to parse batch response:', e);
+        throw new Error('Invalid API response format');
+      }
+    } catch (error) {
+      console.error('Error processing passages:', error);
+      throw error;
+    }
+  }
+
   async generateContextualization(title, author) {
     console.log('generateContextualization called for:', title, 'by', author);
     

src/clozeGameEngine.js

@@ -51,17 +51,33 @@ class ClozeGame {
       this.passages = [passage1.trim(), passage2.trim()];
       this.currentPassageIndex = 0;
       
-      // Start with the first passage
-      this.currentBook = book1;
-      this.originalText = this.passages[0];
+      // Calculate blanks per passage based on level
+      const blanksPerPassage = Math.min(this.currentLevel + 2, 5);
       
-      // Run AI calls sequentially to avoid rate limiting
-      await this.createClozeText();
-      
-      // Add small delay between API calls to avoid rate limiting
-      await new Promise(resolve => setTimeout(resolve, 1000));
-      
-      await this.generateContextualization();
+      // Process both passages in a single API call
+      try {
+        const batchResult = await aiService.processBothPassages(
+          passage1, book1, passage2, book2, blanksPerPassage
+        );
+        
+        // Store the preprocessed data for both passages
+        this.preprocessedData = batchResult;
+        
+        // Set up first passage using preprocessed data
+        this.currentBook = book1;
+        this.originalText = this.passages[0];
+        await this.createClozeTextFromPreprocessed(0);
+        this.contextualization = this.preprocessedData.passage1.context;
+        
+      } catch (error) {
+        console.warn('Batch processing failed, falling back to sequential:', error);
+        // Fallback to sequential processing
+        this.currentBook = book1;
+        this.originalText = this.passages[0];
+        await this.createClozeText();
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await this.generateContextualization();
+      }
       
       return {
         title: this.currentBook.title,
@@ -159,6 +175,66 @@ class ClozeGame {
     return passage.trim();
   }
 
+  async createClozeTextFromPreprocessed(passageIndex) {
+    // Use preprocessed word selection from batch API call
+    const preprocessed = passageIndex === 0 ? this.preprocessedData.passage1 : this.preprocessedData.passage2;
+    const selectedWords = preprocessed.words;
+    
+    // Split passage into words
+    const words = this.originalText.split(/(\s+)/);
+    const wordsOnly = words.filter(w => w.trim() !== '');
+    
+    // Find indices of selected words
+    const selectedIndices = [];
+    selectedWords.forEach(word => {
+      const index = wordsOnly.findIndex((w, idx) => 
+        w.toLowerCase().includes(word.toLowerCase()) && !selectedIndices.includes(idx)
+      );
+      if (index !== -1) {
+        selectedIndices.push(index);
+      }
+    });
+    
+    // Create blanks
+    this.blanks = [];
+    this.hints = [];
+    const clozeWords = [...wordsOnly];
+    
+    selectedIndices.forEach((wordIndex, blankIndex) => {
+      const originalWord = wordsOnly[wordIndex];
+      const cleanWord = originalWord.replace(/[^\w]/g, '');
+      
+      this.blanks.push({
+        index: blankIndex,
+        originalWord: cleanWord,
+        wordIndex: wordIndex
+      });
+      
+      // Generate structural hint
+      const hint = this.currentLevel <= 2
+        ? `${cleanWord.length} letters, starts with "${cleanWord[0]}", ends with "${cleanWord[cleanWord.length - 1]}"`
+        : `${cleanWord.length} letters, starts with "${cleanWord[0]}"`;
+      this.hints.push({ index: blankIndex, hint });
+      
+      // Replace with placeholder
+      clozeWords[wordIndex] = `___BLANK_${blankIndex}___`;
+    });
+    
+    // Reconstruct text with original spacing
+    let reconstructed = '';
+    let wordIndex = 0;
+    words.forEach(part => {
+      if (part.trim() === '') {
+        reconstructed += part;
+      } else {
+        reconstructed += clozeWords[wordIndex++];
+      }
+    });
+    
+    this.clozeText = reconstructed;
+    this.userAnswers = new Array(this.blanks.length).fill('');
+  }
+
   async createClozeText() {
     const words = this.originalText.split(' ');
     // Progressive difficulty: levels 1-2 = 1 blank, levels 3-4 = 2 blanks, level 5+ = 3 blanks
@@ -511,13 +587,16 @@ class ClozeGame {
         // Clear last results
         this.lastResults = null;
         
-        // Generate new cloze text and contextualization for second passage sequentially
-        await this.createClozeText();
-        
-        // Add small delay between API calls to avoid rate limiting
-        await new Promise(resolve => setTimeout(resolve, 1000));
-        
-        await this.generateContextualization();
+        // Use preprocessed data if available
+        if (this.preprocessedData && this.preprocessedData.passage2) {
+          await this.createClozeTextFromPreprocessed(1);
+          this.contextualization = this.preprocessedData.passage2.context;
+        } else {
+          // Fallback to sequential processing
+          await this.createClozeText();
+          await new Promise(resolve => setTimeout(resolve, 1000));
+          await this.generateContextualization();
+        }
         
         return {
           title: this.currentBook.title,