Upload 41 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Halgakos.ico filter=lfs diff=lfs merge=lfs -text

ai_hunter_enhanced.py

@@ -0,0 +1,1385 @@
+# ai_hunter_enhanced.py
+# Combined AI Hunter configuration GUI and detection logic
+
+import tkinter as tk
+from tkinter import ttk
+import ttkbootstrap as tb
+import json
+import os
+import re
+import unicodedata
+from difflib import SequenceMatcher
+from collections import Counter
+
+class AIHunterConfigGUI:
+    """GUI for configuring AI Hunter detection parameters"""
+    def __init__(self, parent, config_dict, callback=None):
+        """
+        Initialize with reference to main config dictionary
+        
+        Args:
+            parent: Parent window
+            config_dict: Reference to main translator config dictionary
+            callback: Function to call after saving
+        """
+        self.parent = parent
+        self.config = config_dict  # Reference to main config
+        self.callback = callback
+        self.window = None
+        
+        # Default AI Hunter settings structure
+        self.default_ai_hunter = {
+            'enabled': True,
+            'ai_hunter_max_workers': 1,
+            'retry_attempts': 6,
+            'disable_temperature_change': False,
+            'sample_size': 3000,
+            'thresholds': {
+                'exact': 90,
+                'text': 35,
+                'semantic': 85,
+                'structural': 85,
+                'character': 90,
+                'pattern': 80
+            },
+            'weights': {
+                'exact': 1.5,
+                'text': 1.2,
+                'semantic': 1.0,
+                'structural': 1.0,
+                'character': 0.8,
+                'pattern': 0.8
+            },
+            'detection_mode': 'weighted_average',
+            'multi_method_requirements': {
+                'methods_required': 3,
+                'min_methods': ['semantic', 'structural']
+            },
+            'preprocessing': {
+                'remove_html_spacing': True,
+                'normalize_unicode': True,
+                'ignore_case': True,
+                'remove_extra_whitespace': True
+            },
+            'edge_filters': {
+                'min_text_length': 500,
+                'max_length_ratio': 1.3,
+                'min_length_ratio': 0.7
+            },
+            'language_detection': {
+                'enabled': False,
+                'target_language': 'english',
+                'threshold_characters': 500,
+                'languages': {
+                    'english': ['en'],
+                    'japanese': ['ja', 'jp'],
+                    'korean': ['ko', 'kr'],
+                    'chinese': ['zh', 'zh-cn', 'zh-tw'],
+                    'spanish': ['es'],
+                    'french': ['fr'],
+                    'german': ['de'],
+                    'russian': ['ru'],
+                    'arabic': ['ar'],
+                    'hindi': ['hi'],
+                    'portuguese': ['pt'],
+                    'italian': ['it'],
+                    'dutch': ['nl'],
+                    'thai': ['th'],
+                    'vietnamese': ['vi'],
+                    'turkish': ['tr'],
+                    'polish': ['pl'],
+                    'swedish': ['sv'],
+                    'danish': ['da'],
+                    'norwegian': ['no'],
+                    'finnish': ['fi']
+                }
+            }
+        }
+        
+        # Initialize AI Hunter config in main config if not present
+        if 'ai_hunter_config' not in self.config:
+            self.config['ai_hunter_config'] = self.default_ai_hunter.copy()
+        else:
+            # Merge with defaults to ensure all keys exist
+            self.config['ai_hunter_config'] = self._merge_configs(
+                self.default_ai_hunter, 
+                self.config['ai_hunter_config']
+            )
+    
+    def _merge_configs(self, default, existing):
+        """Recursively merge existing config with defaults"""
+        result = default.copy()
+        for key, value in existing.items():
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = self._merge_configs(result[key], value)
+            else:
+                result[key] = value
+        return result
+    
+    def get_ai_config(self):
+        """Get AI Hunter configuration from main config"""
+        return self.config.get('ai_hunter_config', self.default_ai_hunter)
+    
+    def show_ai_hunter_config(self):
+        """Display the AI Hunter configuration window with scrollbar using WindowManager"""
+        if self.window and self.window.winfo_exists():
+            self.window.lift()
+            return
+        
+        # Import WindowManager if not already available
+        if not hasattr(self, 'wm'):
+            from translator_gui import WindowManager
+            import sys
+            import os
+            base_dir = getattr(sys, '_MEIPASS', os.path.dirname(os.path.abspath(__file__)))
+            self.wm = WindowManager(base_dir)
+        
+        # Create scrollable dialog using WindowManager
+        dialog, scrollable_frame, canvas = self.wm.setup_scrollable(
+            self.parent,
+            "AI Hunter Configuration",
+            width=820,
+            height=None,  # Will use default height
+            max_width_ratio=0.9,
+            max_height_ratio=0.85
+        )
+        
+        self.window = dialog
+        
+        # Create notebook inside scrollable frame
+        notebook = ttk.Notebook(scrollable_frame)
+        notebook.pack(fill='both', expand=True, padx=10, pady=10)
+        
+        # Tab 1: Detection Thresholds
+        self.create_thresholds_tab(notebook)
+        
+        # Tab 2: Detection Mode
+        self.create_mode_tab(notebook)
+        
+        # Tab 3: Preprocessing
+        self.create_preprocessing_tab(notebook)
+        
+        # Tab 4: Advanced Settings
+        self.create_advanced_tab(notebook)
+        
+        # Buttons at the bottom (inside scrollable frame)
+        button_frame = tk.Frame(scrollable_frame)
+        button_frame.pack(fill='x', padx=10, pady=(10, 20))
+        
+        tb.Button(button_frame, text="Save", command=self.apply_ai_hunter_settings, 
+                 bootstyle="success").pack(side='right', padx=5)
+        tb.Button(button_frame, text="Cancel", command=self.window.destroy,
+                 bootstyle="secondary").pack(side='right')
+        tb.Button(button_frame, text="Reset to Defaults", command=self.reset_defaults,
+                 bootstyle="warning").pack(side='left')
+        
+        # Auto-resize and show
+        self.wm.auto_resize_dialog(dialog, canvas, max_width_ratio=0.9, max_height_ratio=1.1)
+        
+        # Handle window close
+        dialog.protocol("WM_DELETE_WINDOW", lambda: [dialog._cleanup_scrolling(), dialog.destroy()])
+    
+    def create_thresholds_tab(self, notebook):
+        """Create the thresholds configuration tab"""
+        frame = ttk.Frame(notebook)
+        notebook.add(frame, text="Detection Thresholds")
+        
+        # Title
+        tk.Label(frame, text="Detection Method Thresholds", 
+                font=('TkDefaultFont', 12, 'bold')).pack(pady=10)
+        
+        tk.Label(frame, text="Higher values = fewer false positives (more strict)\n"
+                           "Lower values = more false positives (more sensitive)",
+                font=('TkDefaultFont', 10), fg='gray').pack(pady=(0, 20))
+        
+        # Threshold controls
+        self.threshold_vars = {}
+        threshold_frame = tk.Frame(frame)
+        threshold_frame.pack(fill='both', expand=True, padx=20)
+        
+        descriptions = {
+            'exact': 'Exact Text Match - Direct character-by-character comparison',
+            'text': 'Smart Text Similarity - Intelligent text comparison with sampling',
+            'semantic': 'Semantic Analysis - Character names, dialogue patterns, numbers',
+            'structural': 'Structural Patterns - Paragraph structure, dialogue distribution',
+            'character': 'Character Overlap - Common character names between chapters',
+            'pattern': 'Pattern Analysis - Narrative flow and structure patterns'
+        }
+        
+        ai_config = self.get_ai_config()
+        
+        for method, desc in descriptions.items():
+            method_frame = tk.Frame(threshold_frame)
+            method_frame.pack(fill='x', pady=10)
+            
+            # Method name and description
+            label_frame = tk.Frame(method_frame)
+            label_frame.pack(fill='x')
+            
+            tk.Label(label_frame, text=f"{method.title()}:", 
+                    font=('TkDefaultFont', 10, 'bold')).pack(side='left')
+            tk.Label(label_frame, text=f" {desc}",
+                    font=('TkDefaultFont', 9), fg='gray').pack(side='left', padx=(10, 0))
+            
+            # Slider and value
+            slider_frame = tk.Frame(method_frame)
+            slider_frame.pack(fill='x', pady=(5, 0))
+            
+            self.threshold_vars[method] = tk.IntVar(value=ai_config['thresholds'][method])
+            
+            slider = tb.Scale(slider_frame, from_=10, to=100, 
+                            variable=self.threshold_vars[method],
+                            bootstyle="info", length=400)
+            slider.pack(side='left', padx=(20, 10))
+            
+            value_label = tk.Label(slider_frame, text="", width=4)
+            value_label.pack(side='left')
+            
+            # Update label when slider changes
+            def update_label(val, label=value_label, var=self.threshold_vars[method]):
+                label.config(text=f"{int(var.get())}%")
+            
+            self.threshold_vars[method].trace('w', lambda *args, f=update_label: f(None))
+            update_label(None)
+        
+        # Weight configuration
+        tk.Label(frame, text="Method Weights (for weighted average mode)", 
+                font=('TkDefaultFont', 11, 'bold')).pack(pady=(30, 10))
+        
+        self.weight_vars = {}
+        weight_frame = tk.Frame(frame)
+        weight_frame.pack(fill='x', padx=20)
+        
+        for method in descriptions.keys():
+            w_frame = tk.Frame(weight_frame)
+            w_frame.pack(fill='x', pady=5)
+            
+            tk.Label(w_frame, text=f"{method.title()} weight:", width=20, 
+                    anchor='w').pack(side='left')
+            
+            self.weight_vars[method] = tk.DoubleVar(value=ai_config['weights'][method])
+            
+            tb.Spinbox(w_frame, from_=0.1, to=2.0, increment=0.1,
+                      textvariable=self.weight_vars[method],
+                      width=10).pack(side='left', padx=10)
+    
+    def create_mode_tab(self, notebook):
+        """Create the detection mode configuration tab"""
+        frame = ttk.Frame(notebook)
+        notebook.add(frame, text="Detection Mode")
+        
+        tk.Label(frame, text="Detection Mode Configuration", 
+                font=('TkDefaultFont', 12, 'bold')).pack(pady=10)
+        
+        # Detection mode selection
+        mode_frame = tk.LabelFrame(frame, text="Detection Mode", padx=20, pady=20)
+        mode_frame.pack(fill='x', padx=20, pady=10)
+        
+        ai_config = self.get_ai_config()
+        self.mode_var = tk.StringVar(value=ai_config['detection_mode'])
+        
+        modes = [
+            ('single_method', 'Single Method', 
+             'Flag as duplicate if ANY method exceeds its threshold\n(Most sensitive, most false positives)'),
+            ('multi_method', 'Multi-Method Agreement', 
+             'Require multiple methods to agree before flagging\n(Balanced approach)'),
+            ('weighted_average', 'Weighted Average', 
+             'Calculate weighted average of all methods\n(Most nuanced, least false positives)')
+        ]
+        
+        for value, text, desc in modes:
+            rb_frame = tk.Frame(mode_frame)
+            rb_frame.pack(fill='x', pady=10)
+            
+            tb.Radiobutton(rb_frame, text=text, variable=self.mode_var, 
+                          value=value, bootstyle="primary").pack(anchor='w')
+            tk.Label(rb_frame, text=desc, font=('TkDefaultFont', 9), 
+                    fg='gray').pack(anchor='w', padx=(25, 0))
+        
+        # Multi-method configuration
+        multi_frame = tk.LabelFrame(frame, text="Multi-Method Settings", padx=20, pady=20)
+        multi_frame.pack(fill='x', padx=20, pady=10)
+        
+        tk.Label(multi_frame, text="Number of methods required to agree:",
+                font=('TkDefaultFont', 10)).pack(anchor='w')
+        
+        self.methods_required_var = tk.IntVar(
+            value=ai_config['multi_method_requirements']['methods_required'])
+        
+        tb.Spinbox(multi_frame, from_=1, to=6, textvariable=self.methods_required_var,
+                  width=10).pack(anchor='w', pady=5)
+        
+        tk.Label(multi_frame, text="Required methods (at least one must be included):",
+                font=('TkDefaultFont', 10)).pack(anchor='w', pady=(10, 5))
+        
+        self.required_method_vars = {}
+        for method in ['exact', 'text', 'semantic', 'structural', 'character', 'pattern']:
+            var = tk.BooleanVar(
+                value=method in ai_config['multi_method_requirements']['min_methods'])
+            self.required_method_vars[method] = var
+            
+            tb.Checkbutton(multi_frame, text=method.title(), variable=var,
+                          bootstyle="round-toggle").pack(anchor='w', padx=20)
+    
+    def create_preprocessing_tab(self, notebook):
+        """Create the preprocessing configuration tab"""
+        frame = ttk.Frame(notebook)
+        notebook.add(frame, text="Preprocessing")
+        
+        tk.Label(frame, text="Text Preprocessing Options", 
+                font=('TkDefaultFont', 12, 'bold')).pack(pady=10)
+        
+        tk.Label(frame, text="Configure how text is processed before comparison",
+                font=('TkDefaultFont', 10), fg='gray').pack(pady=(0, 20))
+        
+        # Preprocessing options
+        prep_frame = tk.Frame(frame)
+        prep_frame.pack(fill='both', expand=True, padx=20)
+        
+        self.prep_vars = {}
+        ai_config = self.get_ai_config()
+        
+        options = [
+            ('remove_html_spacing', 'Remove HTML with spacing', 
+             'Replace HTML tags with spaces instead of removing completely'),
+            ('normalize_unicode', 'Normalize Unicode', 
+             'Normalize unicode characters (recommended)'),
+            ('ignore_case', 'Case-insensitive comparison', 
+             'Ignore character case when comparing'),
+            ('remove_extra_whitespace', 'Remove extra whitespace', 
+             'Collapse multiple spaces/newlines into single spaces')
+        ]
+        
+        for key, text, desc in options:
+            var = tk.BooleanVar(value=ai_config['preprocessing'][key])
+            self.prep_vars[key] = var
+            
+            opt_frame = tk.Frame(prep_frame)
+            opt_frame.pack(fill='x', pady=10)
+            
+            tb.Checkbutton(opt_frame, text=text, variable=var,
+                          bootstyle="round-toggle").pack(anchor='w')
+            tk.Label(opt_frame, text=desc, font=('TkDefaultFont', 9),
+                    fg='gray').pack(anchor='w', padx=(25, 0))
+    
+    def create_advanced_tab(self, notebook):
+        """Create the advanced settings tab"""
+        frame = ttk.Frame(notebook)
+        notebook.add(frame, text="Advanced")
+        
+        tk.Label(frame, text="Advanced Settings", 
+                font=('TkDefaultFont', 12, 'bold')).pack(pady=10)
+        
+        # General settings
+        general_frame = tk.LabelFrame(frame, text="General", padx=20, pady=20)
+        general_frame.pack(fill='x', padx=20, pady=10)
+        
+        ai_config = self.get_ai_config()
+        
+        # Add separator for better organization
+        ttk.Separator(general_frame, orient='horizontal').pack(fill='x', pady=(0, 10))
+
+        # Sample size
+        ss_frame = tk.Frame(general_frame)
+        ss_frame.pack(fill='x', pady=5)
+        
+        tk.Label(ss_frame, text="Sample size:", width=20, anchor='w').pack(side='left')
+        self.sample_size_var = tk.IntVar(value=ai_config['sample_size'])
+        tb.Spinbox(ss_frame, from_=1000, to=10000, increment=500,
+                  textvariable=self.sample_size_var, width=10).pack(side='left', padx=10)
+        tk.Label(ss_frame, text="characters",
+                font=('TkDefaultFont', 9)).pack(side='left')
+        
+        # AI Hunter Behavior Settings
+        tk.Label(general_frame, text="AI Hunter Behavior", 
+                font=('TkDefaultFont', 10, 'bold')).pack(anchor='w', pady=(0, 5))
+        
+        # Retry Attempts
+        retry_frame = tk.Frame(general_frame)
+        retry_frame.pack(fill='x', pady=5)
+        
+        tk.Label(retry_frame, text="Retry attempts:", width=20, anchor='w').pack(side='left')
+        self.retry_attempts_var = tk.IntVar(value=ai_config.get('retry_attempts', 3))
+        tb.Spinbox(retry_frame, from_=1, to=10, textvariable=self.retry_attempts_var, width=10).pack(side='left', padx=10)
+        tk.Label(retry_frame, text="attempts", font=('TkDefaultFont', 9)).pack(side='left')
+        
+        # Temperature Change Toggle
+        temp_frame = tk.Frame(general_frame)
+        temp_frame.pack(fill='x', pady=10)
+        
+        self.disable_temp_change_var = tk.BooleanVar(value=ai_config.get('disable_temperature_change', False))
+        tb.Checkbutton(temp_frame, text="Disable temperature change behavior",
+                      variable=self.disable_temp_change_var, bootstyle="round-toggle").pack(anchor='w')
+        tk.Label(temp_frame, text="Prevents AI Hunter from modifying temperature settings during retries",
+                font=('TkDefaultFont', 9), fg='gray').pack(anchor='w', padx=(25, 0))       
+        
+        # Edge filters
+        edge_frame = tk.LabelFrame(frame, text="Edge Case Filters", padx=20, pady=20)
+        edge_frame.pack(fill='x', padx=20, pady=10)
+        
+        # Min text length
+        min_frame = tk.Frame(edge_frame)
+        min_frame.pack(fill='x', pady=5)
+        
+        tk.Label(min_frame, text="Minimum text length:", width=20, anchor='w').pack(side='left')
+        self.min_length_var = tk.IntVar(value=ai_config['edge_filters']['min_text_length'])
+        tb.Spinbox(min_frame, from_=100, to=2000, increment=100,
+                  textvariable=self.min_length_var, width=10).pack(side='left', padx=10)
+        tk.Label(min_frame, text="characters",
+                font=('TkDefaultFont', 9)).pack(side='left')
+        
+        # Length ratios
+        ratio_frame = tk.Frame(edge_frame)
+        ratio_frame.pack(fill='x', pady=10)
+        
+        tk.Label(ratio_frame, text="Length ratio limits:").pack(anchor='w')
+        
+        r_frame = tk.Frame(ratio_frame)
+        r_frame.pack(fill='x', pady=5)
+        
+        tk.Label(r_frame, text="Min ratio:", width=10, anchor='w').pack(side='left', padx=(20, 5))
+        self.min_ratio_var = tk.DoubleVar(value=ai_config['edge_filters']['min_length_ratio'])
+        tb.Spinbox(r_frame, from_=0.5, to=0.9, increment=0.1,
+                  textvariable=self.min_ratio_var, width=8).pack(side='left')
+        
+        tk.Label(r_frame, text="Max ratio:", width=10, anchor='w').pack(side='left', padx=(20, 5))
+        self.max_ratio_var = tk.DoubleVar(value=ai_config['edge_filters']['max_length_ratio'])
+        tb.Spinbox(r_frame, from_=1.1, to=2.0, increment=0.1,
+                  textvariable=self.max_ratio_var, width=8).pack(side='left')
+        
+        tk.Label(edge_frame, text="Chapters with vastly different lengths won't be compared",
+                font=('TkDefaultFont', 9), fg='gray').pack(anchor='w', padx=20)
+        
+        # Language Detection
+        lang_frame = tk.LabelFrame(frame, text="Non-Target Language Detection", padx=20, pady=20)
+        lang_frame.pack(fill='x', padx=20, pady=10)
+        
+        # Enable toggle
+        enable_frame = tk.Frame(lang_frame)
+        enable_frame.pack(fill='x', pady=5)
+        
+        self.lang_enabled_var = tk.BooleanVar(value=ai_config['language_detection']['enabled'])
+        tb.Checkbutton(enable_frame, text="Enable non-target language detection",
+                      variable=self.lang_enabled_var, bootstyle="round-toggle").pack(anchor='w')
+        tk.Label(enable_frame, text="Trigger retranslation when too much non-target language is detected",
+                font=('TkDefaultFont', 9), fg='gray').pack(anchor='w', padx=(25, 0))
+        
+        # Target language selection
+        target_frame = tk.Frame(lang_frame)
+        target_frame.pack(fill='x', pady=10)
+        
+        tk.Label(target_frame, text="Target language:", width=20, anchor='w').pack(side='left')
+        self.target_lang_var = tk.StringVar(value=ai_config['language_detection']['target_language'])
+        
+        lang_options = list(ai_config['language_detection']['languages'].keys())
+        target_combo = ttk.Combobox(target_frame, textvariable=self.target_lang_var,
+                                   values=lang_options, state='readonly', width=15)
+        target_combo.pack(side='left', padx=10)
+        
+        tk.Label(target_frame, text="Language that should be in the translation",
+                font=('TkDefaultFont', 9), fg='gray').pack(side='left', padx=(10, 0))
+        
+        # Threshold setting
+        thresh_frame = tk.Frame(lang_frame)
+        thresh_frame.pack(fill='x', pady=5)
+        
+        tk.Label(thresh_frame, text="Character threshold:", width=20, anchor='w').pack(side='left')
+        self.lang_threshold_var = tk.IntVar(value=ai_config['language_detection']['threshold_characters'])
+        tb.Spinbox(thresh_frame, from_=100, to=2000, increment=50,
+                  textvariable=self.lang_threshold_var, width=10).pack(side='left', padx=10)
+        tk.Label(thresh_frame, text="non-target language characters to trigger retranslation",
+                font=('TkDefaultFont', 9), fg='gray').pack(side='left')
+    
+    def apply_ai_hunter_settings(self):
+        """Apply AI Hunter settings to the main config"""
+        ai_config = self.get_ai_config()
+        
+        # Update from GUI variables
+        for method, var in self.threshold_vars.items():
+            ai_config['thresholds'][method] = var.get()
+        
+        for method, var in self.weight_vars.items():
+            ai_config['weights'][method] = var.get()
+        
+        ai_config['detection_mode'] = self.mode_var.get()
+        ai_config['multi_method_requirements']['methods_required'] = self.methods_required_var.get()
+        
+        min_methods = [method for method, var in self.required_method_vars.items() if var.get()]
+        ai_config['multi_method_requirements']['min_methods'] = min_methods
+        
+        for key, var in self.prep_vars.items():
+            ai_config['preprocessing'][key] = var.get()
+        
+        ai_config['sample_size'] = self.sample_size_var.get()
+        
+        ai_config['edge_filters']['min_text_length'] = self.min_length_var.get()
+        ai_config['edge_filters']['min_length_ratio'] = self.min_ratio_var.get()
+        ai_config['edge_filters']['max_length_ratio'] = self.max_ratio_var.get()
+        
+        # Language detection settings
+        ai_config['language_detection']['enabled'] = self.lang_enabled_var.get()
+        ai_config['language_detection']['target_language'] = self.target_lang_var.get()
+        ai_config['language_detection']['threshold_characters'] = self.lang_threshold_var.get()
+        
+        # Update retry attempts and temperature change settings
+        ai_config['retry_attempts'] = self.retry_attempts_var.get()
+        ai_config['disable_temperature_change'] = self.disable_temp_change_var.get()
+        
+        # Update main config
+        self.config['ai_hunter_config'] = ai_config
+        
+        # Call callback if provided (this should trigger main save_configuration)
+        if self.callback:
+            self.callback()
+        
+        self.window.destroy()
+    
+    def reset_defaults(self):
+        """Reset all values to defaults"""
+        import tkinter.messagebox as messagebox
+        result = messagebox.askyesno("Reset to Defaults", 
+                                   "Are you sure you want to reset all settings to defaults?")
+        if result:
+            self.config['ai_hunter_config'] = self.default_ai_hunter.copy()
+            self.window.destroy()
+            self.show_ai_hunter_config()  # Reopen with default values
+
+
+class ImprovedAIHunterDetection:
+    """Improved AI Hunter detection methods for TranslateKRtoEN"""
+    
+    def __init__(self, main_config):
+        """
+        Initialize with reference to main config
+        
+        Args:
+            main_config: Reference to main translator config dictionary
+        """
+        self.main_config = main_config
+        
+        # Default AI Hunter settings
+        self.default_ai_hunter = {
+            'enabled': True,
+            'lookback_chapters': 5,
+            'retry_attempts': 3,
+            'disable_temperature_change': False,
+            'sample_size': 3000,
+            'thresholds': {
+                'exact': 90,
+                'text': 85,
+                'semantic': 85,
+                'structural': 85,
+                'character': 80,
+                'pattern': 80
+            },
+            'weights': {
+                'exact': 1.5,
+                'text': 1.2,
+                'semantic': 1.0,
+                'structural': 1.0,
+                'character': 0.8,
+                'pattern': 0.8
+            },
+            'detection_mode': 'multi_method',
+            'multi_method_requirements': {
+                'methods_required': 2,
+                'min_methods': ['semantic', 'structural']
+            },
+            'preprocessing': {
+                'remove_html_spacing': True,
+                'normalize_unicode': True,
+                'ignore_case': True,
+                'remove_extra_whitespace': True
+            },
+            'edge_filters': {
+                'min_text_length': 500,
+                'max_length_ratio': 1.3,
+                'min_length_ratio': 0.7
+            },
+            'language_detection': {
+                'enabled': False,
+                'target_language': 'english',
+                'threshold_characters': 500,
+                'languages': {
+                    'english': ['en'],
+                    'japanese': ['ja', 'jp'],
+                    'korean': ['ko', 'kr'],
+                    'chinese': ['zh', 'zh-cn', 'zh-tw'],
+                    'spanish': ['es'],
+                    'french': ['fr'],
+                    'german': ['de'],
+                    'russian': ['ru'],
+                    'arabic': ['ar'],
+                    'hindi': ['hi'],
+                    'portuguese': ['pt'],
+                    'italian': ['it'],
+                    'dutch': ['nl'],
+                    'thai': ['th'],
+                    'vietnamese': ['vi'],
+                    'turkish': ['tr'],
+                    'polish': ['pl'],
+                    'swedish': ['sv'],
+                    'danish': ['da'],
+                    'norwegian': ['no'],
+                    'finnish': ['fi']
+                }
+            }
+        }
+    
+    def get_ai_config(self):
+        """Get AI Hunter configuration from main config"""
+        return self.main_config.get('ai_hunter_config', self.default_ai_hunter)
+
+    def detect_duplicate_ai_hunter_enhanced(self, result, idx, prog, out, current_chapter_num=None):
+        """Enhanced AI Hunter duplicate detection with configurable parameters"""
+        try:
+            print(f"\n    ========== AI HUNTER DEBUG START ==========")
+            print(f"    📍 Current chapter index: {idx}")
+            if current_chapter_num:
+                print(f"    📖 Current chapter number: {current_chapter_num}")
+            
+            # Get configuration
+            config = self.get_ai_config()
+            
+            if not config.get('enabled', True):
+                print(f"    ⚠️ AI Hunter is disabled")
+                print(f"    ========== AI HUNTER DEBUG END ==========\n")
+                return False, 0
+            
+            # Preprocess text
+            result_clean = self._preprocess_text(result, config['preprocessing'])
+            print(f"    📄 Text length after preprocessing: {len(result_clean)} chars")
+            
+            # Check for non-target language detection
+            if config['language_detection']['enabled']:
+                non_target_detected, non_target_count = self._check_non_target_language(
+                    result_clean, config['language_detection']
+                )
+                if non_target_detected:
+                    print(f"\n    🌐 NON-TARGET LANGUAGE DETECTED!")
+                    print(f"       Non-target characters found: {non_target_count}")
+                    print(f"       Threshold: {config['language_detection']['threshold_characters']}")
+                    print(f"       Target language: {config['language_detection']['target_language']}")
+                    print(f"    ========== AI HUNTER DEBUG END ==========\n")
+                    return True, 100  # High confidence for language detection
+            
+            # Check edge cases
+            if len(result_clean) < config['edge_filters']['min_text_length']:
+                print(f"    ⚠️ Text too short ({len(result_clean)} < {config['edge_filters']['min_text_length']})")
+                print(f"    ========== AI HUNTER DEBUG END ==========\n")
+                return False, 0
+            
+            # Extract features
+            print(f"    🔬 Extracting text features...")
+            result_features = self._extract_text_features(result_clean)
+            
+            # Get lookback from main config, then fall back to env var if not found
+            lookback = self.main_config.get('duplicate_lookback_chapters', 
+                                           int(os.getenv('DUPLICATE_LOOKBACK_CHAPTERS', '5')))
+            
+            # Log configuration
+            print(f"\n    🔧 Configuration:")
+            print(f"       Detection mode: {config['detection_mode']}")
+            print(f"       Lookback chapters: {lookback}")
+            print(f"       Sample size: {config['sample_size']}")
+            
+            # FIX: Get all completed chapters sorted by actual chapter number
+            completed_chapters = []
+            for chapter_key, chapter_info in prog["chapters"].items():
+                if chapter_info.get("status") == "completed" and chapter_info.get("output_file"):
+                    # Handle both numeric and hash-based chapter keys
+                    try:
+                        # Get actual_num from progress (this is the real chapter number)
+                        chapter_num = chapter_info.get("actual_num")
+                        if chapter_num is None:
+                            # Try chapter_num as fallback
+                            chapter_num = chapter_info.get("chapter_num")
+                        if chapter_num is None:
+                            # Skip chapters without valid numbers
+                            print(f"       ⚠️ No chapter number found for key {chapter_key}, skipping")
+                            continue
+
+                        completed_chapters.append({
+                            'key': chapter_key,
+                            'num': chapter_num,
+                            'file': chapter_info.get("output_file"),
+                            'ai_features': chapter_info.get("ai_features")
+                        })
+                    except Exception as e:
+                        print(f"       ⚠️ Error processing chapter {chapter_key}: {e}")
+                        continue
+            
+            # Sort by actual chapter number
+            completed_chapters.sort(key=lambda x: x['num'])
+            
+            # If no current chapter number provided, try to infer it
+            if current_chapter_num is None:
+                # The current chapter should be passed in, but if not, we need to find it
+                # Since we're using content hash keys, we can't use idx directly
+                print(f"    ⚠️ No current chapter number provided")
+                print(f"    📊 Current index: {idx}")
+                
+                # The current chapter number should have been passed from the wrapper
+                # If it wasn't, we have a problem
+                print(f"    ❌ ERROR: Current chapter number not provided to AI Hunter!")
+                print(f"    ❌ This indicates the wrapper function is not passing the chapter number correctly")
+                
+                # Emergency: just use a high number so we don't compare against anything
+                current_chapter_num = 999999
+                print(f"    ⚠️ Using index-based chapter number: {current_chapter_num}")
+            
+            print(f"\n    📚 Found {len(completed_chapters)} completed chapters in progress")
+            if completed_chapters:
+                chapter_nums = [ch['num'] for ch in completed_chapters]
+                print(f"    📊 Chapter numbers in progress: {sorted(chapter_nums)[:10]}{'...' if len(chapter_nums) > 10 else ''}")
+            print(f"    🎯 Current chapter number: {current_chapter_num}")
+            print(f"    🔍 Will check against last {lookback} chapters before chapter {current_chapter_num}")
+            
+            # Check previous chapters
+            all_similarities = []
+            highest_similarity = 0.0
+            detected_method = None
+            detected_chapter = None
+            
+            # FIX: Look at chapters by actual number, not index
+            chapters_checked = 0
+            for completed_chapter in reversed(completed_chapters):
+                # Only check chapters that come before the current one
+                if completed_chapter['num'] >= current_chapter_num:
+                    continue
+                    
+                # Only check up to lookback number of chapters
+                if chapters_checked >= lookback:
+                    break
+                    
+                chapters_checked += 1
+                
+                print(f"\n    📝 Checking against chapter {completed_chapter['num']}...")
+                
+                # Get previous chapter features
+                prev_features = completed_chapter.get('ai_features')
+                prev_clean = None
+                
+                # Try to get cached features first
+                if prev_features:
+                    print(f"       ✅ Using cached features")
+                else:
+                    # Read and extract features
+                    prev_path = os.path.join(out, completed_chapter['file'])
+                    
+                    if os.path.exists(prev_path):
+                        try:
+                            with open(prev_path, 'r', encoding='utf-8') as f:
+                                prev_content = f.read()
+                                prev_clean = self._preprocess_text(prev_content, config['preprocessing'])
+                                
+                                # Check length ratio
+                                len_ratio = len(result_clean) / max(1, len(prev_clean))
+                                if (len_ratio < config['edge_filters']['min_length_ratio'] or 
+                                    len_ratio > config['edge_filters']['max_length_ratio']):
+                                    print(f"       ⚠️ Length ratio out of bounds: {len_ratio:.2f}")
+                                    continue
+                                
+                                prev_features = self._extract_text_features(prev_clean)
+                                print(f"       📄 Extracted features from file")
+                        except Exception as e:
+                            print(f"       ❌ Failed to read file: {e}")
+                            continue
+                    else:
+                        print(f"       ❌ File not found: {prev_path}")
+                        continue
+                
+                # Calculate similarities
+                print(f"       🔍 Calculating similarities...")
+                similarities = self._calculate_all_similarities(
+                    result_clean, result_features, 
+                    prev_clean, prev_features, config
+                )
+                
+                # Store for reporting
+                all_similarities.append({
+                    'chapter': completed_chapter['num'],
+                    'similarities': similarities
+                })
+                
+                # Log similarity scores
+                for method, score in similarities.items():
+                    if score > 0:
+                        print(f"          {method}: {int(score*100)}%")
+                
+                # Check if duplicate based on configured mode
+                is_duplicate, confidence, methods_triggered = self._evaluate_duplicate(
+                    similarities, config
+                )
+                
+                if is_duplicate:
+                    print(f"\n    🚨 DUPLICATE DETECTED!")
+                    print(f"       Detection mode: {config['detection_mode']}")
+                    print(f"       Confidence: {int(confidence*100)}%")
+                    print(f"       Triggered methods: {', '.join(methods_triggered)}")
+                    print(f"       Match with: Chapter {completed_chapter['num']}")
+                    print(f"    ========== AI HUNTER DEBUG END ==========\n")
+                    return True, int(confidence * 100)
+                
+                # Track highest for reporting
+                for method, sim in similarities.items():
+                    if sim > highest_similarity:
+                        highest_similarity = sim
+                        detected_method = method
+                        detected_chapter = completed_chapter['num']
+            
+            # No duplicate found
+            print(f"\n    ✅ No duplicate found")
+            if detected_method:
+                print(f"       Highest similarity: {int(highest_similarity*100)}% via {detected_method}")
+                print(f"       Closest match: Chapter {detected_chapter}")
+            
+            # Show top 3 closest matches
+            if all_similarities:
+                print(f"\n    📊 Top 3 closest matches:")
+                sorted_chapters = sorted(all_similarities, 
+                                       key=lambda x: self._get_chapter_score(x['similarities'], config), 
+                                       reverse=True)[:3]
+                for i, chapter_data in enumerate(sorted_chapters, 1):
+                    score = self._get_chapter_score(chapter_data['similarities'], config)
+                    print(f"       {i}. Chapter {chapter_data['chapter']}: {int(score*100)}%")
+            
+            print(f"    ========== AI HUNTER DEBUG END ==========\n")
+            return False, 0
+            
+        except Exception as e:
+            print(f"    ❌ AI Hunter detection failed with error: {e}")
+            import traceback
+            print(f"    {traceback.format_exc()}")
+            print(f"    ========== AI HUNTER DEBUG END ==========\n")
+            return False, 0
+    
+    def _preprocess_text(self, text, prep_config):
+        """Preprocess text according to configuration"""
+        # Remove HTML
+        if prep_config.get('remove_html_spacing', True):
+            text = re.sub(r'<[^>]+>', ' ', text)
+        else:
+            text = re.sub(r'<[^>]+>', '', text)
+        
+        # Normalize unicode
+        if prep_config.get('normalize_unicode', True):
+            text = unicodedata.normalize('NFKD', text)
+        
+        # Remove extra whitespace
+        if prep_config.get('remove_extra_whitespace', True):
+            text = re.sub(r'\s+', ' ', text)
+            text = re.sub(r'\n\s*\n', '\n\n', text)
+        
+        text = text.strip()
+        
+        # Convert to lowercase if case-insensitive
+        if prep_config.get('ignore_case', True):
+            text = text.lower()
+        
+        return text
+    
+    def _calculate_all_similarities(self, result_clean, result_features, 
+                                   prev_clean, prev_features, config):
+        """Calculate all similarity metrics"""
+        similarities = {}
+        
+        # Method 1: Exact content match
+        if prev_clean is not None:
+            sample_size = min(config['sample_size'], len(result_clean), len(prev_clean))
+            exact_sim = self._calculate_exact_similarity(
+                result_clean[:sample_size], 
+                prev_clean[:sample_size]
+            )
+            similarities['exact'] = exact_sim
+            
+            # Method 2: Smart text similarity
+            text_sim = self._calculate_smart_similarity(
+                result_clean, prev_clean, config['sample_size']
+            )
+            similarities['text'] = text_sim
+        else:
+            similarities['exact'] = 0.0
+            similarities['text'] = 0.0
+        
+        # Method 3: Semantic fingerprint
+        semantic_sim = self._calculate_semantic_similarity(
+            result_features.get('semantic', {}), 
+            prev_features.get('semantic', {})
+        )
+        similarities['semantic'] = semantic_sim
+        
+        # Method 4: Structural signature
+        structural_sim = self._calculate_structural_similarity(
+            result_features.get('structural', {}), 
+            prev_features.get('structural', {})
+        )
+        similarities['structural'] = structural_sim
+        
+        # Method 5: Character analysis
+        char_sim = self._calculate_character_similarity(
+            result_features.get('characters', []), 
+            prev_features.get('characters', [])
+        )
+        similarities['character'] = char_sim
+        
+        # Method 6: Pattern analysis
+        pattern_sim = self._calculate_pattern_similarity(
+            result_features.get('patterns', {}), 
+            prev_features.get('patterns', {})
+        )
+        similarities['pattern'] = pattern_sim
+        
+        return similarities
+    
+    def _evaluate_duplicate(self, similarities, config):
+        """Evaluate if similarities indicate a duplicate based on detection mode"""
+        mode = config['detection_mode']
+        thresholds = {k: v/100.0 for k, v in config['thresholds'].items()}
+        
+        if mode == 'single_method':
+            # Any method exceeding threshold
+            for method, sim in similarities.items():
+                if sim >= thresholds.get(method, 0.85):
+                    return True, sim, [method]
+            return False, 0, []
+        
+        elif mode == 'multi_method':
+            # Multiple methods must agree
+            triggered_methods = []
+            for method, sim in similarities.items():
+                if sim >= thresholds.get(method, 0.85):
+                    triggered_methods.append(method)
+            
+            # Check if enough methods triggered
+            required = config.get('multi_method_requirements', {}).get('methods_required', 2)
+            min_methods = config.get('multi_method_requirements', {}).get('min_methods', [])
+            
+            if len(triggered_methods) >= required:
+                # Check if at least one required method is included
+                if not min_methods or any(m in triggered_methods for m in min_methods):
+                    # Calculate average confidence of triggered methods
+                    confidence = sum(similarities[m] for m in triggered_methods) / len(triggered_methods)
+                    return True, confidence, triggered_methods
+            
+            return False, 0, []
+        
+        elif mode == 'weighted_average':
+            # Calculate weighted average
+            weights = config.get('weights', {})
+            total_weight = sum(weights.get(m, 1.0) for m in similarities)
+            weighted_sum = sum(similarities[m] * weights.get(m, 1.0) for m in similarities)
+            weighted_avg = weighted_sum / total_weight if total_weight > 0 else 0
+            
+            # Check if weighted average exceeds average threshold
+            avg_threshold = sum(thresholds.values()) / len(thresholds) if thresholds else 0.85
+            
+            if weighted_avg >= avg_threshold:
+                # Find which methods contributed most
+                triggered = [m for m, sim in similarities.items() 
+                           if sim >= thresholds.get(m, 0.85)]
+                return True, weighted_avg, triggered
+            
+            return False, 0, []
+        
+        return False, 0, []
+    
+    def _get_chapter_score(self, similarities, config):
+        """Calculate overall score for a chapter comparison"""
+        if config['detection_mode'] == 'weighted_average':
+            weights = config.get('weights', {})
+            total_weight = sum(weights.get(m, 1.0) for m in similarities)
+            return sum(similarities.get(m, 0) * weights.get(m, 1.0) for m in similarities) / total_weight if total_weight > 0 else 0
+        else:
+            return max(similarities.values()) if similarities else 0
+    
+    def _extract_text_features(self, text):
+        """Extract multiple features from text for AI Hunter analysis"""
+        features = {
+            'semantic': {},
+            'structural': {},
+            'characters': [],
+            'patterns': {}
+        }
+        
+        # Semantic fingerprint
+        lines = text.split('\n')
+        
+        # Character extraction (names that appear 3+ times)
+        words = re.findall(r'\b[A-Z][a-z]+\b', text)
+        word_freq = Counter(words)
+        features['characters'] = [name for name, count in word_freq.items() 
+                                 if count >= 3 and name not in {
+                                     'The', 'A', 'An', 'In', 'On', 'At', 'To', 
+                                     'From', 'With', 'By', 'For', 'Of', 'As', 
+                                     'But', 'And', 'Or', 'He', 'She', 'It', 
+                                     'They', 'We', 'You', 'What', 'When', 'Where',
+                                     'Who', 'Why', 'How', 'That', 'This', 'These'
+                                 }]
+        
+        # Dialogue patterns
+        dialogue_patterns = re.findall(r'"([^"]+)"', text)
+        features['semantic']['dialogue_count'] = len(dialogue_patterns)
+        features['semantic']['dialogue_lengths'] = [len(d) for d in dialogue_patterns[:10]]
+        
+        # Speaker patterns
+        speaker_patterns = re.findall(r'(\w+)\s+(?:said|asked|replied|shouted|whispered)', text.lower())
+        features['semantic']['speakers'] = list(set(speaker_patterns[:20]))
+        
+        # Number extraction
+        numbers = re.findall(r'\b\d+\b', text)
+        features['patterns']['numbers'] = numbers[:20]
+        
+        # Structural signature
+        para_lengths = []
+        dialogue_count = 0
+        for para in text.split('\n\n'):
+            if para.strip():
+                para_lengths.append(len(para))
+                if '"' in para:
+                    dialogue_count += 1
+        
+        features['structural']['para_count'] = len(para_lengths)
+        features['structural']['avg_para_length'] = sum(para_lengths) / max(1, len(para_lengths))
+        features['structural']['dialogue_ratio'] = dialogue_count / max(1, len(para_lengths))
+        
+        # Create structural pattern string
+        pattern = []
+        for para in text.split('\n\n')[:20]:  # First 20 paragraphs
+            if para.strip():
+                if '"' in para:
+                    pattern.append('D')  # Dialogue
+                elif len(para) > 300:
+                    pattern.append('L')  # Long
+                elif len(para) < 100:
+                    pattern.append('S')  # Short
+                else:
+                    pattern.append('M')  # Medium
+        features['structural']['pattern'] = ''.join(pattern)
+        
+        # Action density
+        action_verbs = len(re.findall(r'\b\w+ed\b', text))
+        features['semantic']['action_density'] = action_verbs / max(1, len(text.split()))
+        
+        # Text length
+        features['semantic']['text_length'] = len(text)
+        
+        return features
+    
+    def _calculate_exact_similarity(self, text1, text2):
+        """Calculate exact text similarity"""
+        return SequenceMatcher(None, text1, text2).ratio()
+    
+    def _calculate_smart_similarity(self, text1, text2, sample_size):
+        """Smart similarity with configurable sample size"""
+        if len(text1) > sample_size * 3 and len(text2) > sample_size * 3:
+            # Use multiple samples
+            samples1 = [
+                text1[:sample_size],
+                text1[len(text1)//2 - sample_size//2:len(text1)//2 + sample_size//2],
+                text1[-sample_size:]
+            ]
+            samples2 = [
+                text2[:sample_size],
+                text2[len(text2)//2 - sample_size//2:len(text2)//2 + sample_size//2],
+                text2[-sample_size:]
+            ]
+            similarities = [SequenceMatcher(None, s1, s2).ratio() 
+                           for s1, s2 in zip(samples1, samples2)]
+            return sum(similarities) / len(similarities)
+        else:
+            # Use full text up to sample size
+            return SequenceMatcher(None, text1[:sample_size], text2[:sample_size]).ratio()
+    
+    def _calculate_semantic_similarity(self, sem1, sem2):
+        """Calculate semantic fingerprint similarity"""
+        score = 0.0
+        weights = 0.0
+        
+        # Compare dialogue counts
+        if 'dialogue_count' in sem1 and 'dialogue_count' in sem2:
+            weights += 0.3
+            if sem1['dialogue_count'] > 0 or sem2['dialogue_count'] > 0:
+                ratio = min(sem1['dialogue_count'], sem2['dialogue_count']) / \
+                       max(1, max(sem1['dialogue_count'], sem2['dialogue_count']))
+                score += ratio * 0.3
+        
+        # Compare speakers
+        if 'speakers' in sem1 and 'speakers' in sem2:
+            weights += 0.4
+            if sem1['speakers'] and sem2['speakers']:
+                overlap = len(set(sem1['speakers']) & set(sem2['speakers']))
+                total = len(set(sem1['speakers']) | set(sem2['speakers']))
+                score += (overlap / max(1, total)) * 0.4
+            elif not sem1['speakers'] and not sem2['speakers']:
+                score += 0.4  # Both have no speakers
+        
+        # Compare dialogue lengths pattern
+        if 'dialogue_lengths' in sem1 and 'dialogue_lengths' in sem2:
+            weights += 0.2
+            if sem1['dialogue_lengths'] and sem2['dialogue_lengths']:
+                len1 = sem1['dialogue_lengths'][:10]
+                len2 = sem2['dialogue_lengths'][:10]
+                if len1 and len2:
+                    avg1 = sum(len1) / len(len1)
+                    avg2 = sum(len2) / len(len2)
+                    ratio = min(avg1, avg2) / max(1, max(avg1, avg2))
+                    score += ratio * 0.2
+            elif not sem1['dialogue_lengths'] and not sem2['dialogue_lengths']:
+                score += 0.2  # Both have no dialogue
+        
+        # Action density
+        if 'action_density' in sem1 and 'action_density' in sem2:
+            weights += 0.1
+            act_sim = 1 - abs(sem1['action_density'] - sem2['action_density'])
+            score += act_sim * 0.1
+        
+        return score / max(0.1, weights)
+    
+    def _calculate_structural_similarity(self, struct1, struct2):
+        """Calculate structural signature similarity"""
+        score = 0.0
+        
+        # Compare paragraph patterns
+        if 'pattern' in struct1 and 'pattern' in struct2:
+            pattern_sim = SequenceMatcher(None, struct1['pattern'], struct2['pattern']).ratio()
+            score += pattern_sim * 0.5
+        
+        # Compare paragraph statistics
+        if all(k in struct1 for k in ['para_count', 'avg_para_length', 'dialogue_ratio']) and \
+           all(k in struct2 for k in ['para_count', 'avg_para_length', 'dialogue_ratio']):
+            
+            # Paragraph count ratio
+            para_ratio = min(struct1['para_count'], struct2['para_count']) / \
+                        max(1, max(struct1['para_count'], struct2['para_count']))
+            score += para_ratio * 0.2
+            
+            # Average length ratio
+            avg_ratio = min(struct1['avg_para_length'], struct2['avg_para_length']) / \
+                       max(1, max(struct1['avg_para_length'], struct2['avg_para_length']))
+            score += avg_ratio * 0.15
+            
+            # Dialogue ratio similarity
+            dialogue_diff = abs(struct1['dialogue_ratio'] - struct2['dialogue_ratio'])
+            score += (1 - min(1, dialogue_diff)) * 0.15
+        
+        return score
+    
+    def _calculate_character_similarity(self, chars1, chars2):
+        """Calculate character overlap similarity"""
+        if not chars1 or not chars2:
+            return 0.0
+        
+        # Convert to sets
+        set1 = set(chars1)
+        set2 = set(chars2)
+        
+        # If no overlap at all, return 0
+        intersection = set1 & set2
+        if not intersection:
+            return 0.0
+        
+        # Calculate Jaccard index (intersection over union)
+        union = set1 | set2
+        jaccard = len(intersection) / len(union)
+        
+        # Also consider the proportion of matching characters relative to each set
+        # This prevents small overlaps from scoring too high
+        overlap1 = len(intersection) / len(set1)
+        overlap2 = len(intersection) / len(set2)
+        
+        # Take the minimum overlap to be more conservative
+        min_overlap = min(overlap1, overlap2)
+        
+        # Combine jaccard and overlap scores
+        # Jaccard penalizes when sets are very different sizes
+        # Min overlap ensures both texts share a significant portion of characters
+        score = (jaccard + min_overlap) / 2
+        
+        return score
+    
+    def _calculate_pattern_similarity(self, pat1, pat2):
+        """Calculate pattern similarity (numbers, etc.)"""
+        score = 0.0
+        
+        # Number overlap
+        if 'numbers' in pat1 and 'numbers' in pat2:
+            nums1 = set(pat1['numbers'])
+            nums2 = set(pat2['numbers'])
+            
+            if nums1 or nums2:
+                overlap = len(nums1 & nums2)
+                total = len(nums1 | nums2)
+                score = overlap / max(1, total)
+            else:
+                score = 1.0  # Both have no numbers
+        
+        return score
+    
+    def _check_non_target_language(self, text, lang_config):
+        """Check if text contains too much non-target language"""
+        target_language = lang_config['target_language'].lower()
+        threshold = lang_config['threshold_characters']
+        
+        # Character ranges for different languages
+        language_ranges = {
+            'english': [  # Latin script + basic symbols
+                (0x0000, 0x007F),  # Basic Latin
+                (0x0080, 0x00FF),  # Latin-1 Supplement
+                (0x0100, 0x017F),  # Latin Extended-A
+                (0x0180, 0x024F),  # Latin Extended-B
+                (0x2000, 0x206F),  # General Punctuation
+                (0x20A0, 0x20CF),  # Currency Symbols
+                (0xFF00, 0xFFEF),  # Halfwidth and Fullwidth Forms
+            ],
+            'japanese': [
+                (0x3040, 0x309F),  # Hiragana
+                (0x30A0, 0x30FF),  # Katakana
+                (0x4E00, 0x9FAF),  # CJK Unified Ideographs
+                (0x3400, 0x4DBF),  # CJK Extension A
+                (0xFF66, 0xFF9F),  # Halfwidth Katakana
+            ],
+            'korean': [
+                (0xAC00, 0xD7AF),  # Hangul Syllables
+                (0x1100, 0x11FF),  # Hangul Jamo
+                (0x3130, 0x318F),  # Hangul Compatibility Jamo
+                (0xA960, 0xA97F),  # Hangul Jamo Extended-A
+                (0xD7B0, 0xD7FF),  # Hangul Jamo Extended-B
+            ],
+            'chinese': [
+                (0x4E00, 0x9FAF),  # CJK Unified Ideographs
+                (0x3400, 0x4DBF),  # CJK Extension A
+                (0x20000, 0x2A6DF), # CJK Extension B
+                (0x2A700, 0x2B73F), # CJK Extension C
+                (0x2B740, 0x2B81F), # CJK Extension D
+                (0x3000, 0x303F),  # CJK Symbols and Punctuation
+            ],
+            'arabic': [
+                (0x0600, 0x06FF),  # Arabic
+                (0x0750, 0x077F),  # Arabic Supplement
+                (0x08A0, 0x08FF),  # Arabic Extended-A
+                (0xFB50, 0xFDFF),  # Arabic Presentation Forms-A
+                (0xFE70, 0xFEFF),  # Arabic Presentation Forms-B
+            ],
+            'russian': [
+                (0x0400, 0x04FF),  # Cyrillic
+                (0x0500, 0x052F),  # Cyrillic Supplement
+                (0x2DE0, 0x2DFF),  # Cyrillic Extended-A
+                (0xA640, 0xA69F),  # Cyrillic Extended-B
+            ],
+            'thai': [
+                (0x0E00, 0x0E7F),  # Thai
+            ],
+            'hindi': [
+                (0x0900, 0x097F),  # Devanagari
+                (0xA8E0, 0xA8FF),  # Devanagari Extended
+            ],
+            'spanish': [  # Same as English (Latin script)
+                (0x0000, 0x007F),  # Basic Latin
+                (0x0080, 0x00FF),  # Latin-1 Supplement
+                (0x0100, 0x017F),  # Latin Extended-A
+                (0x0180, 0x024F),  # Latin Extended-B
+            ],
+            'french': [  # Same as English (Latin script)
+                (0x0000, 0x007F),  # Basic Latin
+                (0x0080, 0x00FF),  # Latin-1 Supplement
+                (0x0100, 0x017F),  # Latin Extended-A
+                (0x0180, 0x024F),  # Latin Extended-B
+            ],
+            'german': [  # Same as English (Latin script)
+                (0x0000, 0x007F),  # Basic Latin
+                (0x0080, 0x00FF),  # Latin-1 Supplement
+                (0x0100, 0x017F),  # Latin Extended-A
+                (0x0180, 0x024F),  # Latin Extended-B
+            ],
+            'portuguese': [  # Same as English (Latin script)
+                (0x0000, 0x007F),  # Basic Latin
+                (0x0080, 0x00FF),  # Latin-1 Supplement
+                (0x0100, 0x017F),  # Latin Extended-A
+                (0x0180, 0x024F),  # Latin Extended-B
+            ],
+            'italian': [  # Same as English (Latin script)
+                (0x0000, 0x007F),  # Basic Latin
+                (0x0080, 0x00FF),  # Latin-1 Supplement
+                (0x0100, 0x017F),  # Latin Extended-A
+                (0x0180, 0x024F),  # Latin Extended-B
+            ],
+            'dutch': [  # Same as English (Latin script)
+                (0x0000, 0x007F),  # Basic Latin
+                (0x0080, 0x00FF),  # Latin-1 Supplement
+                (0x0100, 0x017F),  # Latin Extended-A
+                (0x0180, 0x024F),  # Latin Extended-B
+            ],
+            'vietnamese': [
+                (0x0000, 0x007F),  # Basic Latin
+                (0x0080, 0x00FF),  # Latin-1 Supplement
+                (0x0100, 0x017F),  # Latin Extended-A
+                (0x0180, 0x024F),  # Latin Extended-B
+                (0x1EA0, 0x1EFF),  # Latin Extended Additional (Vietnamese)
+            ],
+            'turkish': [
+                (0x0000, 0x007F),  # Basic Latin
+                (0x0080, 0x00FF),  # Latin-1 Supplement
+                (0x0100, 0x017F),  # Latin Extended-A
+                (0x0180, 0x024F),  # Latin Extended-B
+            ],
+            'polish': [
+                (0x0000, 0x007F),  # Basic Latin
+                (0x0080, 0x00FF),  # Latin-1 Supplement
+                (0x0100, 0x017F),  # Latin Extended-A
+                (0x0180, 0x024F),  # Latin Extended-B
+            ],
+            'swedish': [  # Same as English (Latin script)
+                (0x0000, 0x007F),  # Basic Latin
+                (0x0080, 0x00FF),  # Latin-1 Supplement
+                (0x0100, 0x017F),  # Latin Extended-A
+                (0x0180, 0x024F),  # Latin Extended-B
+            ],
+            'danish': [  # Same as English (Latin script)
+                (0x0000, 0x007F),  # Basic Latin
+                (0x0080, 0x00FF),  # Latin-1 Supplement
+                (0x0100, 0x017F),  # Latin Extended-A
+                (0x0180, 0x024F),  # Latin Extended-B
+            ],
+            'norwegian': [  # Same as English (Latin script)
+                (0x0000, 0x007F),  # Basic Latin
+                (0x0080, 0x00FF),  # Latin-1 Supplement
+                (0x0100, 0x017F),  # Latin Extended-A
+                (0x0180, 0x024F),  # Latin Extended-B
+            ],
+            'finnish': [  # Same as English (Latin script)
+                (0x0000, 0x007F),  # Basic Latin
+                (0x0080, 0x00FF),  # Latin-1 Supplement
+                (0x0100, 0x017F),  # Latin Extended-A
+                (0x0180, 0x024F),  # Latin Extended-B
+            ],
+        }
+        
+        # Get target language ranges
+        target_ranges = language_ranges.get(target_language, language_ranges['english'])
+        
+        # Count characters that are NOT in target language ranges
+        non_target_count = 0
+        total_letters = 0
+        
+        for char in text:
+            # Skip whitespace, punctuation, and numbers for counting
+            if char.isspace() or char.isdigit():
+                continue
+                
+            # Count as letter character
+            total_letters += 1
+            
+            # Check if character is in any target language range
+            char_code = ord(char)
+            is_target_char = any(start <= char_code <= end for start, end in target_ranges)
+            
+            if not is_target_char:
+                non_target_count += 1
+        
+        # Debug logging
+        if non_target_count > 0:
+            print(f"       🌐 Language detection: {non_target_count}/{total_letters} non-target chars ({target_language})")
+        
+        # Return True if non-target character count exceeds threshold
+        return non_target_count >= threshold, non_target_count

api_key_encryption.py

@@ -0,0 +1,244 @@
+"""
+Simple API Key Encryption Module for Glossarion
+Encrypts only specific API key fields including multi-key support
+"""
+
+import os
+import json
+import base64
+from cryptography.fernet import Fernet
+from pathlib import Path
+
+
+class APIKeyEncryption:
+    """Simple encryption handler for API keys"""
+    
+    def __init__(self):
+        self.key_file = Path('.glossarion_key')
+        self.cipher = self._get_or_create_cipher()
+        
+        # Define which fields to encrypt
+        self.api_key_fields = [
+            'api_key',
+            'replicate_api_key',
+            # Add more field names here if needed
+        ]
+    
+    def _get_or_create_cipher(self):
+        """Get existing cipher or create new one"""
+        if self.key_file.exists():
+            try:
+                key = self.key_file.read_bytes()
+                return Fernet(key)
+            except:
+                pass
+        
+        # Generate new key
+        key = Fernet.generate_key()
+        self.key_file.write_bytes(key)
+        
+        # Hide file on Windows
+        if os.name == 'nt':
+            import ctypes
+            ctypes.windll.kernel32.SetFileAttributesW(str(self.key_file), 2)
+        else:
+            # Restrict permissions on Unix
+            os.chmod(self.key_file, 0o600)
+        
+        return Fernet(key)
+    
+    def encrypt_value(self, value):
+        """Encrypt a single value"""
+        try:
+            encrypted = self.cipher.encrypt(value.encode())
+            return f"ENC:{base64.b64encode(encrypted).decode()}"
+        except:
+            return value
+    
+    def decrypt_value(self, value):
+        """Decrypt a single value"""
+        if not isinstance(value, str) or not value.startswith('ENC:'):
+            return value
+        
+        try:
+            encrypted_data = base64.b64decode(value[4:])
+            return self.cipher.decrypt(encrypted_data).decode()
+        except:
+            return value
+    
+    def encrypt_multi_keys(self, multi_keys):
+        """Encrypt API keys in multi_api_keys array"""
+        if not isinstance(multi_keys, list):
+            return multi_keys
+        
+        encrypted_keys = []
+        for key_entry in multi_keys:
+            if isinstance(key_entry, dict):
+                encrypted_entry = key_entry.copy()
+                # Encrypt the api_key field in each entry
+                if 'api_key' in encrypted_entry and encrypted_entry['api_key']:
+                    value = encrypted_entry['api_key']
+                    if isinstance(value, str) and not value.startswith('ENC:'):
+                        encrypted_entry['api_key'] = self.encrypt_value(value)
+                encrypted_keys.append(encrypted_entry)
+            else:
+                encrypted_keys.append(key_entry)
+        
+        return encrypted_keys
+    
+    def decrypt_multi_keys(self, multi_keys):
+        """Decrypt API keys in multi_api_keys array"""
+        if not isinstance(multi_keys, list):
+            return multi_keys
+        
+        decrypted_keys = []
+        for key_entry in multi_keys:
+            if isinstance(key_entry, dict):
+                decrypted_entry = key_entry.copy()
+                # Decrypt the api_key field in each entry
+                if 'api_key' in decrypted_entry and decrypted_entry['api_key']:
+                    decrypted_entry['api_key'] = self.decrypt_value(decrypted_entry['api_key'])
+                decrypted_keys.append(decrypted_entry)
+            else:
+                decrypted_keys.append(key_entry)
+        
+        return decrypted_keys
+    
+    def encrypt_config(self, config):
+        """Encrypt specific API key fields including multi-key support"""
+        encrypted = config.copy()
+        
+        # Encrypt regular API key fields
+        for field in self.api_key_fields:
+            if field in encrypted and encrypted[field]:
+                value = encrypted[field]
+                # Only encrypt if not already encrypted
+                if isinstance(value, str) and not value.startswith('ENC:'):
+                    encrypted[field] = self.encrypt_value(value)
+        
+        # Encrypt multi_api_keys if present
+        if 'multi_api_keys' in encrypted:
+            encrypted['multi_api_keys'] = self.encrypt_multi_keys(encrypted['multi_api_keys'])
+            
+        # Encrypt fallback_keys if present
+        if 'fallback_keys' in encrypted:
+            encrypted['fallback_keys'] = self.encrypt_multi_keys(encrypted['fallback_keys'])
+        
+        return encrypted
+    
+    def decrypt_config(self, config):
+        """Decrypt specific API key fields including multi-key support"""
+        decrypted = config.copy()
+        
+        # Decrypt regular API key fields
+        for field in self.api_key_fields:
+            if field in decrypted and decrypted[field]:
+                decrypted[field] = self.decrypt_value(decrypted[field])
+        
+        # Decrypt multi_api_keys if present
+        if 'multi_api_keys' in decrypted:
+            decrypted['multi_api_keys'] = self.decrypt_multi_keys(decrypted['multi_api_keys'])
+            
+        # Decrypt fallback_keys if present  
+        if 'fallback_keys' in decrypted:
+            decrypted['fallback_keys'] = self.decrypt_multi_keys(decrypted['fallback_keys'])
+        
+        return decrypted
+
+# Simple interface functions
+_handler = None
+
+def get_handler():
+    global _handler
+    if _handler is None:
+        _handler = APIKeyEncryption()
+    return _handler
+
+def encrypt_config(config):
+    """Encrypt API keys in config"""
+    return get_handler().encrypt_config(config)
+
+def decrypt_config(config):
+    """Decrypt API keys in config"""
+    return get_handler().decrypt_config(config)
+
+def migrate_config_file(config_file='config.json'):
+    """Migrate existing config to encrypted format"""
+    try:
+        # Read config
+        with open(config_file, 'r', encoding='utf-8') as f:
+            config = json.load(f)
+        
+        # Check if already encrypted
+        handler = get_handler()
+        needs_encryption = False
+        
+        # Check regular API key fields
+        for field in handler.api_key_fields:
+            if field in config and config[field]:
+                if isinstance(config[field], str) and not config[field].startswith('ENC:'):
+                    needs_encryption = True
+                    break
+        
+        # Check multi_api_keys
+        if 'multi_api_keys' in config and isinstance(config['multi_api_keys'], list):
+            for key_entry in config['multi_api_keys']:
+                if isinstance(key_entry, dict) and 'api_key' in key_entry:
+                    if key_entry['api_key'] and not key_entry['api_key'].startswith('ENC:'):
+                        needs_encryption = True
+                        break
+
+        # Check fallback_keys
+        if 'fallback_keys' in config and isinstance(config['fallback_keys'], list):
+            for key_entry in config['fallback_keys']:
+                if isinstance(key_entry, dict) and 'api_key' in key_entry:
+                    if key_entry['api_key'] and not key_entry['api_key'].startswith('ENC:'):
+                        needs_encryption = True
+                        break
+        
+        if not needs_encryption:
+            print("Config already encrypted or no API keys found.")
+            return True
+        
+        # Backup
+        backup_file = f"{config_file}.backup"
+        with open(backup_file, 'w', encoding='utf-8') as f:
+            json.dump(config, f, ensure_ascii=False, indent=2)
+        print(f"Created backup: {backup_file}")
+        
+        # Encrypt
+        encrypted = encrypt_config(config)
+        
+        # Save
+        with open(config_file, 'w', encoding='utf-8') as f:
+            json.dump(encrypted, f, ensure_ascii=False, indent=2)
+        
+        print("✅ Successfully encrypted API keys!")
+        
+        # Show summary
+        if 'multi_api_keys' in config:
+            print(f"  - Encrypted {len(config['multi_api_keys'])} multi-key entries")
+        
+        if 'fallback_keys' in config:
+            print(f"  - Encrypted {len(config['fallback_keys'])} fallback-key entries")
+    
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    # Simple migration script
+    import sys
+    
+    config_file = 'config.json'
+    if len(sys.argv) > 1:
+        config_file = sys.argv[1]
+    
+    if os.path.exists(config_file):
+        print(f"Encrypting API keys in {config_file}...")
+        migrate_config_file(config_file)
+    else:
+        print(f"Config file not found: {config_file}")

bubble_detector.py

@@ -0,0 +1,1881 @@
+"""
+bubble_detector.py - Modified version that works in frozen PyInstaller executables
+Replace your bubble_detector.py with this version
+"""
+import os
+import sys
+import json
+import numpy as np
+import cv2
+from typing import List, Tuple, Optional, Dict, Any
+import logging
+import traceback
+import hashlib
+from pathlib import Path
+import threading
+import time
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Check if we're running in a frozen environment
+IS_FROZEN = getattr(sys, 'frozen', False)
+if IS_FROZEN:
+    # In frozen environment, set proper paths for ML libraries
+    MEIPASS = sys._MEIPASS
+    os.environ['TORCH_HOME'] = MEIPASS
+    os.environ['TRANSFORMERS_CACHE'] = os.path.join(MEIPASS, 'transformers')
+    os.environ['HF_HOME'] = os.path.join(MEIPASS, 'huggingface')
+    logger.info(f"Running in frozen environment: {MEIPASS}")
+
+# Modified import checks for frozen environment
+YOLO_AVAILABLE = False
+YOLO = None
+torch = None
+TORCH_AVAILABLE = False
+ONNX_AVAILABLE = False
+TRANSFORMERS_AVAILABLE = False
+RTDetrForObjectDetection = None
+RTDetrImageProcessor = None
+PIL_AVAILABLE = False
+
+# Try to import YOLO dependencies with better error handling
+if IS_FROZEN:
+    # In frozen environment, try harder to import
+    try:
+        # First try to import torch components individually
+        import torch
+        import torch.nn
+        import torch.cuda
+        TORCH_AVAILABLE = True
+        logger.info("✓ PyTorch loaded in frozen environment")
+    except Exception as e:
+        logger.warning(f"PyTorch not available in frozen environment: {e}")
+        TORCH_AVAILABLE = False
+        torch = None
+    
+    # Try ultralytics after torch
+    if TORCH_AVAILABLE:
+        try:
+            from ultralytics import YOLO
+            YOLO_AVAILABLE = True
+            logger.info("✓ Ultralytics YOLO loaded in frozen environment")
+        except Exception as e:
+            logger.warning(f"Ultralytics not available in frozen environment: {e}")
+            YOLO_AVAILABLE = False
+    
+    # Try transformers
+    try:
+        import transformers
+        # Try specific imports
+        try:
+            from transformers import RTDetrForObjectDetection, RTDetrImageProcessor
+            TRANSFORMERS_AVAILABLE = True
+            logger.info("✓ Transformers RT-DETR loaded in frozen environment")
+        except ImportError:
+            # Try alternative import
+            try:
+                from transformers import AutoModel, AutoImageProcessor
+                RTDetrForObjectDetection = AutoModel
+                RTDetrImageProcessor = AutoImageProcessor
+                TRANSFORMERS_AVAILABLE = True
+                logger.info("✓ Transformers loaded with AutoModel fallback")
+            except:
+                TRANSFORMERS_AVAILABLE = False
+                logger.warning("Transformers RT-DETR not available in frozen environment")
+    except Exception as e:
+        logger.warning(f"Transformers not available in frozen environment: {e}")
+        TRANSFORMERS_AVAILABLE = False
+else:
+    # Normal environment - original import logic
+    try:
+        from ultralytics import YOLO
+        YOLO_AVAILABLE = True
+    except:
+        YOLO_AVAILABLE = False
+        logger.warning("Ultralytics YOLO not available")
+
+    try:
+        import torch
+        # Test if cuda attribute exists
+        _ = torch.cuda
+        TORCH_AVAILABLE = True
+    except (ImportError, AttributeError):
+        TORCH_AVAILABLE = False
+        torch = None
+        logger.warning("PyTorch not available or incomplete")
+
+    try:
+        from transformers import RTDetrForObjectDetection, RTDetrImageProcessor
+        try:
+            from transformers import RTDetrV2ForObjectDetection
+            RTDetrForObjectDetection = RTDetrV2ForObjectDetection
+        except ImportError:
+            pass
+        TRANSFORMERS_AVAILABLE = True
+    except:
+        TRANSFORMERS_AVAILABLE = False
+        logger.info("Transformers not available for RT-DETR")
+
+# Configure ORT memory behavior before importing
+try:
+    os.environ.setdefault('ORT_DISABLE_MEMORY_ARENA', '1')
+except Exception:
+    pass
+# ONNX Runtime - works well in frozen environments
+try:
+    import onnxruntime as ort
+    ONNX_AVAILABLE = True
+    logger.info("✓ ONNX Runtime available")
+except ImportError:
+    ONNX_AVAILABLE = False
+    logger.warning("ONNX Runtime not available")
+
+# PIL
+try:
+    from PIL import Image
+    PIL_AVAILABLE = True
+except ImportError:
+    PIL_AVAILABLE = False
+    logger.info("PIL not available")
+
+
+class BubbleDetector:
+    """
+    Combined YOLOv8 and RT-DETR speech bubble detector for comics and manga.
+    Supports multiple model formats and provides configurable detection.
+    Backward compatible with existing code while adding RT-DETR support.
+    """
+    
+    # Process-wide shared RT-DETR to avoid concurrent meta-device loads
+    _rtdetr_init_lock = threading.Lock()
+    _rtdetr_shared_model = None
+    _rtdetr_shared_processor = None
+    _rtdetr_loaded = False
+    _rtdetr_repo_id = 'ogkalu/comic-text-and-bubble-detector'
+    
+    # Shared RT-DETR (ONNX) across process to avoid device/context storms
+    _rtdetr_onnx_init_lock = threading.Lock()
+    _rtdetr_onnx_shared_session = None
+    _rtdetr_onnx_loaded = False
+    _rtdetr_onnx_providers = None
+    _rtdetr_onnx_model_path = None
+    # Limit DML concurrent runs to avoid DXGI device hang. Adjustable via env DML_MAX_CONCURRENT
+    try:
+        _rtdetr_onnx_max_concurrent = int(os.environ.get('DML_MAX_CONCURRENT', '1'))
+    except Exception:
+        _rtdetr_onnx_max_concurrent = 1
+    _rtdetr_onnx_sema = threading.Semaphore(max(1, _rtdetr_onnx_max_concurrent))
+    
+    def __init__(self, config_path: str = "config.json"):
+        """
+        Initialize the bubble detector.
+        
+        Args:
+            config_path: Path to configuration file
+        """
+        self.config_path = config_path
+        self.config = self._load_config()
+        
+        # YOLOv8 components (original)
+        self.model = None
+        self.model_loaded = False
+        self.model_type = None  # 'yolo', 'onnx', or 'torch'
+        self.onnx_session = None
+        
+        # RT-DETR components (new)
+        self.rtdetr_model = None
+        self.rtdetr_processor = None
+        self.rtdetr_loaded = False
+        self.rtdetr_repo = 'ogkalu/comic-text-and-bubble-detector'
+
+        # RT-DETR (ONNX) backend components
+        self.rtdetr_onnx_session = None
+        self.rtdetr_onnx_loaded = False
+        self.rtdetr_onnx_repo = 'ogkalu/comic-text-and-bubble-detector'
+        
+        # RT-DETR class definitions
+        self.CLASS_BUBBLE = 0      # Empty speech bubble
+        self.CLASS_TEXT_BUBBLE = 1 # Bubble with text
+        self.CLASS_TEXT_FREE = 2   # Text without bubble
+        
+        # Detection settings
+        self.default_confidence = 0.5
+        self.default_iou_threshold = 0.45
+        # Allow override from settings
+        try:
+            ocr_cfg = self.config.get('manga_settings', {}).get('ocr', {}) if isinstance(self.config, dict) else {}
+            self.default_max_detections = int(ocr_cfg.get('bubble_max_detections', 100))
+            self.max_det_yolo = int(ocr_cfg.get('bubble_max_detections_yolo', self.default_max_detections))
+            self.max_det_rtdetr = int(ocr_cfg.get('bubble_max_detections_rtdetr', self.default_max_detections))
+        except Exception:
+            self.default_max_detections = 100
+            self.max_det_yolo = 100
+            self.max_det_rtdetr = 100
+        
+        # Cache directory for ONNX conversions
+        self.cache_dir = os.environ.get('BUBBLE_CACHE_DIR', 'models')
+        os.makedirs(self.cache_dir, exist_ok=True)
+        
+        # GPU availability
+        self.use_gpu = TORCH_AVAILABLE and torch.cuda.is_available()
+        self.device = 'cuda' if self.use_gpu else 'cpu'
+        
+        # Quantization/precision settings
+        adv_cfg = self.config.get('manga_settings', {}).get('advanced', {}) if isinstance(self.config, dict) else {}
+        ocr_cfg = self.config.get('manga_settings', {}).get('ocr', {}) if isinstance(self.config, dict) else {}
+        env_quant = os.environ.get('MODEL_QUANTIZE', 'false').lower() == 'true'
+        self.quantize_enabled = bool(env_quant or adv_cfg.get('quantize_models', False) or ocr_cfg.get('quantize_bubble_detector', False))
+        self.quantize_dtype = str(adv_cfg.get('torch_precision', os.environ.get('TORCH_PRECISION', 'auto'))).lower()
+        # Prefer advanced.onnx_quantize; fall back to env or global quantize
+        self.onnx_quantize_enabled = bool(adv_cfg.get('onnx_quantize', os.environ.get('ONNX_QUANTIZE', 'false').lower() == 'true' or self.quantize_enabled))
+        
+        # Stop flag support
+        self.stop_flag = None
+        self._stopped = False
+        self.log_callback = None
+        
+        logger.info(f"🗨️ BubbleDetector initialized")
+        logger.info(f"   GPU: {'Available' if self.use_gpu else 'Not available'}")
+        logger.info(f"   YOLO: {'Available' if YOLO_AVAILABLE else 'Not installed'}")
+        logger.info(f"   ONNX: {'Available' if ONNX_AVAILABLE else 'Not installed'}")
+        logger.info(f"   RT-DETR: {'Available' if TRANSFORMERS_AVAILABLE else 'Not installed'}")
+        logger.info(f"   Quantization: {'ENABLED' if self.quantize_enabled else 'disabled'} (torch_precision={self.quantize_dtype}, onnx_quantize={'on' if self.onnx_quantize_enabled else 'off'})" )
+    
+    def _load_config(self) -> Dict[str, Any]:
+        """Load configuration from file."""
+        if os.path.exists(self.config_path):
+            try:
+                with open(self.config_path, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except Exception as e:
+                logger.warning(f"Failed to load config: {e}")
+        return {}
+    
+    def _save_config(self):
+        """Save configuration to file."""
+        try:
+            with open(self.config_path, 'w', encoding='utf-8') as f:
+                json.dump(self.config, f, indent=2)
+        except Exception as e:
+            logger.error(f"Failed to save config: {e}")
+    
+    def set_stop_flag(self, stop_flag):
+        """Set the stop flag for checking interruptions"""
+        self.stop_flag = stop_flag
+        self._stopped = False
+    
+    def set_log_callback(self, log_callback):
+        """Set log callback for GUI integration"""
+        self.log_callback = log_callback
+    
+    def _check_stop(self) -> bool:
+        """Check if stop has been requested"""
+        if self._stopped:
+            return True
+        if self.stop_flag and self.stop_flag.is_set():
+            self._stopped = True
+            return True
+        # Check global manga translator cancellation
+        try:
+            from manga_translator import MangaTranslator
+            if MangaTranslator.is_globally_cancelled():
+                self._stopped = True
+                return True
+        except Exception:
+            pass
+        return False
+    
+    def _log(self, message: str, level: str = "info"):
+        """Log message with stop suppression"""
+        # Suppress logs when stopped (allow only essential stop confirmation messages)
+        if self._check_stop():
+            essential_stop_keywords = [
+                "⏹️ Translation stopped by user",
+                "⏹️ Bubble detection stopped",
+                "cleanup", "🧹"
+            ]
+            if not any(keyword in message for keyword in essential_stop_keywords):
+                return
+        
+        if self.log_callback:
+            self.log_callback(message, level)
+        else:
+            logger.info(message) if level == 'info' else getattr(logger, level, logger.info)(message)
+    
+    def reset_stop_flags(self):
+        """Reset stop flags when starting new processing"""
+        self._stopped = False
+        
+    def load_model(self, model_path: str, force_reload: bool = False) -> bool:
+        """
+        Load a YOLOv8 model for bubble detection.
+        
+        Args:
+            model_path: Path to model file (.pt, .onnx, or .torchscript)
+            force_reload: Force reload even if model is already loaded
+            
+        Returns:
+            True if model loaded successfully, False otherwise
+        """
+        try:
+            # If given a Hugging Face repo ID (e.g., 'owner/name'), fetch detector.onnx into models/
+            if model_path and (('/' in model_path) and not os.path.exists(model_path)):
+                try:
+                    from huggingface_hub import hf_hub_download
+                    os.makedirs(self.cache_dir, exist_ok=True)
+                    logger.info(f"📥 Resolving repo '{model_path}' to detector.onnx in {self.cache_dir}...")
+                    resolved = hf_hub_download(repo_id=model_path, filename='detector.onnx', cache_dir=self.cache_dir, local_dir=self.cache_dir, local_dir_use_symlinks=False)
+                    if resolved and os.path.exists(resolved):
+                        model_path = resolved
+                        logger.info(f"✅ Downloaded detector.onnx to: {model_path}")
+                except Exception as repo_err:
+                    logger.error(f"Failed to download from repo '{model_path}': {repo_err}")
+            if not os.path.exists(model_path):
+                logger.error(f"Model file not found: {model_path}")
+                return False
+            
+            # Check if it's the same model already loaded
+            if self.model_loaded and not force_reload:
+                last_path = self.config.get('last_model_path', '')
+                if last_path == model_path:
+                    logger.info("Model already loaded (same path)")
+                    return True
+                else:
+                    logger.info(f"Model path changed from {last_path} to {model_path}, reloading...")
+                    force_reload = True
+            
+            # Clear previous model if force reload
+            if force_reload:
+                logger.info("Force reloading model...")
+                self.model = None
+                self.onnx_session = None
+                self.model_loaded = False
+                self.model_type = None
+            
+            logger.info(f"📥 Loading bubble detection model: {model_path}")
+            
+            # Determine model type by extension
+            ext = Path(model_path).suffix.lower()
+            
+            if ext in ['.pt', '.pth']:
+                if not YOLO_AVAILABLE:
+                    logger.warning("Ultralytics package not available in this build")
+                    logger.info("Bubble detection will be disabled - this is normal for lightweight builds")
+                    # Don't return False immediately, try other fallbacks
+                    self.model_loaded = False
+                    return False
+                
+                # Load YOLOv8 model
+                try:
+                    self.model = YOLO(model_path)
+                    self.model_type = 'yolo'
+                    
+                    # Set to eval mode
+                    if hasattr(self.model, 'model'):
+                        self.model.model.eval()
+                    
+                    # Move to GPU if available
+                    if self.use_gpu and TORCH_AVAILABLE:
+                        try:
+                            self.model.to('cuda')
+                        except Exception as gpu_error:
+                            logger.warning(f"Could not move model to GPU: {gpu_error}")
+                            
+                    logger.info("✅ YOLOv8 model loaded successfully")
+                    # Apply optional FP16 precision to reduce VRAM if enabled
+                    if self.quantize_enabled and self.use_gpu and TORCH_AVAILABLE:
+                        try:
+                            m = self.model.model if hasattr(self.model, 'model') else self.model
+                            m.half()
+                            logger.info("🔻 Applied FP16 precision to YOLO model (GPU)")
+                        except Exception as _e:
+                            logger.warning(f"Could not switch YOLO model to FP16: {_e}")
+                    
+                except Exception as yolo_error:
+                    logger.error(f"Failed to load YOLO model: {yolo_error}")
+                    return False
+                    
+            elif ext == '.onnx':
+                if not ONNX_AVAILABLE:
+                    logger.warning("ONNX Runtime not available in this build")
+                    logger.info("ONNX model support disabled - this is normal for lightweight builds")
+                    return False
+                
+                try:
+                    # Load ONNX model
+                    providers = ['CUDAExecutionProvider', 'CPUExecutionProvider'] if self.use_gpu else ['CPUExecutionProvider']
+                    session_path = model_path
+                    if self.quantize_enabled:
+                        try:
+                            from onnxruntime.quantization import quantize_dynamic, QuantType
+                            quant_path = os.path.splitext(model_path)[0] + ".int8.onnx"
+                            if not os.path.exists(quant_path) or os.environ.get('FORCE_ONNX_REBUILD', 'false').lower() == 'true':
+                                logger.info("🔻 Quantizing ONNX model weights to INT8 (dynamic)...")
+                                quantize_dynamic(model_input=model_path, model_output=quant_path, weight_type=QuantType.QInt8, op_types_to_quantize=['Conv', 'MatMul'])
+                            session_path = quant_path
+                            self.config['last_onnx_quantized_path'] = quant_path
+                            self._save_config()
+                            logger.info(f"✅ Using quantized ONNX model: {quant_path}")
+                        except Exception as qe:
+                            logger.warning(f"ONNX quantization not applied: {qe}")
+                    # Use conservative ORT memory options to reduce RAM growth
+                    so = ort.SessionOptions()
+                    try:
+                        so.enable_mem_pattern = False
+                        so.enable_cpu_mem_arena = False
+                    except Exception:
+                        pass
+                    self.onnx_session = ort.InferenceSession(session_path, sess_options=so, providers=providers)
+                    self.model_type = 'onnx'
+                    
+                    logger.info("✅ ONNX model loaded successfully")
+                    
+                except Exception as onnx_error:
+                    logger.error(f"Failed to load ONNX model: {onnx_error}")
+                    return False
+                    
+            elif ext == '.torchscript':
+                if not TORCH_AVAILABLE:
+                    logger.warning("PyTorch not available in this build")
+                    logger.info("TorchScript model support disabled - this is normal for lightweight builds")
+                    return False
+                
+                try:
+                    # Add safety check for torch being None
+                    if torch is None:
+                        logger.error("PyTorch module is None - cannot load TorchScript model")
+                        return False
+                        
+                    # Load TorchScript model
+                    self.model = torch.jit.load(model_path, map_location='cpu')
+                    self.model.eval()
+                    self.model_type = 'torch'
+                    
+                    if self.use_gpu:
+                        try:
+                            self.model = self.model.cuda()
+                        except Exception as gpu_error:
+                            logger.warning(f"Could not move TorchScript model to GPU: {gpu_error}")
+                    
+                    logger.info("✅ TorchScript model loaded successfully")
+                    
+                    # Optional FP16 precision on GPU
+                    if self.quantize_enabled and self.use_gpu and TORCH_AVAILABLE:
+                        try:
+                            self.model = self.model.half()
+                            logger.info("🔻 Applied FP16 precision to TorchScript model (GPU)")
+                        except Exception as _e:
+                            logger.warning(f"Could not switch TorchScript model to FP16: {_e}")
+                    
+                except Exception as torch_error:
+                    logger.error(f"Failed to load TorchScript model: {torch_error}")
+                    return False
+                    
+            else:
+                logger.error(f"Unsupported model format: {ext}")
+                logger.info("Supported formats: .pt/.pth (YOLOv8), .onnx (ONNX), .torchscript (TorchScript)")
+                return False
+            
+            # Only set loaded if we actually succeeded
+            self.model_loaded = True
+            self.config['last_model_path'] = model_path
+            self.config['model_type'] = self.model_type
+            self._save_config()
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to load model: {e}")
+            logger.error(traceback.format_exc())
+            self.model_loaded = False
+            
+            # Provide helpful context for .exe users
+            logger.info("Note: If running from .exe, some ML libraries may not be included")
+            logger.info("This is normal for lightweight builds - bubble detection will be disabled")
+            
+            return False
+    
+    def load_rtdetr_model(self, model_path: str = None, model_id: str = None, force_reload: bool = False) -> bool:
+        """
+        Load RT-DETR model for advanced bubble and text detection.
+        This implementation avoids the 'meta tensor' copy error by:
+        - Serializing the entire load under a class lock (no concurrent loads)
+        - Loading directly onto the target device (CUDA if available) via device_map='auto'
+        - Avoiding .to() on a potentially-meta model; no device migration post-load
+        
+        Args:
+            model_path: Optional path to local model
+            model_id: Optional HuggingFace model ID (default: 'ogkalu/comic-text-and-bubble-detector')
+            force_reload: Force reload even if already loaded
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        if not TRANSFORMERS_AVAILABLE:
+            logger.error("Transformers library required for RT-DETR. Install with: pip install transformers")
+            return False
+        
+        if not PIL_AVAILABLE:
+            logger.error("PIL required for RT-DETR. Install with: pip install pillow")
+            return False
+        
+        if self.rtdetr_loaded and not force_reload:
+            logger.info("RT-DETR model already loaded")
+            return True
+        
+        # Fast path: if shared already loaded and not forcing reload, attach
+        if BubbleDetector._rtdetr_loaded and not force_reload:
+            self.rtdetr_model = BubbleDetector._rtdetr_shared_model
+            self.rtdetr_processor = BubbleDetector._rtdetr_shared_processor
+            self.rtdetr_loaded = True
+            logger.info("RT-DETR model attached from shared cache")
+            return True
+        
+        # Serialize the ENTIRE loading sequence to avoid concurrent init issues
+        with BubbleDetector._rtdetr_init_lock:
+            try:
+                # Re-check after acquiring lock
+                if BubbleDetector._rtdetr_loaded and not force_reload:
+                    self.rtdetr_model = BubbleDetector._rtdetr_shared_model
+                    self.rtdetr_processor = BubbleDetector._rtdetr_shared_processor
+                    self.rtdetr_loaded = True
+                    logger.info("RT-DETR model attached from shared cache (post-lock)")
+                    return True
+                
+                # Use custom model_id if provided, otherwise use default
+                repo_id = model_id if model_id else self.rtdetr_repo
+                logger.info(f"📥 Loading RT-DETR model from {repo_id}...")
+
+                # Ensure TorchDynamo/compile doesn't interfere on some builds
+                try:
+                    os.environ.setdefault('TORCHDYNAMO_DISABLE', '1')
+                except Exception:
+                    pass
+                
+                # Decide device strategy
+                gpu_available = bool(TORCH_AVAILABLE and hasattr(torch, 'cuda') and torch.cuda.is_available())
+                device_map = 'auto' if gpu_available else None
+                # Choose dtype
+                dtype = None
+                if TORCH_AVAILABLE:
+                    try:
+                        dtype = torch.float16 if gpu_available else torch.float32
+                    except Exception:
+                        dtype = None
+                low_cpu = True if gpu_available else False
+                
+                # Load processor (once)
+                self.rtdetr_processor = RTDetrImageProcessor.from_pretrained(
+                    repo_id,
+                    size={"width": 640, "height": 640},
+                    cache_dir=self.cache_dir if not model_path else None
+                )
+                
+                # Prepare kwargs for from_pretrained
+                from_kwargs = {
+                    'cache_dir': self.cache_dir if not model_path else None,
+                    'low_cpu_mem_usage': low_cpu,
+                    'device_map': device_map,
+                }
+                if dtype is not None:
+                    from_kwargs['dtype'] = dtype
+                
+                # First attempt: load directly to target (CUDA if available)
+                try:
+                    self.rtdetr_model = RTDetrForObjectDetection.from_pretrained(
+                        model_path if model_path else repo_id,
+                        **from_kwargs,
+                    )
+                except Exception as primary_err:
+                    # Fallback to a simple CPU load (no device move) if CUDA path fails
+                    logger.warning(f"RT-DETR primary load failed ({primary_err}); retrying on CPU...")
+                    from_kwargs_fallback = {
+                        'cache_dir': self.cache_dir if not model_path else None,
+                        'low_cpu_mem_usage': False,
+                        'device_map': None,
+                    }
+                    if TORCH_AVAILABLE:
+                        from_kwargs_fallback['dtype'] = torch.float32
+                    self.rtdetr_model = RTDetrForObjectDetection.from_pretrained(
+                        model_path if model_path else repo_id,
+                        **from_kwargs_fallback,
+                    )
+                
+                # Optional dynamic quantization for linear layers (CPU only)
+                if self.quantize_enabled and TORCH_AVAILABLE and (not gpu_available):
+                    try:
+                        try:
+                            import torch.ao.quantization as tq
+                            quantize_dynamic = tq.quantize_dynamic  # type: ignore
+                        except Exception:
+                            import torch.quantization as tq  # type: ignore
+                            quantize_dynamic = tq.quantize_dynamic  # type: ignore
+                        self.rtdetr_model = quantize_dynamic(self.rtdetr_model, {torch.nn.Linear}, dtype=torch.qint8)
+                        logger.info("🔻 Applied dynamic INT8 quantization to RT-DETR linear layers (CPU)")
+                    except Exception as qe:
+                        logger.warning(f"RT-DETR dynamic quantization skipped: {qe}")
+                
+                # Finalize
+                self.rtdetr_model.eval()
+
+                # Sanity check: ensure no parameter is left on 'meta' device
+                try:
+                    for n, p in self.rtdetr_model.named_parameters():
+                        dev = getattr(p, 'device', None)
+                        if dev is not None and getattr(dev, 'type', '') == 'meta':
+                            raise RuntimeError(f"Parameter {n} is on 'meta' device after load")
+                except Exception as e:
+                    logger.error(f"RT-DETR load sanity check failed: {e}")
+                    self.rtdetr_loaded = False
+                    return False
+
+                # Publish shared cache
+                BubbleDetector._rtdetr_shared_model = self.rtdetr_model
+                BubbleDetector._rtdetr_shared_processor = self.rtdetr_processor
+                BubbleDetector._rtdetr_loaded = True
+                BubbleDetector._rtdetr_repo_id = repo_id
+
+                self.rtdetr_loaded = True
+                
+                # Save the model ID that was used
+                self.config['rtdetr_loaded'] = True
+                self.config['rtdetr_model_id'] = repo_id
+                self._save_config()
+                
+                loc = 'CUDA' if gpu_available else 'CPU'
+                logger.info(f"✅ RT-DETR model loaded successfully ({loc})")
+                logger.info("   Classes: Empty bubbles, Text bubbles, Free text")
+                
+                # Auto-convert to ONNX for RT-DETR only if explicitly enabled
+                if os.environ.get('AUTO_CONVERT_RTDETR_ONNX', 'false').lower() == 'true':
+                    onnx_path = os.path.join(self.cache_dir, 'rtdetr_comic.onnx')
+                    if self.convert_to_onnx('rtdetr', onnx_path):
+                        logger.info("🚀 RT-DETR converted to ONNX for faster inference")
+                        # Store ONNX path for later use
+                        self.config['rtdetr_onnx_path'] = onnx_path
+                        self._save_config()
+                        # Optionally quantize ONNX for reduced RAM
+                        if self.onnx_quantize_enabled:
+                            try:
+                                from onnxruntime.quantization import quantize_dynamic, QuantType
+                                quant_path = os.path.splitext(onnx_path)[0] + ".int8.onnx"
+                                if not os.path.exists(quant_path) or os.environ.get('FORCE_ONNX_REBUILD', 'false').lower() == 'true':
+                                    logger.info("🔻 Quantizing RT-DETR ONNX to INT8 (dynamic)...")
+                                    quantize_dynamic(model_input=onnx_path, model_output=quant_path, weight_type=QuantType.QInt8, op_types_to_quantize=['Conv', 'MatMul'])
+                                self.config['rtdetr_onnx_quantized_path'] = quant_path
+                                self._save_config()
+                                logger.info(f"✅ Quantized RT-DETR ONNX saved to: {quant_path}")
+                            except Exception as qe:
+                                logger.warning(f"ONNX quantization for RT-DETR skipped: {qe}")
+                    else:
+                        logger.info("ℹ️ Skipping RT-DETR ONNX export (converter not supported in current environment)")
+                
+                return True
+            except Exception as e:
+                logger.error(f"❌ Failed to load RT-DETR: {e}")
+                self.rtdetr_loaded = False
+                return False
+ 
+    def check_rtdetr_available(self, model_id: str = None) -> bool:
+        """
+        Check if RT-DETR model is available (cached).
+        
+        Args:
+            model_id: Optional HuggingFace model ID
+            
+        Returns:
+            True if model is cached and available
+        """
+        try:
+            from pathlib import Path
+            
+            # Use provided model_id or default
+            repo_id = model_id if model_id else self.rtdetr_repo
+            
+            # Check HuggingFace cache
+            cache_dir = Path.home() / ".cache" / "huggingface" / "hub"
+            model_id_formatted = repo_id.replace("/", "--")
+            
+            # Look for model folder
+            model_folders = list(cache_dir.glob(f"models--{model_id_formatted}*"))
+            
+            if model_folders:
+                for folder in model_folders:
+                    if (folder / "snapshots").exists():
+                        snapshots = list((folder / "snapshots").iterdir())
+                        if snapshots:
+                            return True
+            
+            return False
+            
+        except Exception:
+            return False
+        
+    def detect_bubbles(self, 
+                      image_path: str, 
+                      confidence: float = None,
+                      iou_threshold: float = None,
+                      max_detections: int = None,
+                      use_rtdetr: bool = None) -> List[Tuple[int, int, int, int]]:
+        """
+        Detect speech bubbles in an image (backward compatible method).
+        
+        Args:
+            image_path: Path to image file
+            confidence: Minimum confidence threshold (0-1)
+            iou_threshold: IOU threshold for NMS (0-1)
+            max_detections: Maximum number of detections to return
+            use_rtdetr: If True, use RT-DETR instead of YOLOv8 (if available)
+            
+        Returns:
+            List of bubble bounding boxes as (x, y, width, height) tuples
+        """
+        # Check for stop at start
+        if self._check_stop():
+            self._log("⏹️ Bubble detection stopped by user", "warning")
+            return []
+        
+        # Decide which model to use
+        if use_rtdetr is None:
+            # Auto-select: prefer RT-DETR if available
+            use_rtdetr = self.rtdetr_loaded
+        
+        if use_rtdetr:
+            # Prefer ONNX backend if available, else PyTorch
+            if getattr(self, 'rtdetr_onnx_loaded', False):
+                results = self.detect_with_rtdetr_onnx(
+                    image_path=image_path,
+                    confidence=confidence,
+                    return_all_bubbles=True
+                )
+                return results
+            if self.rtdetr_loaded:
+                results = self.detect_with_rtdetr(
+                    image_path=image_path,
+                    confidence=confidence,
+                    return_all_bubbles=True
+                )
+                return results
+        
+        # Original YOLOv8 detection
+        if not self.model_loaded:
+            logger.error("No model loaded. Call load_model() first.")
+            return []
+        
+        # Use defaults if not specified
+        confidence = confidence or self.default_confidence
+        iou_threshold = iou_threshold or self.default_iou_threshold
+        max_detections = max_detections or self.default_max_detections
+        
+        try:
+            # Load image
+            image = cv2.imread(image_path)
+            if image is None:
+                logger.error(f"Failed to load image: {image_path}")
+                return []
+            
+            h, w = image.shape[:2]
+            self._log(f"🔍 Detecting bubbles in {w}x{h} image")
+            
+            # Check for stop before inference
+            if self._check_stop():
+                self._log("⏹️ Bubble detection inference stopped by user", "warning")
+                return []
+            
+            if self.model_type == 'yolo':
+                # YOLOv8 inference
+                results = self.model(
+                    image_path,
+                    conf=confidence,
+                    iou=iou_threshold,
+                    max_det=min(max_detections, getattr(self, 'max_det_yolo', max_detections)),
+                    verbose=False
+                )
+                
+                bubbles = []
+                for r in results:
+                    if r.boxes is not None:
+                        for box in r.boxes:
+                            # Get box coordinates
+                            x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+                            x, y = int(x1), int(y1)
+                            width = int(x2 - x1)
+                            height = int(y2 - y1)
+                            
+                            # Get confidence
+                            conf = float(box.conf[0])
+                            
+                            # Add to list
+                            if len(bubbles) < max_detections:
+                                bubbles.append((x, y, width, height))
+                            
+                            logger.debug(f"   Bubble: ({x},{y}) {width}x{height} conf={conf:.2f}")
+                
+            elif self.model_type == 'onnx':
+                # ONNX inference
+                bubbles = self._detect_with_onnx(image, confidence, iou_threshold, max_detections)
+                
+            elif self.model_type == 'torch':
+                # TorchScript inference
+                bubbles = self._detect_with_torchscript(image, confidence, iou_threshold, max_detections)
+            
+            else:
+                logger.error(f"Unknown model type: {self.model_type}")
+                return []
+            
+            logger.info(f"✅ Detected {len(bubbles)} speech bubbles")
+            time.sleep(0.1)  # Brief pause for stability
+            logger.debug("💤 Bubble detection pausing briefly for stability")
+            return bubbles
+            
+        except Exception as e:
+            logger.error(f"Detection failed: {e}")
+            logger.error(traceback.format_exc())
+            return []
+    
+    def detect_with_rtdetr(self,
+                          image_path: str = None,
+                          image: np.ndarray = None,
+                          confidence: float = None,
+                          return_all_bubbles: bool = False) -> Any:
+        """
+        Detect using RT-DETR model with 3-class detection (PyTorch backend).
+        
+        Args:
+            image_path: Path to image file
+            image: Image array (BGR format)
+            confidence: Confidence threshold
+            return_all_bubbles: If True, return list of bubble boxes (for compatibility)
+                               If False, return dict with all classes
+        
+        Returns:
+            List of bubbles if return_all_bubbles=True, else dict with classes
+        """
+        # Check for stop at start
+        if self._check_stop():
+            self._log("⏹️ RT-DETR detection stopped by user", "warning")
+            if return_all_bubbles:
+                return []
+            return {'bubbles': [], 'text_bubbles': [], 'text_free': []}
+        
+        if not self.rtdetr_loaded:
+            self._log("RT-DETR not loaded. Call load_rtdetr_model() first.", "warning")
+            if return_all_bubbles:
+                return []
+            return {'bubbles': [], 'text_bubbles': [], 'text_free': []}
+        
+        confidence = confidence or self.default_confidence
+        
+        try:
+            # Load image
+            if image_path:
+                image = cv2.imread(image_path)
+            elif image is None:
+                logger.error("No image provided")
+                if return_all_bubbles:
+                    return []
+                return {'bubbles': [], 'text_bubbles': [], 'text_free': []}
+            
+            # Convert BGR to RGB for PIL
+            image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            pil_image = Image.fromarray(image_rgb)
+            
+            # Prepare image for model
+            inputs = self.rtdetr_processor(images=pil_image, return_tensors="pt")
+            
+            # Move inputs to the same device as the model and match model dtype for floating tensors
+            model_device = next(self.rtdetr_model.parameters()).device if self.rtdetr_model is not None else (torch.device('cpu') if TORCH_AVAILABLE else 'cpu')
+            model_dtype = None
+            if TORCH_AVAILABLE and self.rtdetr_model is not None:
+                try:
+                    model_dtype = next(self.rtdetr_model.parameters()).dtype
+                except Exception:
+                    model_dtype = None
+            
+            if TORCH_AVAILABLE:
+                new_inputs = {}
+                for k, v in inputs.items():
+                    if isinstance(v, torch.Tensor):
+                        v = v.to(model_device)
+                        if model_dtype is not None and torch.is_floating_point(v):
+                            v = v.to(model_dtype)
+                    new_inputs[k] = v
+                inputs = new_inputs
+            
+            # Run inference with autocast when model is half/bfloat16 on CUDA
+            use_amp = TORCH_AVAILABLE and hasattr(model_device, 'type') and model_device.type == 'cuda' and (model_dtype in (torch.float16, torch.bfloat16))
+            autocast_dtype = model_dtype if model_dtype in (torch.float16, torch.bfloat16) else None
+            
+            with torch.no_grad():
+                if use_amp and autocast_dtype is not None:
+                    with torch.autocast('cuda', dtype=autocast_dtype):
+                        outputs = self.rtdetr_model(**inputs)
+                else:
+                    outputs = self.rtdetr_model(**inputs)
+                
+                # Brief pause for stability after inference
+                time.sleep(0.1)
+                logger.debug("💤 RT-DETR inference pausing briefly for stability")
+            
+            # Post-process results
+            target_sizes = torch.tensor([pil_image.size[::-1]]) if TORCH_AVAILABLE else None
+            if TORCH_AVAILABLE and hasattr(model_device, 'type') and model_device.type == "cuda":
+                target_sizes = target_sizes.to(model_device)
+            
+            results = self.rtdetr_processor.post_process_object_detection(
+                outputs,
+                target_sizes=target_sizes,
+                threshold=confidence
+            )[0]
+            
+            # Apply per-detector cap if configured
+            cap = getattr(self, 'max_det_rtdetr', self.default_max_detections)
+            if cap and len(results['boxes']) > cap:
+                # Keep top-scoring first
+                scores = results['scores']
+                top_idx = scores.topk(k=cap).indices if hasattr(scores, 'topk') else range(cap)
+                results = {
+                    'boxes': [results['boxes'][i] for i in top_idx],
+                    'scores': [results['scores'][i] for i in top_idx],
+                    'labels': [results['labels'][i] for i in top_idx]
+                }
+            
+            logger.info(f"📊 RT-DETR found {len(results['boxes'])} detections above {confidence:.2f} confidence")
+
+            # Organize detections by class
+            detections = {
+                'bubbles': [],       # Empty speech bubbles
+                'text_bubbles': [],  # Bubbles with text
+                'text_free': []      # Text without bubbles
+            }
+            
+            for box, score, label in zip(results['boxes'], results['scores'], results['labels']):
+                x1, y1, x2, y2 = map(int, box.tolist())
+                width = x2 - x1
+                height = y2 - y1
+                
+                # Store as (x, y, width, height) to match YOLOv8 format
+                bbox = (x1, y1, width, height)
+                
+                label_id = label.item()
+                if label_id == self.CLASS_BUBBLE:
+                    detections['bubbles'].append(bbox)
+                elif label_id == self.CLASS_TEXT_BUBBLE:
+                    detections['text_bubbles'].append(bbox)
+                elif label_id == self.CLASS_TEXT_FREE:
+                    detections['text_free'].append(bbox)
+                
+                # Stop early if we hit the configured cap across all classes
+                total_count = len(detections['bubbles']) + len(detections['text_bubbles']) + len(detections['text_free'])
+                if total_count >= (self.config.get('manga_settings', {}).get('ocr', {}).get('bubble_max_detections', self.default_max_detections) if isinstance(self.config, dict) else self.default_max_detections):
+                    break
+            
+            # Log results
+            total = len(detections['bubbles']) + len(detections['text_bubbles']) + len(detections['text_free'])
+            logger.info(f"✅ RT-DETR detected {total} objects:")
+            logger.info(f"   - Empty bubbles: {len(detections['bubbles'])}")
+            logger.info(f"   - Text bubbles: {len(detections['text_bubbles'])}")
+            logger.info(f"   - Free text: {len(detections['text_free'])}")
+            
+            # Return format based on compatibility mode
+            if return_all_bubbles:
+                # Return all bubbles (empty + with text) for backward compatibility
+                all_bubbles = detections['bubbles'] + detections['text_bubbles']
+                return all_bubbles
+            else:
+                return detections
+            
+        except Exception as e:
+            logger.error(f"RT-DETR detection failed: {e}")
+            logger.error(traceback.format_exc())
+            if return_all_bubbles:
+                return []
+            return {'bubbles': [], 'text_bubbles': [], 'text_free': []}
+    
+    def detect_all_text_regions(self, image_path: str = None, image: np.ndarray = None) -> List[Tuple[int, int, int, int]]:
+        """
+        Detect all text regions using RT-DETR (both in bubbles and free text).
+        
+        Returns:
+            List of bounding boxes for all text regions
+        """
+        if not self.rtdetr_loaded:
+            logger.warning("RT-DETR required for text detection")
+            return []
+        
+        detections = self.detect_with_rtdetr(image_path=image_path, image=image, return_all_bubbles=False)
+        
+        # Combine text bubbles and free text
+        all_text = detections['text_bubbles'] + detections['text_free']
+        
+        logger.info(f"📝 Found {len(all_text)} text regions total")
+        return all_text
+    
+    def _detect_with_onnx(self, image: np.ndarray, confidence: float, 
+                         iou_threshold: float, max_detections: int) -> List[Tuple[int, int, int, int]]:
+        """Run detection using ONNX model."""
+        # Preprocess image
+        img_size = 640  # Standard YOLOv8 input size
+        img_resized = cv2.resize(image, (img_size, img_size))
+        img_norm = img_resized.astype(np.float32) / 255.0
+        img_transposed = np.transpose(img_norm, (2, 0, 1))
+        img_batch = np.expand_dims(img_transposed, axis=0)
+        
+        # Run inference
+        input_name = self.onnx_session.get_inputs()[0].name
+        outputs = self.onnx_session.run(None, {input_name: img_batch})
+        
+        # Process outputs (YOLOv8 format)
+        predictions = outputs[0][0]  # Remove batch dimension
+        
+        # Filter by confidence and apply NMS
+        bubbles = []
+        boxes = []
+        scores = []
+        
+        for pred in predictions.T:  # Transpose to get predictions per detection
+            if len(pred) >= 5:
+                x_center, y_center, width, height, obj_conf = pred[:5]
+                
+                if obj_conf >= confidence:
+                    # Convert to corner coordinates
+                    x1 = x_center - width / 2
+                    y1 = y_center - height / 2
+                    
+                    # Scale to original image size
+                    h, w = image.shape[:2]
+                    x1 = int(x1 * w / img_size)
+                    y1 = int(y1 * h / img_size)
+                    width = int(width * w / img_size)
+                    height = int(height * h / img_size)
+                    
+                    boxes.append([x1, y1, x1 + width, y1 + height])
+                    scores.append(float(obj_conf))
+        
+        # Apply NMS
+        if boxes:
+            indices = cv2.dnn.NMSBoxes(boxes, scores, confidence, iou_threshold)
+            if len(indices) > 0:
+                indices = indices.flatten()[:max_detections]
+                for i in indices:
+                    x1, y1, x2, y2 = boxes[i]
+                    bubbles.append((x1, y1, x2 - x1, y2 - y1))
+        
+        return bubbles
+    
+    def _detect_with_torchscript(self, image: np.ndarray, confidence: float,
+                                 iou_threshold: float, max_detections: int) -> List[Tuple[int, int, int, int]]:
+        """Run detection using TorchScript model."""
+        # Similar to ONNX but using PyTorch tensors
+        img_size = 640
+        img_resized = cv2.resize(image, (img_size, img_size))
+        img_norm = img_resized.astype(np.float32) / 255.0
+        img_tensor = torch.from_numpy(img_norm).permute(2, 0, 1).unsqueeze(0)
+        
+        if self.use_gpu:
+            img_tensor = img_tensor.cuda()
+        
+        with torch.no_grad():
+            outputs = self.model(img_tensor)
+        
+        # Process outputs similar to ONNX
+        # Implementation depends on exact model output format
+        # This is a placeholder - adjust based on your model
+        return []
+    
+    def visualize_detections(self, image_path: str, bubbles: List[Tuple[int, int, int, int]] = None, 
+                            output_path: str = None, use_rtdetr: bool = False) -> np.ndarray:
+        """
+        Visualize detected bubbles on the image.
+        
+        Args:
+            image_path: Path to original image
+            bubbles: List of bubble bounding boxes (if None, will detect)
+            output_path: Optional path to save visualization
+            use_rtdetr: Use RT-DETR for visualization with class colors
+            
+        Returns:
+            Image with drawn bounding boxes
+        """
+        image = cv2.imread(image_path)
+        if image is None:
+            logger.error(f"Failed to load image: {image_path}")
+            return None
+        
+        vis_image = image.copy()
+        
+        if use_rtdetr and self.rtdetr_loaded:
+            # RT-DETR visualization with different colors per class
+            detections = self.detect_with_rtdetr(image_path=image_path, return_all_bubbles=False)
+            
+            # Colors for each class
+            colors = {
+                'bubbles': (0, 255, 0),       # Green for empty bubbles
+                'text_bubbles': (255, 0, 0),  # Blue for text bubbles
+                'text_free': (0, 0, 255)      # Red for free text
+            }
+            
+            # Draw detections
+            for class_name, bboxes in detections.items():
+                color = colors[class_name]
+                
+                for i, (x, y, w, h) in enumerate(bboxes):
+                    # Draw rectangle
+                    cv2.rectangle(vis_image, (x, y), (x + w, y + h), color, 2)
+                    
+                    # Add label
+                    label = f"{class_name.replace('_', ' ').title()} {i+1}"
+                    label_size, _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)
+                    cv2.rectangle(vis_image, (x, y - label_size[1] - 4), 
+                                (x + label_size[0], y), color, -1)
+                    cv2.putText(vis_image, label, (x, y - 2), 
+                              cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+        else:
+            # Original YOLOv8 visualization
+            if bubbles is None:
+                bubbles = self.detect_bubbles(image_path)
+            
+            # Draw bounding boxes
+            for i, (x, y, w, h) in enumerate(bubbles):
+                # Draw rectangle
+                color = (0, 255, 0)  # Green
+                thickness = 2
+                cv2.rectangle(vis_image, (x, y), (x + w, y + h), color, thickness)
+                
+                # Add label
+                label = f"Bubble {i+1}"
+                label_size, _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)
+                cv2.rectangle(vis_image, (x, y - label_size[1] - 4), (x + label_size[0], y), color, -1)
+                cv2.putText(vis_image, label, (x, y - 2), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+        
+        # Save if output path provided
+        if output_path:
+            cv2.imwrite(output_path, vis_image)
+            logger.info(f"💾 Visualization saved to: {output_path}")
+        
+        return vis_image
+    
+    def convert_to_onnx(self, model_path: str, output_path: str = None) -> bool:
+        """
+        Convert a YOLOv8 or RT-DETR model to ONNX format.
+        
+        Args:
+            model_path: Path to model file or 'rtdetr' for loaded RT-DETR
+            output_path: Path for ONNX output (auto-generated if None)
+            
+        Returns:
+            True if conversion successful, False otherwise
+        """
+        try:
+            logger.info(f"🔄 Converting {model_path} to ONNX...")
+            
+            # Generate output path if not provided
+            if output_path is None:
+                if model_path == 'rtdetr' and self.rtdetr_loaded:
+                    base_name = 'rtdetr_comic'
+                else:
+                    base_name = Path(model_path).stem
+                output_path = os.path.join(self.cache_dir, f"{base_name}.onnx")
+            
+            # Check if already exists
+            if os.path.exists(output_path) and not os.environ.get('FORCE_ONNX_REBUILD', 'false').lower() == 'true':
+                logger.info(f"✅ ONNX model already exists: {output_path}")
+                return True
+            
+            # Handle RT-DETR conversion
+            if model_path == 'rtdetr' and self.rtdetr_loaded:
+                if not TORCH_AVAILABLE:
+                    logger.error("PyTorch required for RT-DETR ONNX conversion")
+                    return False
+                
+                # RT-DETR specific conversion
+                self.rtdetr_model.eval()
+                
+                # Create dummy input (pixel values): BxCxHxW
+                dummy_input = torch.randn(1, 3, 640, 640)
+                if self.device == 'cuda':
+                    dummy_input = dummy_input.to('cuda')
+                
+                # Wrap the model to return only tensors (logits, pred_boxes)
+                class _RTDetrExportWrapper(torch.nn.Module):
+                    def __init__(self, mdl):
+                        super().__init__()
+                        self.mdl = mdl
+                    def forward(self, images):
+                        out = self.mdl(pixel_values=images)
+                        # Handle dict/ModelOutput/tuple outputs
+                        logits = None
+                        boxes = None
+                        try:
+                            if isinstance(out, dict):
+                                logits = out.get('logits', None)
+                                boxes = out.get('pred_boxes', out.get('boxes', None))
+                            else:
+                                logits = getattr(out, 'logits', None)
+                                boxes = getattr(out, 'pred_boxes', getattr(out, 'boxes', None))
+                        except Exception:
+                            pass
+                        if (logits is None or boxes is None) and isinstance(out, (tuple, list)) and len(out) >= 2:
+                            logits, boxes = out[0], out[1]
+                        return logits, boxes
+                
+                wrapper = _RTDetrExportWrapper(self.rtdetr_model)
+                if self.device == 'cuda':
+                    wrapper = wrapper.to('cuda')
+                
+                # Try PyTorch 2.x dynamo_export first (more tolerant of newer aten ops)
+                try:
+                    success = False
+                    try:
+                        from torch.onnx import dynamo_export
+                        try:
+                            exp = dynamo_export(wrapper, dummy_input)
+                        except TypeError:
+                            # Older PyTorch dynamo_export may not support this calling convention
+                            exp = dynamo_export(wrapper, dummy_input)
+                        # exp may have save(); otherwise, it may expose model_proto
+                        try:
+                            exp.save(output_path)  # type: ignore
+                            success = True
+                        except Exception:
+                            try:
+                                import onnx as _onnx
+                                _onnx.save(exp.model_proto, output_path)  # type: ignore
+                                success = True
+                            except Exception as _se:
+                                logger.warning(f"dynamo_export produced model but could not save: {_se}")
+                    except Exception as de:
+                        logger.warning(f"dynamo_export failed; falling back to legacy exporter: {de}")
+                    if success:
+                        logger.info(f"✅ RT-DETR ONNX saved to: {output_path} (dynamo_export)")
+                        return True
+                except Exception as de2:
+                    logger.warning(f"dynamo_export path error: {de2}")
+
+                # Legacy exporter with opset fallback
+                last_err = None
+                for opset in [19, 18, 17, 16, 15, 14, 13]:
+                    try:
+                        torch.onnx.export(
+                            wrapper,
+                            dummy_input,
+                            output_path,
+                            export_params=True,
+                            opset_version=opset,
+                            do_constant_folding=True,
+                            input_names=['pixel_values'],
+                            output_names=['logits', 'boxes'],
+                            dynamic_axes={
+                                'pixel_values': {0: 'batch', 2: 'height', 3: 'width'},
+                                'logits': {0: 'batch'},
+                                'boxes': {0: 'batch'}
+                            }
+                        )
+                        logger.info(f"✅ RT-DETR ONNX saved to: {output_path} (opset {opset})")
+                        return True
+                    except Exception as _e:
+                        last_err = _e
+                        try:
+                            msg = str(_e)
+                        except Exception:
+                            msg = ''
+                        logger.warning(f"RT-DETR ONNX export failed at opset {opset}: {msg}")
+                        continue
+                
+                logger.error(f"All RT-DETR ONNX export attempts failed. Last error: {last_err}")
+                return False
+            
+            # Handle YOLOv8 conversion - FIXED
+            elif YOLO_AVAILABLE and os.path.exists(model_path):
+                logger.info(f"Loading YOLOv8 model from: {model_path}")
+                
+                # Load model
+                model = YOLO(model_path)
+                
+                # Export to ONNX - this returns the path to the exported model
+                logger.info("Exporting to ONNX format...")
+                exported_path = model.export(format='onnx', imgsz=640, simplify=True)
+                
+                # exported_path could be a string or Path object
+                exported_path = str(exported_path) if exported_path else None
+                
+                if exported_path and os.path.exists(exported_path):
+                    # Move to desired location if different
+                    if exported_path != output_path:
+                        import shutil
+                        logger.info(f"Moving ONNX from {exported_path} to {output_path}")
+                        shutil.move(exported_path, output_path)
+                    
+                    logger.info(f"✅ YOLOv8 ONNX saved to: {output_path}")
+                    return True
+                else:
+                    # Fallback: check if it was created with expected name
+                    expected_onnx = model_path.replace('.pt', '.onnx')
+                    if os.path.exists(expected_onnx):
+                        if expected_onnx != output_path:
+                            import shutil
+                            shutil.move(expected_onnx, output_path)
+                        logger.info(f"✅ YOLOv8 ONNX saved to: {output_path}")
+                        return True
+                    else:
+                        logger.error(f"ONNX export failed - no output file found")
+                        return False
+            
+            else:
+                logger.error(f"Cannot convert {model_path}: Model not found or dependencies missing")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Conversion failed: {e}")
+            # Avoid noisy full stack trace in production logs; return False gracefully
+            return False
+    
+    def batch_detect(self, image_paths: List[str], **kwargs) -> Dict[str, List[Tuple[int, int, int, int]]]:
+        """
+        Detect bubbles in multiple images.
+        
+        Args:
+            image_paths: List of image paths
+            **kwargs: Detection parameters (confidence, iou_threshold, max_detections, use_rtdetr)
+            
+        Returns:
+            Dictionary mapping image paths to bubble lists
+        """
+        results = {}
+        
+        for i, image_path in enumerate(image_paths):
+            logger.info(f"Processing image {i+1}/{len(image_paths)}: {os.path.basename(image_path)}")
+            bubbles = self.detect_bubbles(image_path, **kwargs)
+            results[image_path] = bubbles
+        
+        return results
+    
+    def unload(self, release_shared: bool = False):
+        """Release model resources held by this detector instance.
+        Args:
+            release_shared: If True, also clear class-level shared RT-DETR caches.
+        """
+        try:
+            # Release instance-level models and sessions
+            try:
+                if getattr(self, 'onnx_session', None) is not None:
+                    self.onnx_session = None
+            except Exception:
+                pass
+            try:
+                if getattr(self, 'rtdetr_onnx_session', None) is not None:
+                    self.rtdetr_onnx_session = None
+            except Exception:
+                pass
+            for attr in ['model', 'rtdetr_model', 'rtdetr_processor']:
+                try:
+                    if hasattr(self, attr):
+                        setattr(self, attr, None)
+                except Exception:
+                    pass
+            for flag in ['model_loaded', 'rtdetr_loaded', 'rtdetr_onnx_loaded']:
+                try:
+                    if hasattr(self, flag):
+                        setattr(self, flag, False)
+                except Exception:
+                    pass
+
+            # Optional: release shared caches
+            if release_shared:
+                try:
+                    BubbleDetector._rtdetr_shared_model = None
+                    BubbleDetector._rtdetr_shared_processor = None
+                    BubbleDetector._rtdetr_loaded = False
+                except Exception:
+                    pass
+
+            # Free CUDA cache and trigger GC
+            try:
+                if TORCH_AVAILABLE and torch is not None and torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+            except Exception:
+                pass
+            try:
+                import gc
+                gc.collect()
+            except Exception:
+                pass
+        except Exception:
+            # Best-effort only
+            pass
+
+    def get_bubble_masks(self, image_path: str, bubbles: List[Tuple[int, int, int, int]]) -> np.ndarray:
+        """
+        Create a mask image with bubble regions.
+        
+        Args:
+            image_path: Path to original image
+            bubbles: List of bubble bounding boxes
+            
+        Returns:
+            Binary mask with bubble regions as white (255)
+        """
+        image = cv2.imread(image_path)
+        if image is None:
+            return None
+        
+        h, w = image.shape[:2]
+        mask = np.zeros((h, w), dtype=np.uint8)
+        
+        # Fill bubble regions
+        for x, y, bw, bh in bubbles:
+            cv2.rectangle(mask, (x, y), (x + bw, y + bh), 255, -1)
+        
+        return mask
+    
+    def filter_bubbles_by_size(self, bubbles: List[Tuple[int, int, int, int]], 
+                              min_area: int = 100, 
+                              max_area: int = None) -> List[Tuple[int, int, int, int]]:
+        """
+        Filter bubbles by area.
+        
+        Args:
+            bubbles: List of bubble bounding boxes
+            min_area: Minimum area in pixels
+            max_area: Maximum area in pixels (None for no limit)
+            
+        Returns:
+            Filtered list of bubbles
+        """
+        filtered = []
+        
+        for x, y, w, h in bubbles:
+            area = w * h
+            if area >= min_area and (max_area is None or area <= max_area):
+                filtered.append((x, y, w, h))
+        
+        return filtered
+    
+    def merge_overlapping_bubbles(self, bubbles: List[Tuple[int, int, int, int]], 
+                                 overlap_threshold: float = 0.1) -> List[Tuple[int, int, int, int]]:
+        """
+        Merge overlapping bubble detections.
+        
+        Args:
+            bubbles: List of bubble bounding boxes
+            overlap_threshold: Minimum overlap ratio to merge
+            
+        Returns:
+            Merged list of bubbles
+        """
+        if not bubbles:
+            return []
+        
+        # Convert to numpy array for easier manipulation
+        boxes = np.array([(x, y, x+w, y+h) for x, y, w, h in bubbles])
+        
+        merged = []
+        used = set()
+        
+        for i, box1 in enumerate(boxes):
+            if i in used:
+                continue
+            
+            # Start with current box
+            x1, y1, x2, y2 = box1
+            
+            # Check for overlaps with remaining boxes
+            for j in range(i + 1, len(boxes)):
+                if j in used:
+                    continue
+                
+                box2 = boxes[j]
+                
+                # Calculate intersection
+                ix1 = max(x1, box2[0])
+                iy1 = max(y1, box2[1])
+                ix2 = min(x2, box2[2])
+                iy2 = min(y2, box2[3])
+                
+                if ix1 < ix2 and iy1 < iy2:
+                    # Calculate overlap ratio
+                    intersection = (ix2 - ix1) * (iy2 - iy1)
+                    area1 = (x2 - x1) * (y2 - y1)
+                    area2 = (box2[2] - box2[0]) * (box2[3] - box2[1])
+                    overlap = intersection / min(area1, area2)
+                    
+                    if overlap >= overlap_threshold:
+                        # Merge boxes
+                        x1 = min(x1, box2[0])
+                        y1 = min(y1, box2[1])
+                        x2 = max(x2, box2[2])
+                        y2 = max(y2, box2[3])
+                        used.add(j)
+            
+            merged.append((int(x1), int(y1), int(x2 - x1), int(y2 - y1)))
+        
+        return merged
+
+    # ============================
+    # RT-DETR (ONNX) BACKEND
+    # ============================
+    def load_rtdetr_onnx_model(self, model_id: str = None, force_reload: bool = False) -> bool:
+        """
+        Load RT-DETR ONNX model using onnxruntime. Downloads detector.onnx and config.json
+        from the provided Hugging Face repo if not already cached.
+        """
+        if not ONNX_AVAILABLE:
+            logger.error("ONNX Runtime not available for RT-DETR ONNX backend")
+            return False
+        try:
+            # If singleton mode and already loaded, just attach shared session
+            try:
+                adv = (self.config or {}).get('manga_settings', {}).get('advanced', {}) if isinstance(self.config, dict) else {}
+                singleton = bool(adv.get('use_singleton_models', True))
+            except Exception:
+                singleton = True
+            if singleton and BubbleDetector._rtdetr_onnx_loaded and not force_reload and BubbleDetector._rtdetr_onnx_shared_session is not None:
+                self.rtdetr_onnx_session = BubbleDetector._rtdetr_onnx_shared_session
+                self.rtdetr_onnx_loaded = True
+                return True
+
+            repo = model_id or self.rtdetr_onnx_repo
+            try:
+                from huggingface_hub import hf_hub_download
+            except Exception as e:
+                logger.error(f"huggingface-hub required to fetch RT-DETR ONNX: {e}")
+                return False
+
+            # Ensure local models dir (use configured cache_dir directly: e.g., 'models')
+            cache_dir = self.cache_dir
+            os.makedirs(cache_dir, exist_ok=True)
+
+            # Download files into models/ and avoid symlinks so the file is visible there
+            try:
+                _ = hf_hub_download(repo_id=repo, filename='config.json', cache_dir=cache_dir, local_dir=cache_dir, local_dir_use_symlinks=False)
+            except Exception:
+                pass
+            onnx_fp = hf_hub_download(repo_id=repo, filename='detector.onnx', cache_dir=cache_dir, local_dir=cache_dir, local_dir_use_symlinks=False)
+            BubbleDetector._rtdetr_onnx_model_path = onnx_fp
+
+            # Pick providers: prefer CUDA if available; otherwise CPU. Do NOT use DML.
+            providers = ['CPUExecutionProvider']
+            try:
+                avail = ort.get_available_providers() if ONNX_AVAILABLE else []
+                if 'CUDAExecutionProvider' in avail:
+                    providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
+            except Exception:
+                pass
+
+            # Session options with reduced memory arena and optional thread limiting in singleton mode
+            so = ort.SessionOptions()
+            try:
+                so.enable_mem_pattern = False
+                so.enable_cpu_mem_arena = False
+            except Exception:
+                pass
+            # If singleton models mode is enabled in config, limit ORT threading to reduce CPU spikes
+            try:
+                adv = (self.config or {}).get('manga_settings', {}).get('advanced', {}) if isinstance(self.config, dict) else {}
+                if bool(adv.get('use_singleton_models', True)):
+                    so.intra_op_num_threads = 1
+                    so.inter_op_num_threads = 1
+                    try:
+                        so.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
+                    except Exception:
+                        pass
+                    try:
+                        so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_BASIC
+                    except Exception:
+                        pass
+            except Exception:
+                pass
+
+            # Create session (serialize creation in singleton mode to avoid device storms)
+            if singleton:
+                with BubbleDetector._rtdetr_onnx_init_lock:
+                    # Re-check after acquiring lock
+                    if BubbleDetector._rtdetr_onnx_loaded and BubbleDetector._rtdetr_onnx_shared_session is not None and not force_reload:
+                        self.rtdetr_onnx_session = BubbleDetector._rtdetr_onnx_shared_session
+                        self.rtdetr_onnx_loaded = True
+                        return True
+                    sess = ort.InferenceSession(onnx_fp, providers=providers, sess_options=so)
+                    BubbleDetector._rtdetr_onnx_shared_session = sess
+                    BubbleDetector._rtdetr_onnx_loaded = True
+                    BubbleDetector._rtdetr_onnx_providers = providers
+                    self.rtdetr_onnx_session = sess
+                    self.rtdetr_onnx_loaded = True
+            else:
+                self.rtdetr_onnx_session = ort.InferenceSession(onnx_fp, providers=providers, sess_options=so)
+                self.rtdetr_onnx_loaded = True
+            logger.info("✅ RT-DETR (ONNX) model ready")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to load RT-DETR ONNX: {e}")
+            self.rtdetr_onnx_session = None
+            self.rtdetr_onnx_loaded = False
+            return False
+
+    def detect_with_rtdetr_onnx(self,
+                                image_path: str = None,
+                                image: np.ndarray = None,
+                                confidence: float = 0.3,
+                                return_all_bubbles: bool = False) -> Any:
+        """Detect using RT-DETR ONNX backend.
+        Returns bubbles list if return_all_bubbles else dict by classes similar to PyTorch path.
+        """
+        if not self.rtdetr_onnx_loaded or self.rtdetr_onnx_session is None:
+            logger.warning("RT-DETR ONNX not loaded")
+            return [] if return_all_bubbles else {'bubbles': [], 'text_bubbles': [], 'text_free': []}
+        try:
+            # Acquire image
+            if image_path is not None:
+                import cv2
+                image = cv2.imread(image_path)
+                if image is None:
+                    raise RuntimeError(f"Failed to read image: {image_path}")
+                image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            else:
+                if image is None:
+                    raise RuntimeError("No image provided")
+                # Assume image is BGR np.ndarray if from OpenCV
+                try:
+                    import cv2
+                    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+                except Exception:
+                    image_rgb = image
+
+            # To PIL then resize 640x640 as in reference
+            from PIL import Image as _PILImage
+            pil_image = _PILImage.fromarray(image_rgb)
+            im_resized = pil_image.resize((640, 640))
+            arr = np.asarray(im_resized, dtype=np.float32) / 255.0
+            arr = np.transpose(arr, (2, 0, 1))  # (3,H,W)
+            im_data = arr[np.newaxis, ...]
+
+            w, h = pil_image.size
+            orig_size = np.array([[w, h]], dtype=np.int64)
+
+            # Run with a concurrency guard when using DML to prevent device hangs
+            providers = BubbleDetector._rtdetr_onnx_providers or []
+            def _do_run(session):
+                return session.run(None, {
+                    'images': im_data,
+                    'orig_target_sizes': orig_size
+                })
+            if 'DmlExecutionProvider' in providers:
+                acquired = False
+                try:
+                    BubbleDetector._rtdetr_onnx_sema.acquire()
+                    acquired = True
+                    outputs = _do_run(self.rtdetr_onnx_session)
+                except Exception as dml_err:
+                    msg = str(dml_err)
+                    if '887A0005' in msg or '887A0006' in msg or 'Dml' in msg:
+                        # Rebuild CPU session and retry once
+                        try:
+                            base_path = BubbleDetector._rtdetr_onnx_model_path
+                            if base_path:
+                                so = ort.SessionOptions()
+                                so.enable_mem_pattern = False
+                                so.enable_cpu_mem_arena = False
+                                cpu_providers = ['CPUExecutionProvider']
+                                # Serialize rebuild
+                                with BubbleDetector._rtdetr_onnx_init_lock:
+                                    sess = ort.InferenceSession(base_path, providers=cpu_providers, sess_options=so)
+                                    BubbleDetector._rtdetr_onnx_shared_session = sess
+                                    BubbleDetector._rtdetr_onnx_providers = cpu_providers
+                                    self.rtdetr_onnx_session = sess
+                                outputs = _do_run(self.rtdetr_onnx_session)
+                            else:
+                                raise
+                        except Exception:
+                            raise
+                    else:
+                        raise
+                finally:
+                    if acquired:
+                        try:
+                            BubbleDetector._rtdetr_onnx_sema.release()
+                        except Exception:
+                            pass
+            else:
+                outputs = _do_run(self.rtdetr_onnx_session)
+
+            # outputs expected: labels, boxes, scores
+            labels, boxes, scores = outputs[:3]
+            if labels.ndim == 2 and labels.shape[0] == 1:
+                labels = labels[0]
+            if scores.ndim == 2 and scores.shape[0] == 1:
+                scores = scores[0]
+            if boxes.ndim == 3 and boxes.shape[0] == 1:
+                boxes = boxes[0]
+
+            detections = {'bubbles': [], 'text_bubbles': [], 'text_free': []}
+            bubbles_all = []
+            for lab, box, scr in zip(labels, boxes, scores):
+                if float(scr) < float(confidence):
+                    continue
+                x1, y1, x2, y2 = map(int, box)
+                bbox = (x1, y1, x2 - x1, y2 - y1)
+                label_id = int(lab)
+                if label_id == self.CLASS_BUBBLE:
+                    detections['bubbles'].append(bbox)
+                    bubbles_all.append(bbox)
+                elif label_id == self.CLASS_TEXT_BUBBLE:
+                    detections['text_bubbles'].append(bbox)
+                    bubbles_all.append(bbox)
+                elif label_id == self.CLASS_TEXT_FREE:
+                    detections['text_free'].append(bbox)
+
+            return bubbles_all if return_all_bubbles else detections
+        except Exception as e:
+            logger.error(f"RT-DETR ONNX detection failed: {e}")
+            return [] if return_all_bubbles else {'bubbles': [], 'text_bubbles': [], 'text_free': []}
+
+
+# Standalone utility functions
+def download_model_from_huggingface(repo_id: str = "ogkalu/comic-speech-bubble-detector-yolov8m",
+                                   filename: str = "comic-speech-bubble-detector-yolov8m.pt",
+                                   cache_dir: str = "models") -> str:
+    """
+    Download model from Hugging Face Hub.
+    
+    Args:
+        repo_id: Hugging Face repository ID
+        filename: Model filename in the repository
+        cache_dir: Local directory to cache the model
+        
+    Returns:
+        Path to downloaded model file
+    """
+    try:
+        from huggingface_hub import hf_hub_download
+        
+        os.makedirs(cache_dir, exist_ok=True)
+        
+        logger.info(f"📥 Downloading {filename} from {repo_id}...")
+        
+        model_path = hf_hub_download(
+            repo_id=repo_id,
+            filename=filename,
+            cache_dir=cache_dir,
+            local_dir=cache_dir
+        )
+        
+        logger.info(f"✅ Model downloaded to: {model_path}")
+        return model_path
+        
+    except ImportError:
+        logger.error("huggingface-hub package required. Install with: pip install huggingface-hub")
+        return None
+    except Exception as e:
+        logger.error(f"Download failed: {e}")
+        return None
+
+
+def download_rtdetr_model(cache_dir: str = "models") -> bool:
+    """
+    Download RT-DETR model for advanced detection.
+    
+    Args:
+        cache_dir: Directory to cache the model
+        
+    Returns:
+        True if successful
+    """
+    if not TRANSFORMERS_AVAILABLE:
+        logger.error("Transformers required. Install with: pip install transformers")
+        return False
+    
+    try:
+        logger.info("📥 Downloading RT-DETR model...")
+        from transformers import RTDetrForObjectDetection, RTDetrImageProcessor
+        
+        # This will download and cache the model
+        processor = RTDetrImageProcessor.from_pretrained(
+            "ogkalu/comic-text-and-bubble-detector",
+            cache_dir=cache_dir
+        )
+        model = RTDetrForObjectDetection.from_pretrained(
+            "ogkalu/comic-text-and-bubble-detector",
+            cache_dir=cache_dir
+        )
+        
+        logger.info("✅ RT-DETR model downloaded successfully")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Download failed: {e}")
+        return False
+
+
+# Example usage and testing
+if __name__ == "__main__":
+    import sys
+    
+    # Create detector
+    detector = BubbleDetector()
+    
+    if len(sys.argv) > 1:
+        if sys.argv[1] == "download":
+            # Download model from Hugging Face
+            model_path = download_model_from_huggingface()
+            if model_path:
+                print(f"YOLOv8 model downloaded to: {model_path}")
+            
+            # Also download RT-DETR
+            if download_rtdetr_model():
+                print("RT-DETR model downloaded")
+        
+        elif sys.argv[1] == "detect" and len(sys.argv) > 3:
+            # Detect bubbles in an image
+            model_path = sys.argv[2]
+            image_path = sys.argv[3]
+            
+            # Load appropriate model
+            if 'rtdetr' in model_path.lower():
+                if detector.load_rtdetr_model():
+                    # Use RT-DETR
+                    results = detector.detect_with_rtdetr(image_path)
+                    print(f"RT-DETR Detection:")
+                    print(f"  Empty bubbles: {len(results['bubbles'])}")
+                    print(f"  Text bubbles: {len(results['text_bubbles'])}")
+                    print(f"  Free text: {len(results['text_free'])}")
+            else:
+                if detector.load_model(model_path):
+                    bubbles = detector.detect_bubbles(image_path, confidence=0.5)
+                    print(f"YOLOv8 detected {len(bubbles)} bubbles:")
+                    for i, (x, y, w, h) in enumerate(bubbles):
+                        print(f"  Bubble {i+1}: position=({x},{y}) size=({w}x{h})")
+            
+            # Optionally visualize
+            if len(sys.argv) > 4:
+                output_path = sys.argv[4]
+                detector.visualize_detections(image_path, output_path=output_path, 
+                                             use_rtdetr='rtdetr' in model_path.lower())
+        
+        elif sys.argv[1] == "test-both" and len(sys.argv) > 2:
+            # Test both models
+            image_path = sys.argv[2]
+            
+            # Load YOLOv8
+            yolo_path = "models/comic-speech-bubble-detector-yolov8m.pt"
+            if os.path.exists(yolo_path):
+                detector.load_model(yolo_path)
+                yolo_bubbles = detector.detect_bubbles(image_path, use_rtdetr=False)
+                print(f"YOLOv8: {len(yolo_bubbles)} bubbles")
+            
+            # Load RT-DETR
+            if detector.load_rtdetr_model():
+                rtdetr_bubbles = detector.detect_bubbles(image_path, use_rtdetr=True)
+                print(f"RT-DETR: {len(rtdetr_bubbles)} bubbles")
+        
+        else:
+            print("Usage:")
+            print("  python bubble_detector.py download")
+            print("  python bubble_detector.py detect <model_path> <image_path> [output_path]")
+            print("  python bubble_detector.py test-both <image_path>")
+    
+    else:
+        print("Bubble Detector Module (YOLOv8 + RT-DETR)")
+        print("Usage:")
+        print("  python bubble_detector.py download")
+        print("  python bubble_detector.py detect <model_path> <image_path> [output_path]")
+        print("  python bubble_detector.py test-both <image_path>")

chapter_extraction_manager.py

@@ -0,0 +1,403 @@
+#!/usr/bin/env python3
+"""
+Chapter Extraction Manager - Manages chapter extraction in subprocess to prevent GUI freezing
+"""
+
+import subprocess
+import sys
+import os
+import json
+import threading
+import queue
+import time
+from pathlib import Path
+
+
+class ChapterExtractionManager:
+    """
+    Manages chapter extraction in a separate process to prevent GUI freezing
+    Similar to GlossaryManager but for chapter extraction
+    """
+    
+    def __init__(self, log_callback=None):
+        """
+        Initialize the extraction manager
+        
+        Args:
+            log_callback: Function to call with log messages (for GUI integration)
+        """
+        self.log_callback = log_callback
+        self.process = None
+        self.output_queue = queue.Queue()
+        self.error_queue = queue.Queue()
+        self.result = None
+        self.is_running = False
+        self.stop_requested = False
+        
+    def extract_chapters_async(self, epub_path, output_dir, extraction_mode="smart", 
+                              progress_callback=None, completion_callback=None):
+        """
+        Start chapter extraction in a subprocess
+        
+        Args:
+            epub_path: Path to EPUB file
+            output_dir: Output directory for extracted content
+            extraction_mode: Extraction mode (smart, comprehensive, full, enhanced)
+            progress_callback: Function to call with progress updates
+            completion_callback: Function to call when extraction completes
+        """
+        if self.is_running:
+            self._log("⚠️ Chapter extraction already in progress")
+            return False
+        
+        self.is_running = True
+        self.stop_requested = False
+        self.result = None
+        
+        # Start extraction in a thread that manages the subprocess
+        thread = threading.Thread(
+            target=self._run_extraction_subprocess,
+            args=(epub_path, output_dir, extraction_mode, progress_callback, completion_callback),
+            daemon=True
+        )
+        thread.start()
+        
+        return True
+    
+    def _run_extraction_subprocess(self, epub_path, output_dir, extraction_mode, 
+                                   progress_callback, completion_callback):
+        """
+        Run the extraction subprocess and handle its output
+        """
+        try:
+            # Build command differently for frozen vs dev mode
+            if getattr(sys, 'frozen', False):
+                # In a frozen one-file build, sys.executable is our GUI .exe, not Python.
+                # Use an internal worker-mode flag handled by translator_gui.py to run the worker.
+                cmd = [
+                    sys.executable,
+                    '--run-chapter-extraction',
+                    epub_path,
+                    output_dir,
+                    extraction_mode
+                ]
+            else:
+                # In dev mode, invoke the worker script with the Python interpreter
+                base_dir = Path(__file__).parent
+                worker_script = base_dir / "chapter_extraction_worker.py"
+                cmd = [
+                    sys.executable,
+                    str(worker_script),
+                    epub_path,
+                    output_dir,
+                    extraction_mode
+                ]
+            
+            # Set environment to force UTF-8 encoding
+            env = os.environ.copy()
+            env['PYTHONIOENCODING'] = 'utf-8'
+            env['PYTHONLEGACYWINDOWSSTDIO'] = '0'  # Use new Windows console API
+            
+            self._log(f"🚀 Starting chapter extraction subprocess...")
+            self._log(f"📚 EPUB: {os.path.basename(epub_path)}")
+            self._log(f"📂 Output: {output_dir}")
+            self._log(f"⚙️ Mode: {extraction_mode}")
+            
+            # Start the subprocess with UTF-8 encoding
+            self.process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                encoding='utf-8',
+                errors='replace',  # Replace invalid chars instead of failing
+                bufsize=1,
+                universal_newlines=True,
+                env=env  # Pass the environment with UTF-8 settings
+            )
+            
+            # Read output in real-time
+            while True:
+                if self.stop_requested:
+                    self._terminate_process()
+                    break
+                
+                # Check if process is still running
+                if self.process.poll() is not None:
+                    break
+                
+                # Read stdout line by line with error handling
+                try:
+                    line = self.process.stdout.readline()
+                    if not line:
+                        continue
+                    
+                    line = line.strip()
+                    if not line:
+                        continue
+                except UnicodeDecodeError as e:
+                    self._log(f"⚠️ Encoding error reading output: {e}")
+                    continue
+                
+                # Skip all processing if stop is requested to suppress logs
+                if self.stop_requested:
+                    continue
+                
+                # Parse output based on prefix
+                if line.startswith("[PROGRESS]"):
+                    # Progress update
+                    message = line[10:].strip()
+                    if progress_callback:
+                        progress_callback(message)
+                    self._log(f"📊 {message}")
+                    
+                elif line.startswith("[INFO]"):
+                    # Information message
+                    message = line[6:].strip()
+                    self._log(f"ℹ️ {message}")
+                    
+                elif line.startswith("[ERROR]"):
+                    # Error message
+                    message = line[7:].strip()
+                    self._log(f"❌ {message}")
+                    self.error_queue.put(message)
+                    
+                elif line.startswith("[RESULT]"):
+                    # Final result as JSON
+                    try:
+                        json_str = line[8:].strip()
+                        self.result = json.loads(json_str)
+                        
+                        if self.result.get("success"):
+                            self._log(f"✅ Extraction completed successfully!")
+                            self._log(f"📚 Extracted {self.result.get('chapters', 0)} chapters")
+                        else:
+                            error = self.result.get("error", "Unknown error")
+                            self._log(f"❌ Extraction failed: {error}")
+                            
+                    except json.JSONDecodeError as e:
+                        self._log(f"⚠️ Failed to parse result: {e}")
+                        
+                elif line.startswith("["):
+                    # Other prefixed messages - skip
+                    pass
+                else:
+                    # Regular output - only log if not too verbose
+                    if not any(skip in line for skip in ["📁     Searching for", "📁     Found", "📁   ✓", "📁   ✗"]):
+                        self._log(line)
+            
+            # Get any remaining output - but only process if not stopped
+            if not self.stop_requested:
+                remaining_output, remaining_error = self.process.communicate(timeout=1)
+                
+                # Process any remaining output
+                if remaining_output:
+                    for line in remaining_output.strip().split('\n'):
+                        if line and not line.startswith("["):
+                            self._log(line)
+                
+                # Check for errors
+                if remaining_error:
+                    for line in remaining_error.strip().split('\n'):
+                        if line:
+                            self._log(f"⚠️ {line}")
+                
+                # Check final status
+                if self.process.returncode != 0:
+                    self._log(f"⚠️ Process exited with code {self.process.returncode}")
+            else:
+                # If stopped, just clean up without processing output
+                try:
+                    self.process.communicate(timeout=0.1)
+                except subprocess.TimeoutExpired:
+                    pass  # Ignore timeout when cleaning up
+            
+        except subprocess.TimeoutExpired:
+            if not self.stop_requested:
+                self._log("⚠️ Subprocess communication timeout")
+            self._terminate_process()
+            
+        except Exception as e:
+            # Only log errors if not stopping (unless it's a critical error)
+            if not self.stop_requested or "Subprocess error" in str(e):
+                self._log(f"❌ Subprocess error: {e}")
+            self.result = {
+                "success": False,
+                "error": str(e) if not self.stop_requested else "Extraction stopped by user"
+            }
+            
+        finally:
+            self.is_running = False
+            # Store process reference before clearing it in case termination is needed
+            process_ref = self.process
+            self.process = None
+            
+            # If process is still running, try to clean it up
+            if process_ref and process_ref.poll() is None:
+                try:
+                    process_ref.terminate()
+                    time.sleep(0.1)  # Brief wait
+                    if process_ref.poll() is None:
+                        process_ref.kill()
+                except Exception:
+                    pass  # Ignore cleanup errors in finally block
+            
+            # Ensure result is never None
+            if self.result is None:
+                if self.stop_requested:
+                    self.result = {
+                        "success": False,
+                        "error": "Extraction stopped by user"
+                    }
+                else:
+                    self.result = {
+                        "success": False,
+                        "error": "Extraction process ended unexpectedly"
+                    }
+            
+            # Call completion callback
+            if completion_callback:
+                completion_callback(self.result)
+    
+    def stop_extraction(self):
+        """Stop the extraction process"""
+        if not self.is_running:
+            return False
+        
+        # Set stop flag first to suppress subsequent logs
+        self.stop_requested = True
+        self._log("🛑 Stopping chapter extraction...")
+        
+        # Store process reference to avoid race condition
+        process_ref = self.process
+        
+        # Give it a moment to stop gracefully
+        time.sleep(0.5)
+        
+        # Force terminate if still running and process still exists
+        if process_ref:
+            self._terminate_process_ref(process_ref)
+        
+        return True
+    
+    def _terminate_process(self):
+        """Terminate the subprocess using current process reference"""
+        if self.process:
+            self._terminate_process_ref(self.process)
+    
+    def _terminate_process_ref(self, process_ref):
+        """Terminate a specific process reference"""
+        if not process_ref:
+            return
+            
+        try:
+            # Check if process is still alive before attempting termination
+            if process_ref.poll() is None:
+                process_ref.terminate()
+                # Give it a moment to terminate
+                time.sleep(0.5)
+                
+                # Force kill if still running
+                if process_ref.poll() is None:
+                    process_ref.kill()
+                    time.sleep(0.1)  # Brief wait after kill
+                    
+                # Only log termination if not stopping (user already knows they stopped it)
+                if not self.stop_requested:
+                    self._log("✅ Process terminated")
+            else:
+                # Only log if not stopping
+                if not self.stop_requested:
+                    self._log("✅ Process already terminated")
+        except Exception as e:
+            # Always log termination errors as they might indicate a problem
+            self._log(f"⚠️ Error terminating process: {e}")
+    
+    def _log(self, message):
+        """Log a message using the callback if available"""
+        # Suppress logs when stop is requested (except for stop/termination messages)
+        if self.stop_requested and not any(keyword in message for keyword in ["🛑", "✅ Process terminated", "❌ Subprocess error"]):
+            return
+            
+        if self.log_callback:
+            self.log_callback(message)
+        else:
+            print(message)
+    
+    def is_extraction_running(self):
+        """Check if extraction is currently running"""
+        return self.is_running
+    
+    def get_result(self):
+        """Get the extraction result if available"""
+        return self.result
+
+
+# Example usage
+if __name__ == "__main__":
+    import tkinter as tk
+    from tkinter import filedialog
+    
+    def test_extraction():
+        """Test the extraction manager"""
+        
+        # Create a simple GUI for testing
+        root = tk.Tk()
+        root.title("Chapter Extraction Test")
+        root.geometry("800x600")
+        
+        # Text widget for logs
+        text = tk.Text(root, wrap=tk.WORD)
+        text.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
+        
+        # Log callback
+        def log_message(msg):
+            text.insert(tk.END, msg + "\n")
+            text.see(tk.END)
+            root.update_idletasks()
+        
+        # Progress callback
+        def progress_update(msg):
+            log_message(f"📊 Progress: {msg}")
+        
+        # Completion callback
+        def extraction_complete(result):
+            if result and result.get("success"):
+                log_message(f"✅ Extraction completed!")
+                log_message(f"   Chapters: {result.get('chapters', 0)}")
+            else:
+                log_message(f"❌ Extraction failed!")
+        
+        # Create manager
+        manager = ChapterExtractionManager(log_callback=log_message)
+        
+        # File selection
+        epub_path = filedialog.askopenfilename(
+            title="Select EPUB file",
+            filetypes=[("EPUB files", "*.epub"), ("All files", "*.*")]
+        )
+        
+        if epub_path:
+            output_dir = os.path.splitext(os.path.basename(epub_path))[0]
+            
+            # Start extraction
+            manager.extract_chapters_async(
+                epub_path,
+                output_dir,
+                extraction_mode="smart",
+                progress_callback=progress_update,
+                completion_callback=extraction_complete
+            )
+        
+        # Button to stop
+        stop_btn = tk.Button(
+            root,
+            text="Stop Extraction",
+            command=lambda: manager.stop_extraction()
+        )
+        stop_btn.pack(pady=5)
+        
+        root.mainloop()
+    
+    # Run test
+    test_extraction()

chapter_extraction_worker.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+Chapter Extraction Worker - Runs chapter extraction in a separate process to prevent GUI freezing
+"""
+
+import sys
+import os
+import io
+
+# Force UTF-8 encoding for stdout/stderr on Windows
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')
+import json
+import zipfile
+import time
+import traceback
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent))
+
+def run_chapter_extraction(epub_path, output_dir, extraction_mode="smart", progress_callback=None):
+    """
+    Run chapter extraction in this worker process
+    
+    Args:
+        epub_path: Path to EPUB file
+        output_dir: Output directory for extracted content
+        extraction_mode: Extraction mode (smart, comprehensive, full, enhanced)
+        progress_callback: Callback function for progress updates (uses print for IPC)
+    
+    Returns:
+        dict: Extraction results including chapters and metadata
+    """
+    try:
+        # Import here to avoid loading heavy modules until needed
+        from TransateKRtoEN import ChapterExtractor
+        
+        # Create progress callback that prints to stdout for IPC
+        def worker_progress_callback(message):
+            # Use special prefix for progress messages
+            print(f"[PROGRESS] {message}", flush=True)
+        
+        # Create extractor with progress callback
+        extractor = ChapterExtractor(progress_callback=worker_progress_callback)
+        
+        # Set extraction mode
+        os.environ["EXTRACTION_MODE"] = extraction_mode
+        
+        # Open EPUB and extract chapters
+        print(f"[INFO] Starting extraction of: {epub_path}", flush=True)
+        print(f"[INFO] Output directory: {output_dir}", flush=True)
+        print(f"[INFO] Extraction mode: {extraction_mode}", flush=True)
+        
+        with zipfile.ZipFile(epub_path, 'r') as zf:
+            # Extract metadata first
+            metadata = extractor._extract_epub_metadata(zf)
+            print(f"[INFO] Extracted metadata: {list(metadata.keys())}", flush=True)
+            
+            # Extract chapters
+            chapters = extractor.extract_chapters(zf, output_dir)
+            
+            print(f"[INFO] Extracted {len(chapters)} chapters", flush=True)
+            
+            # The extract_chapters method already handles OPF sorting internally
+            # Just log if OPF was used
+            opf_path = os.path.join(output_dir, 'content.opf')
+            if os.path.exists(opf_path):
+                print(f"[INFO] OPF file available for chapter ordering", flush=True)
+            
+            # CRITICAL: Save the full chapters with body content!
+            # This is what the main process needs to load
+            chapters_full_path = os.path.join(output_dir, "chapters_full.json")
+            try:
+                with open(chapters_full_path, 'w', encoding='utf-8') as f:
+                    json.dump(chapters, f, ensure_ascii=False)
+                print(f"[INFO] Saved full chapters data to: {chapters_full_path}", flush=True)
+            except Exception as e:
+                print(f"[WARNING] Could not save full chapters: {e}", flush=True)
+                # Fall back to saving individual files
+                for chapter in chapters:
+                    try:
+                        chapter_file = f"chapter_{chapter['num']:04d}_{chapter.get('filename', 'content').replace('/', '_')}.html"
+                        chapter_path = os.path.join(output_dir, chapter_file)
+                        with open(chapter_path, 'w', encoding='utf-8') as f:
+                            f.write(chapter.get('body', ''))
+                        print(f"[INFO] Saved chapter {chapter['num']} to {chapter_file}", flush=True)
+                    except Exception as ce:
+                        print(f"[WARNING] Could not save chapter {chapter.get('num')}: {ce}", flush=True)
+            
+            # Return results as JSON for IPC
+            result = {
+                "success": True,
+                "chapters": len(chapters),
+                "metadata": metadata,
+                "chapter_info": [
+                    {
+                        "num": ch.get("num"),
+                        "title": ch.get("title"),
+                        "has_images": ch.get("has_images", False),
+                        "file_size": ch.get("file_size", 0),
+                        "content_hash": ch.get("content_hash", "")
+                    }
+                    for ch in chapters
+                ]
+            }
+            
+            # Output result as JSON
+            print(f"[RESULT] {json.dumps(result)}", flush=True)
+            return result
+            
+    except Exception as e:
+        # Send error information
+        error_info = {
+            "success": False,
+            "error": str(e),
+            "traceback": traceback.format_exc()
+        }
+        print(f"[ERROR] {str(e)}", flush=True)
+        print(f"[RESULT] {json.dumps(error_info)}", flush=True)
+        return error_info
+
+
+def main():
+    """Main entry point for worker process"""
+    
+    # Parse command line arguments
+    if len(sys.argv) < 3:
+        print("[ERROR] Usage: chapter_extraction_worker.py <epub_path> <output_dir> [extraction_mode]", flush=True)
+        sys.exit(1)
+    
+    epub_path = sys.argv[1]
+    output_dir = sys.argv[2]
+    extraction_mode = sys.argv[3] if len(sys.argv) > 3 else "smart"
+    
+    # Validate inputs
+    if not os.path.exists(epub_path):
+        print(f"[ERROR] EPUB file not found: {epub_path}", flush=True)
+        sys.exit(1)
+    
+    # Create output directory if needed
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Run extraction
+    result = run_chapter_extraction(epub_path, output_dir, extraction_mode)
+    
+    # Exit with appropriate code
+    sys.exit(0 if result.get("success", False) else 1)
+
+
+if __name__ == "__main__":
+    # Ensure freeze support for Windows frozen exe
+    try:
+        import multiprocessing
+        multiprocessing.freeze_support()
+    except Exception:
+        pass
+    main()

chapter_splitter.py

@@ -0,0 +1,195 @@
+import re
+from bs4 import BeautifulSoup
+import tiktoken
+
+class ChapterSplitter:
+    """Split large chapters into smaller chunks while preserving structure"""
+    
+    def __init__(self, model_name="gpt-3.5-turbo", target_tokens=80000, compression_factor=1.0):
+        """
+        Initialize splitter with token counter
+        target_tokens: Target size for each chunk (leaving room for system prompt & history)
+        compression_factor: Expected compression ratio from source to target language (0.7-1.0)
+        """
+        try:
+            self.enc = tiktoken.encoding_for_model(model_name)
+        except:
+            self.enc = tiktoken.get_encoding("cl100k_base")
+        self.target_tokens = target_tokens
+        self.compression_factor = compression_factor
+    
+    def count_tokens(self, text):
+        """Count tokens in text"""
+        try:
+            return len(self.enc.encode(text))
+        except:
+            # Fallback estimation
+            return len(text) // 4
+    
+    def split_chapter(self, chapter_html, max_tokens=None):
+        """
+        Split a chapter into smaller chunks if it exceeds token limit
+        Returns: List of (chunk_html, chunk_index, total_chunks)
+        """
+        if max_tokens is None:
+            max_tokens = self.target_tokens
+        
+        # Apply compression factor to output token limit
+        # If compression_factor is 0.7 and max_tokens is 4096,
+        # we expect output to be 4096 * 0.7 = 2867 tokens
+        effective_max_tokens = int(max_tokens * self.compression_factor)
+            
+        # First check if splitting is needed
+        total_tokens = self.count_tokens(chapter_html)
+        if total_tokens <= effective_max_tokens:
+            return [(chapter_html, 1, 1)]  # No split needed
+        
+        # Parse HTML
+        soup = BeautifulSoup(chapter_html, 'html.parser')
+        
+        # Try to find natural break points
+        chunks = []
+        current_chunk = []
+        current_tokens = 0
+        
+        # Get all direct children of body, or all top-level elements
+        if soup.body:
+            elements = list(soup.body.children)
+        else:
+            elements = list(soup.children)
+        
+        for element in elements:
+            if isinstance(element, str) and element.strip() == '':
+                continue
+                
+            element_html = str(element)
+            element_tokens = self.count_tokens(element_html)
+            
+            # If single element is too large, try to split it
+            if element_tokens > effective_max_tokens:
+                sub_chunks = self._split_large_element(element, effective_max_tokens)
+                for sub_chunk in sub_chunks:
+                    chunks.append(sub_chunk)
+            else:
+                # Check if adding this element would exceed limit
+                if current_tokens + element_tokens > effective_max_tokens and current_chunk:
+                    # Save current chunk
+                    chunks.append(self._create_chunk_html(current_chunk))
+                    current_chunk = [element_html]
+                    current_tokens = element_tokens
+                else:
+                    current_chunk.append(element_html)
+                    current_tokens += element_tokens
+        
+        # Don't forget the last chunk
+        if current_chunk:
+            chunks.append(self._create_chunk_html(current_chunk))
+        
+        # Return chunks with metadata
+        total_chunks = len(chunks)
+        return [(chunk, i+1, total_chunks) for i, chunk in enumerate(chunks)]
+    
+    def _split_large_element(self, element, max_tokens):
+        """Split a single large element (like a long paragraph)"""
+        chunks = []
+        
+        if element.name == 'p' or not hasattr(element, 'children'):
+            # For paragraphs or text elements, split by sentences
+            text = element.get_text()
+            sentences = re.split(r'(?<=[.!?])\s+', text)
+            
+            current_chunk = []
+            current_tokens = 0
+            
+            for sentence in sentences:
+                sentence_tokens = self.count_tokens(sentence)
+                
+                if current_tokens + sentence_tokens > max_tokens * 0.8 and current_chunk:
+                    # Create paragraph with current sentences
+                    chunk_text = ' '.join(current_chunk)
+                    chunks.append(f"<p>{chunk_text}</p>")
+                    current_chunk = [sentence]
+                    current_tokens = sentence_tokens
+                else:
+                    current_chunk.append(sentence)
+                    current_tokens += sentence_tokens
+            
+            if current_chunk:
+                chunk_text = ' '.join(current_chunk)
+                chunks.append(f"<p>{chunk_text}</p>")
+                
+        else:
+            # For other elements, try to split by children
+            children = list(element.children)
+            current_chunk = []
+            current_tokens = 0
+            
+            for child in children:
+                child_html = str(child)
+                child_tokens = self.count_tokens(child_html)
+                
+                if current_tokens + child_tokens > max_tokens * 0.8 and current_chunk:
+                    # Wrap in parent element type
+                    wrapper = BeautifulSoup(f"<{element.name}></{element.name}>", 'html.parser')
+                    wrapper_elem = wrapper.find(element.name)
+                    for item in current_chunk:
+                        wrapper_elem.append(BeautifulSoup(item, 'html.parser'))
+                    chunks.append(str(wrapper))
+                    
+                    current_chunk = [child_html]
+                    current_tokens = child_tokens
+                else:
+                    current_chunk.append(child_html)
+                    current_tokens += child_tokens
+            
+            if current_chunk:
+                wrapper = BeautifulSoup(f"<{element.name}></{element.name}>", 'html.parser')
+                wrapper_elem = wrapper.find(element.name)
+                for item in current_chunk:
+                    wrapper_elem.append(BeautifulSoup(item, 'html.parser'))
+                chunks.append(str(wrapper))
+        
+        return chunks
+    
+    def _create_chunk_html(self, elements):
+        """Create a valid HTML chunk from list of elements"""
+        # Join elements and wrap in basic HTML structure if needed
+        content = '\n'.join(elements)
+        
+        # Check if it already has body tags
+        if '<body' not in content.lower():
+            # Just return the content, let the translation handle it
+            return content
+        else:
+            return content
+    
+    def merge_translated_chunks(self, translated_chunks):
+        """
+        Merge translated chunks back together
+        translated_chunks: List of (translated_html, chunk_index, total_chunks)
+        """
+        # Sort by chunk index to ensure correct order
+        sorted_chunks = sorted(translated_chunks, key=lambda x: x[1])
+        
+        # Extract just the HTML content
+        html_parts = [chunk[0] for chunk in sorted_chunks]
+        
+        # Simply concatenate - the chunks should maintain structure
+        merged = '\n'.join(html_parts)
+        
+        # Clean up any duplicate body tags if they exist
+        soup = BeautifulSoup(merged, 'html.parser')
+        
+        # If multiple body tags, merge their contents
+        bodies = soup.find_all('body')
+        if len(bodies) > 1:
+            # Keep first body, move all content from others into it
+            main_body = bodies[0]
+            for extra_body in bodies[1:]:
+                for child in list(extra_body.children):
+                    main_body.append(child)
+                extra_body.decompose()
+            
+            return str(soup)
+        
+        return merged

check_epub_directory.py

@@ -0,0 +1,152 @@
+import os
+import re
+
+def diagnose_epub_directory(directory="."):
+    """Diagnose issues with EPUB output directory"""
+    
+    print(f"\n{'='*60}")
+    print(f"EPUB Directory Diagnostic Tool")
+    print(f"{'='*60}\n")
+    
+    # Get absolute path
+    abs_path = os.path.abspath(directory)
+    print(f"📁 Checking directory: {abs_path}")
+    
+    # Check if directory exists
+    if not os.path.exists(abs_path):
+        print(f"❌ ERROR: Directory does not exist!")
+        return
+    
+    if not os.path.isdir(abs_path):
+        print(f"❌ ERROR: Path is not a directory!")
+        return
+    
+    # List contents
+    try:
+        contents = os.listdir(abs_path)
+        print(f"✅ Directory is accessible")
+        print(f"📊 Total items: {len(contents)}\n")
+    except Exception as e:
+        print(f"❌ ERROR: Cannot read directory: {e}")
+        return
+    
+    # Categorize files
+    html_files = []
+    response_files = []
+    css_files = []
+    image_files = []
+    directories = []
+    other_files = []
+    
+    for item in contents:
+        item_path = os.path.join(abs_path, item)
+        
+        if os.path.isdir(item_path):
+            directories.append(item)
+        elif item.endswith('.html'):
+            html_files.append(item)
+            if item.startswith('response_'):
+                response_files.append(item)
+        elif item.endswith('.css'):
+            css_files.append(item)
+        elif item.lower().endswith(('.jpg', '.jpeg', '.png', '.gif', '.svg')):
+            image_files.append(item)
+        else:
+            other_files.append(item)
+    
+    # Report findings
+    print("📋 Directory Contents Summary:")
+    print(f"   • HTML files: {len(html_files)}")
+    print(f"   • Response files (translated chapters): {len(response_files)}")
+    print(f"   • CSS files: {len(css_files)}")
+    print(f"   • Image files: {len(image_files)}")
+    print(f"   • Subdirectories: {len(directories)}")
+    print(f"   • Other files: {len(other_files)}")
+    
+    # Check for required items
+    print(f"\n📍 Checking Required Items:")
+    
+    # Check for metadata.json
+    if 'metadata.json' in contents:
+        print("   ✅ metadata.json found")
+    else:
+        print("   ❌ metadata.json NOT FOUND")
+    
+    # Check for response files
+    if response_files:
+        print(f"   ✅ {len(response_files)} translated chapter files found")
+        
+        # Analyze chapter numbers
+        chapter_nums = []
+        for f in response_files:
+            m = re.match(r'response_(\d+)_', f)
+            if m:
+                chapter_nums.append(int(m.group(1)))
+        
+        if chapter_nums:
+            chapter_nums.sort()
+            print(f"   📖 Chapter range: {min(chapter_nums)} to {max(chapter_nums)}")
+            
+            # Check for missing chapters
+            expected = set(range(min(chapter_nums), max(chapter_nums) + 1))
+            actual = set(chapter_nums)
+            missing = expected - actual
+            if missing:
+                print(f"   ⚠️ Missing chapters: {sorted(missing)}")
+    else:
+        print("   ❌ No response_*.html files found!")
+        
+        if html_files:
+            print(f"\n   🔍 Found {len(html_files)} HTML files with different names:")
+            for i, f in enumerate(html_files[:5]):
+                print(f"      {i+1}. {f}")
+            if len(html_files) > 5:
+                print(f"      ... and {len(html_files) - 5} more")
+    
+    # Check subdirectories
+    if directories:
+        print(f"\n📂 Subdirectories found:")
+        for d in directories:
+            print(f"   • {d}/")
+            
+            # Check contents of important subdirectories
+            if d in ['css', 'images', 'fonts']:
+                try:
+                    sub_contents = os.listdir(os.path.join(abs_path, d))
+                    print(f"     Contains {len(sub_contents)} items")
+                except:
+                    print(f"     Cannot read contents")
+    
+    # Sample file check
+    if response_files:
+        print(f"\n🔍 Checking a sample chapter file...")
+        sample_file = response_files[0]
+        sample_path = os.path.join(abs_path, sample_file)
+        
+        try:
+            with open(sample_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+                print(f"   ✅ {sample_file} is readable")
+                print(f"   📏 File size: {len(content):,} characters")
+                
+                # Check for basic HTML structure
+                if '<html' in content.lower():
+                    print("   ✅ Contains HTML tag")
+                if '<body' in content.lower():
+                    print("   ✅ Contains BODY tag")
+                if '<p>' in content or '<p ' in content:
+                    print("   ✅ Contains paragraph tags")
+                    
+        except Exception as e:
+            print(f"   ❌ Cannot read {sample_file}: {e}")
+    
+    print(f"\n{'='*60}")
+    print("Diagnostic complete!")
+    print(f"{'='*60}\n")
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) > 1:
+        diagnose_epub_directory(sys.argv[1])
+    else:
+        diagnose_epub_directory(".")

direct_imports.py

@@ -0,0 +1,38 @@
+import sys
+import os
+
+# Add the current directory to Python path so we can import our modules
+current_dir = os.path.dirname(os.path.abspath(__file__))
+if current_dir not in sys.path:
+    sys.path.insert(0, current_dir)
+
+# When running as executable, modules might be in _MEIPASS
+if hasattr(sys, '_MEIPASS'):
+    meipass_dir = sys._MEIPASS
+    if meipass_dir not in sys.path:
+        sys.path.insert(0, meipass_dir)
+
+# Now we can safely import our modules
+try:
+    from extract_glossary_from_epub import main as glossary_main
+except ImportError as e:
+    print(f"Failed to import glossary module: {e}")
+    glossary_main = None
+
+try:
+    from TransateKRtoEN import main as translation_main
+except ImportError as e:
+    print(f"Failed to import translation module: {e}")
+    translation_main = None
+
+try:
+    from epub_converter import fallback_compile_epub
+except ImportError as e:
+    print(f"Failed to import epub converter: {e}")
+    fallback_compile_epub = None
+
+try:
+    from scan_html_folder import scan_html_folder
+except ImportError as e:
+    print(f"Failed to import scanner: {e}")
+    scan_html_folder = None

enhanced_text_extractor.py

@@ -0,0 +1,597 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Enhanced Text Extractor Module with CJK Support
+Provides superior text extraction from HTML with proper Unicode handling
+Optimized for Korean, Japanese, and Chinese content extraction
+"""
+
+import os
+import re
+import html
+import unicodedata
+from typing import Tuple, Optional
+import chardet
+
+# BEAUTIFUL SOUP IMPORT MONKEY FIX - Import BeautifulSoup BEFORE html2text
+# This prevents certain parser initialization issues
+try:
+    from bs4 import BeautifulSoup
+    # Force BeautifulSoup to initialize its parsers
+    _ = BeautifulSoup("", 'html.parser')
+except ImportError:
+    BeautifulSoup = None
+    raise ImportError("BeautifulSoup is required. Install with: pip install beautifulsoup4")
+
+# Now import html2text AFTER BeautifulSoup
+try:
+    import html2text
+except ImportError:
+    html2text = None
+    raise ImportError("html2text is required. Install with: pip install html2text")
+
+
+class EnhancedTextExtractor:
+    """Enhanced text extraction with proper Unicode and CJK handling"""
+    
+    # Unicode preservation mappings
+    UNICODE_QUOTES = {
+        # Western quotes
+        '“': '\u201c',  # Left double quotation mark
+        '”': '\u201d',  # Right double quotation mark
+        '‘': '\u2018',  # Left single quotation mark
+        '’': '\u2019',  # Right single quotation mark
+        '"': '"',        # Standard double quote
+        ''': "'",        # Standard apostrophe
+        
+        # CJK quotes and punctuation
+        '「': '「',  # Japanese left corner bracket
+        '」': '」',  # Japanese right corner bracket
+        '『': '『',  # Japanese left white corner bracket
+        '』': '』',  # Japanese right white corner bracket
+        '（': '（',  # Fullwidth left parenthesis
+        '）': '）',  # Fullwidth right parenthesis
+        '【': '【',  # Left black lenticular bracket
+        '】': '】',  # Right black lenticular bracket
+        '《': '《',  # Left double angle bracket
+        '》': '》',  # Right double angle bracket
+        '；': '；',  # Fullwidth semicolon
+        '：': '：',  # Fullwidth colon
+        '。': '。',  # Ideographic full stop
+        '？': '？',  # Fullwidth question mark
+        '！': '！',  # Fullwidth exclamation mark
+        '、': '、',  # Ideographic comma
+        
+        # Numeric entities
+        '“': '\u201c',  # Left double quote (numeric)
+        '”': '\u201d',  # Right double quote (numeric)
+        '‘': '\u2018',  # Left single quote (numeric)
+        '’': '\u2019',  # Right single quote (numeric)
+        
+        # Common CJK entities
+        '…': '…',     # Horizontal ellipsis
+        '—': '—',      # Em dash
+        '–': '–',      # En dash
+        ' ': '\u00A0',  # Non-breaking space
+    }
+    
+    # CJK-specific punctuation to preserve
+    CJK_PUNCTUATION = {
+        '。', '、', '！', '？', '…', '—', '～', '・',
+        '「', '」', '『', '』', '（', '）', '【', '】',
+        '《', '》', '〈', '〉', '〔', '〕', '［', '］',
+        '：', '；', '"', '"', ''', ''',
+        '，', '．', '？', '！', '：', '；',
+        '"', '"', '‚', '„', '«', '»',
+    }
+    
+    # Quote protection markers
+    QUOTE_MARKERS = {
+        '"': '␥',   # Opening double quote marker
+        '"': '␦',   # Closing double quote marker  
+        '"': '␦',   # Alternative closing quote
+        "'": '␣',   # Opening single quote marker
+        "'": '␤',   # Closing single quote marker
+        "'": '␤',   # Alternative closing quote
+    }
+    
+    
+    def __init__(self, filtering_mode: str = "smart", preserve_structure: bool = True):
+        """Initialize the enhanced text extractor"""
+        if not html2text:
+            raise ImportError("html2text is required for enhanced extraction")
+        
+        if not BeautifulSoup:
+            raise ImportError("BeautifulSoup is required for enhanced extraction")
+            
+        self.filtering_mode = filtering_mode
+        self.preserve_structure = preserve_structure
+        self.h2t = None
+        self.detected_language = None
+        
+        self._configure_html2text()
+    
+    def _detect_encoding(self, content: bytes) -> str:
+        """Detect the encoding of the content"""
+        try:
+            # Try chardet detection
+            detected = chardet.detect(content)
+            if detected['confidence'] > 0.7:
+                return detected['encoding']
+        except Exception:
+            pass
+        
+        # Try common CJK encodings in order
+        for encoding in ['utf-8', 'gb2312', 'gbk', 'gb18030', 'big5', 'shift_jis', 'euc-kr', 'euc-jp']:
+            try:
+                content.decode(encoding)
+                return encoding
+            except Exception:
+                continue
+        
+        return 'utf-8'  # Default fallback
+    
+    def _detect_content_language(self, text: str) -> str:
+        """Detect the primary language of content"""
+        if not text:
+            return 'unknown'
+        
+        # Take a sample of the text
+        sample = text[:5000]
+        
+        # Count characters by script
+        korean_chars = sum(1 for char in sample if 0xAC00 <= ord(char) <= 0xD7AF)
+        japanese_kana = sum(1 for char in sample if (0x3040 <= ord(char) <= 0x309F) or (0x30A0 <= ord(char) <= 0x30FF))
+        chinese_chars = sum(1 for char in sample if 0x4E00 <= ord(char) <= 0x9FFF)
+        latin_chars = sum(1 for char in sample if 0x0041 <= ord(char) <= 0x007A)
+        
+        # Determine primary language
+        if korean_chars > 50:
+            return 'korean'
+        elif japanese_kana > 20:
+            return 'japanese'
+        elif chinese_chars > 50 and japanese_kana < 10:
+            return 'chinese'
+        elif latin_chars > 100:
+            return 'english'
+        else:
+            return 'unknown'
+    
+    def _configure_html2text(self):
+        """Configure html2text with optimal Unicode and CJK settings"""
+        self.h2t = html2text.HTML2Text()
+        
+        # Core settings for Unicode preservation
+        self.h2t.unicode_snob = True
+        self.h2t.escape_snob = True
+        self.h2t.use_automatic_links = False
+        
+        # Layout settings
+        self.h2t.body_width = 0
+        self.h2t.single_line_break = False
+        
+        # Content filtering
+        self.h2t.ignore_links = False
+        self.h2t.ignore_images = False
+        self.h2t.ignore_anchors = False
+        self.h2t.skip_internal_links = False
+        self.h2t.ignore_tables = False
+        
+        # Image handling - CRITICAL: Force html2text to preserve img tags as HTML
+        self.h2t.images_as_html = True  # Keep images as <img> tags instead of ![]()
+        self.h2t.images_to_alt = False  # Don't convert to alt text only
+        self.h2t.images_with_size = True  # Include width/height attributes
+        
+        # Additional settings
+        self.h2t.wrap_links = False
+        self.h2t.wrap_list_items = False
+        self.h2t.protect_links = True
+        
+        # Structure preservation settings
+        if self.preserve_structure:
+            self.h2t.bypass_tables = False
+            self.h2t.ignore_emphasis = False
+            self.h2t.mark_code = True
+            self.h2t.ul_item_mark = '•'
+        else:
+            self.h2t.bypass_tables = True
+            self.h2t.ignore_emphasis = True
+            self.h2t.mark_code = False
+    
+    def _decode_entities(self, text: str) -> str:
+        """Decode HTML entities to Unicode characters with CJK support"""
+        if not text:
+            return text
+        
+        # First pass: Apply known CJK-aware replacements
+        for entity, unicode_char in self.UNICODE_QUOTES.items():
+            text = text.replace(entity, unicode_char)
+        
+        # Second pass: standard HTML unescape
+        text = html.unescape(text)
+        
+        # Third pass: handle numeric entities
+        def decode_decimal(match):
+            try:
+                code = int(match.group(1))
+                if code < 0x110000:
+                    return chr(code)
+            except Exception:
+                pass
+            return match.group(0)
+        
+        def decode_hex(match):
+            try:
+                code = int(match.group(1), 16)
+                if code < 0x110000:
+                    return chr(code)
+            except Exception:
+                pass
+            return match.group(0)
+        
+        text = re.sub(r'&#(\d+);?', decode_decimal, text)
+        text = re.sub(r'&#x([0-9a-fA-F]+);?', decode_hex, text)
+        
+        # Fourth pass: handle special CJK entities
+        cjk_special_entities = {
+            '&lang;': '〈', '&rang;': '〉',
+            '&lceil;': '⌈', '&rceil;': '⌉',
+            '&lfloor;': '⌊', '&rfloor;': '⌋',
+        }
+        
+        for entity, char in cjk_special_entities.items():
+            text = text.replace(entity, char)
+        
+        return text
+    
+    def _normalize_unicode(self, text: str) -> str:
+        """Normalize Unicode with CJK awareness"""
+        if self.detected_language in ['korean', 'japanese', 'chinese']:
+            return text
+        else:
+            return unicodedata.normalize('NFC', text)
+    
+    def _protect_quotes(self, text: str) -> str:
+        """Protect quotes by replacing with special markers"""
+        for original, marker in self.QUOTE_MARKERS.items():
+            text = text.replace(original, marker)
+        return text
+    
+    def _restore_quotes(self, text: str) -> str:
+        """Restore quotes from special markers"""
+        for original, marker in self.QUOTE_MARKERS.items():
+            text = text.replace(marker, original)
+        return text
+    
+    
+    
+    def _preprocess_html_for_quotes(self, html_content: str) -> str:
+        """Pre-process HTML to protect quotes from conversion"""
+        def protect_quotes_in_text(match):
+            text = match.group(1)
+            return f'>{self._protect_quotes(text)}<'
+        
+        # Apply to all text between tags
+        html_content = re.sub(r'>([^<]+)<', protect_quotes_in_text, html_content)
+        return html_content
+    
+    def _protect_quotes_in_soup(self, soup: BeautifulSoup) -> None:
+        """Protect quotes in BeautifulSoup object before processing"""
+        for element in soup.find_all(string=True):
+            if element.parent.name not in ['script', 'style', 'noscript']:
+                original_text = str(element)
+                protected_text = self._protect_quotes(original_text)
+                element.replace_with(protected_text)
+    
+    def _minimal_parser_fix(self, html_content: str) -> str:
+        """Apply minimal fixes only for parser errors"""
+        # Fix tags with ="" pattern
+        html_content = re.sub(r'<[^>]*?=\s*""\s*[^>]*?>', '', html_content)
+        
+        # Fix malformed closing tags
+        html_content = re.sub(r'</\s+(\w+)>', r'</\1>', html_content)
+        html_content = re.sub(r'</\s*>', '', html_content)
+        html_content = re.sub(r'<//+(\w+)>', r'</\1>', html_content)
+        
+        # Fix orphaned brackets
+        html_content = re.sub(r'<(?![a-zA-Z/!?])', '&lt;', html_content)
+        html_content = re.sub(r'(?<![a-zA-Z0-9"/])>', '&gt;', html_content)
+        
+        # Fix unclosed tags at the end
+        if html_content.rstrip().endswith('<'):
+            html_content = html_content.rstrip()[:-1]
+        
+        # Remove nested opening brackets
+        html_content = re.sub(r'<[^>]*?<[^>]*?>', '', html_content)
+        
+        return html_content
+    
+    def _clean_text_cjk_aware(self, text: str, preserve_structure: bool) -> str:
+        """Clean extracted text with CJK awareness"""
+        if not preserve_structure and self.detected_language not in ['korean', 'japanese', 'chinese']:
+            # Only do aggressive cleanup for non-CJK text
+            text = re.sub(r'^#+\s*', '', text, flags=re.MULTILINE)
+            text = re.sub(r'\*\*(.*?)\*\*', r'\1', text)
+            text = re.sub(r'\*(.*?)\*', r'\1', text)
+            text = re.sub(r'__(.*?)__', r'\1', text)
+            text = re.sub(r'_(.*?)_', r'\1', text)
+            text = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', text)
+            text = re.sub(r'!\[([^\]]*)\]\([^)]+\)', '', text)
+            text = re.sub(r'`([^`]+)`', r'\1', text)
+            text = re.sub(r'```[^`]*```', '', text, flags=re.DOTALL)
+            text = re.sub(r'^[-*+]\s+', '', text, flags=re.MULTILINE)
+            text = re.sub(r'^\d+\.\s+', '', text, flags=re.MULTILINE)
+            text = re.sub(r'^>\s+', '', text, flags=re.MULTILINE)
+            text = re.sub(r'^[-_*]{3,}$', '', text, flags=re.MULTILINE)
+        
+        # Clean whitespace
+        if self.detected_language in ['korean', 'japanese', 'chinese']:
+            text = re.sub(r'\n{3,}', '\n\n', text)
+            text = re.sub(r'[ ]{3,}', '  ', text)
+        else:
+            text = re.sub(r'\n{3,}', '\n\n', text)
+            text = re.sub(r' {2,}', ' ', text)
+        
+        # Remove invisible characters
+        invisible_chars = ['\u200b', '\u200c', '\u200d', '\ufeff', '\u2060']
+        for char in invisible_chars:
+            text = text.replace(char, '')
+        
+        return text.strip()
+    
+    def _extract_title(self, soup: BeautifulSoup) -> Optional[str]:
+        """Extract chapter title from various sources"""
+        # Try title tag first
+        if soup.title and soup.title.string:
+            title = soup.title.string.strip()
+            title = self._decode_entities(title)
+            return title
+        
+        # Try headers in order
+        for header_tag in ['h1', 'h2', 'h3', 'h4']:
+            headers = soup.find_all(header_tag)
+            for header in headers:
+                title = header.get_text(strip=True)
+                if title:
+                    title = self._decode_entities(title)
+                    if self._is_chapter_title(title):
+                        return title
+        
+        return None
+    
+    def _is_chapter_title(self, text: str) -> bool:
+        """Check if text looks like a chapter title"""
+        if not text or len(text) > 200:
+            return False
+        
+        # Common chapter patterns
+        patterns = [
+            r'第.{1,10}[章回話话]',
+            r'Chapter\s+\d+',
+            r'제\s*\d+\s*화',
+            r'第\d+話',
+            r'\d+\s*화',
+            r'EP\.?\s*\d+',
+            r'Part\s+\d+',
+        ]
+        
+        for pattern in patterns:
+            if re.search(pattern, text, re.IGNORECASE):
+                return True
+        
+        # Check if it's short and doesn't contain too much punctuation
+        if len(text) < 100:
+            punct_count = sum(1 for c in text if c in '.,;:!?。、！？')
+            if punct_count < len(text) * 0.2:
+                return True
+        
+        return False
+    
+    def _extract_body_content(self, soup: BeautifulSoup, full_html: str) -> str:
+        """Extract body content while preserving Unicode"""
+        # Remove script and style elements first
+        for element in soup(['script', 'style', 'noscript']):
+            element.decompose()
+        
+        if soup.body:
+            return str(soup.body)
+        else:
+            return str(soup)
+    
+    def extract_chapter_content(self, html_content: str, extraction_mode: str = None) -> Tuple[str, str, Optional[str]]:
+        """Extract chapter content with proper Unicode and CJK handling"""
+        try:
+            # Use instance filtering_mode if not overridden
+            if extraction_mode is None:
+                extraction_mode = self.filtering_mode
+            
+            # Handle encoding if content is bytes
+            if isinstance(html_content, bytes):
+                encoding = self._detect_encoding(html_content)
+                html_content = html_content.decode(encoding, errors='replace')
+            
+            # Pre-process HTML to protect quotes
+            html_content = self._preprocess_html_for_quotes(html_content)
+            
+            # Pre-process HTML to decode all entities
+            html_content = self._decode_entities(html_content)
+            
+            # Detect language early
+            self.detected_language = self._detect_content_language(html_content)
+            print(f"🌐 Detected language: {self.detected_language}")
+            
+            # Parse with BeautifulSoup
+            parser = 'html.parser'
+            if self.detected_language in ['korean', 'japanese', 'chinese']:
+                # For CJK content, lxml might handle encoding better if available
+                try:
+                    import lxml
+                    parser = 'lxml'
+                except ImportError:
+                    pass
+            
+            soup = BeautifulSoup(html_content, parser)
+            
+            # Protect quotes before any processing
+            self._protect_quotes_in_soup(soup)
+            
+            # Extract title
+            chapter_title = self._extract_title(soup)
+            
+            # Respect GUI toggles to exclude headers/titles BEFORE conversion
+            try:
+                batch_translate_active = os.getenv('BATCH_TRANSLATE_HEADERS', '0') == '1'
+                ignore_title_tag = os.getenv('IGNORE_TITLE', '0') == '1' and batch_translate_active
+                ignore_header_tags = os.getenv('IGNORE_HEADER', '0') == '1' and batch_translate_active
+                if ignore_title_tag and soup.title:
+                    # Remove <title> so it isn't included when using full extraction
+                    soup.title.decompose()
+                if ignore_header_tags:
+                    # Remove visible headers from body prior to conversion
+                    for tag_name in ['h1', 'h2', 'h3']:
+                        for hdr in soup.find_all(tag_name):
+                            hdr.decompose()
+            except Exception:
+                # Non-fatal – proceed with original soup if anything goes wrong
+                pass
+            
+            # Determine content to convert (after removals)
+            if extraction_mode == "full":
+                content_to_convert = str(soup)
+            else:
+                content_to_convert = self._extract_body_content(soup, html_content)
+            
+            # Convert using html2text
+            content_to_convert = self._decode_entities(content_to_convert)
+            
+            # Convert to text with error handling
+            try:
+                clean_text = self.h2t.handle(content_to_convert)
+            except (AssertionError, UnboundLocalError) as e:
+                error_msg = str(e)
+                if "cannot access local variable" in error_msg or "we should not get here!" in error_msg or "unexpected call to parse_endtag" in error_msg or "unexpected call to parse_starttag" in error_msg:
+                    print(f"⚠️ html2text encountered malformed HTML: {error_msg}")
+                    print(f"⚠️ Applying minimal fixes...")
+                    # Apply minimal fixes
+                    content_to_convert = self._minimal_parser_fix(content_to_convert)
+                    try:
+                        clean_text = self.h2t.handle(content_to_convert)
+                        print(f"✅ Successfully processed after minimal fixes")
+                    except Exception as e2:
+                        print(f"⚠️ html2text still failing: {e2}")
+                        # Last resort fallback
+                        clean_text = soup.get_text(separator='\n', strip=True)
+                        print(f"✅ Used BeautifulSoup fallback")
+                else:
+                    # Re-raise if it's a different error
+                    raise
+            except Exception as e:
+                print(f"⚠️ Unexpected error in html2text: {e}")
+                # Fallback to BeautifulSoup
+                clean_text = soup.get_text(separator='\n', strip=True)
+            
+            # Normalize only if appropriate
+            clean_text = self._normalize_unicode(clean_text)
+            
+            # Clean based on settings and language
+            clean_text = self._clean_text_cjk_aware(clean_text, self.preserve_structure)
+            
+            # Restore protected quotes
+            clean_text = self._restore_quotes(clean_text)
+            
+            # For enhanced mode, both display and translation content are the same
+            return clean_text, clean_text, chapter_title
+                
+        except Exception as e:
+            print(f"❌ Enhanced extraction failed: {e}")
+            raise
+
+
+# Test function
+def test_cjk_preservation():
+    """Test that CJK characters and quotes are properly preserved"""
+    test_cases = [
+        # Korean test with quotes
+        '''<html>
+        <head><title>제국의 붉은 사신</title></head>
+        <body>
+            <p>"왜 이러는 겁니까? 우리가 무슨 잘못을 했다고!"</p>
+            <p>"......"</p>
+            <p>"한 번만 살려주시오! 가족을 지키려면 어쩔 수 없었소!"</p>
+            <p>"응애! 응애! 응애!"</p>
+            <p>"미안하구나. 모든 죄는 내가 짊어지고 사마."</p>
+        </body>
+        </html>'''
+        
+        # Japanese test with quotes
+        '''<html>
+        <head><title>第1話：始まり</title></head>
+        <body>
+            <h1>第1話：始まり</h1>
+            <p>「こんにちは！これは日本語のテストです。」</p>
+            <p>彼は言った。「これで全部ですか？」</p>
+            <p>「はい、そうです」と答えた。</p>
+        </body>
+        </html>''',
+        
+        # Chinese test with quotes
+        '''<html>
+        <head><title>第一章：开始</title></head>
+        <body>
+            <h1>第一章：开始</h1>
+            <p>"你好！这是中文测试。"</p>
+            <p>他说："这就是全部吗？"</p>
+            <p>"是的，"她回答道。</p>
+        </body>
+        </html>''',
+    ]
+    
+    extractor = EnhancedTextExtractor()
+    
+    print("=== CJK and Quote Preservation Test ===\n")
+    
+    for i, test_html in enumerate(test_cases, 1):
+        print(f"--- Test Case {i} ---")
+        try:
+            content, _, title = extractor.extract_chapter_content(test_html)
+            
+            print(f"Title: {title}")
+            print(f"Content:\n{content}\n")
+            
+            # Check for quotes preservation
+            quote_checks = [
+                ('"', 'Western double quotes'),
+                ('「', 'Japanese left bracket'),
+                ('」', 'Japanese right bracket'),
+                ('“', 'Chinese double quote'),
+            ]
+            
+            print("Quote preservation check:")
+            quote_found = False
+            
+            for quote_char, desc in quote_checks:
+                if quote_char in content:
+                    print(f"  ✓ Found {desc}: {quote_char}")
+                    quote_found = True
+            
+            if not quote_found:
+                print("  ❌ No quotes found!")
+            else:
+                print("  ✅ Quotes preserved successfully!")
+            
+            # Check for image tag preservation (html2text now preserves them natively)
+            img_count = content.count('<img')
+            if img_count > 0:
+                print(f"  ✓ Found {img_count} HTML img tags (preserved natively by html2text)")
+                print("  ✅ Image tags preserved successfully!")
+            else:
+                print("  ℹ️ No images in this test case")
+                
+        except Exception as e:
+            print(f"Error processing test case {i}: {e}")
+        
+        print("-" * 50 + "\n")
+
+
+if __name__ == "__main__":
+    test_cjk_preservation()

extract_glossary_from_epub.py

@@ -0,0 +1,2081 @@
+# extract_glossary_from_epub.py
+import os
+import json
+import argparse
+import zipfile
+import time
+import sys
+import tiktoken
+import threading
+import queue
+import ebooklib
+import re
+from ebooklib import epub
+from chapter_splitter import ChapterSplitter
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import List, Dict, Tuple
+from unified_api_client import UnifiedClient, UnifiedClientError
+
+# Fix for PyInstaller - handle stdout reconfigure more carefully
+if sys.platform.startswith("win"):
+    try:
+        # Try to reconfigure if the method exists
+        if hasattr(sys.stdout, 'reconfigure'):
+            sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    except (AttributeError, ValueError):
+        # If reconfigure doesn't work, try to set up UTF-8 another way
+        import io
+        import locale
+        if sys.stdout and hasattr(sys.stdout, 'buffer'):
+            sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+
+MODEL = os.getenv("MODEL", "gemini-2.0-flash")
+
+def interruptible_sleep(duration, check_stop_fn, interval=0.1):
+    """Sleep that can be interrupted by stop request"""
+    elapsed = 0
+    while elapsed < duration:
+        if check_stop_fn and check_stop_fn():  # Add safety check for None
+            return False  # Interrupted
+        sleep_time = min(interval, duration - elapsed)
+        time.sleep(sleep_time)
+        elapsed += sleep_time
+    return True  # Completed normally
+    
+def cancel_all_futures(futures):
+    """Cancel all pending futures immediately"""
+    cancelled_count = 0
+    for future in futures:
+        if not future.done() and future.cancel():
+            cancelled_count += 1
+    return cancelled_count
+
+def create_client_with_multi_key_support(api_key, model, output_dir, config):
+    """Create a UnifiedClient with multi API key support if enabled"""
+    
+    # Check if multi API key mode is enabled
+    use_multi_keys = config.get('use_multi_api_keys', False)
+    
+    # Set environment variables for UnifiedClient to pick up
+    if use_multi_keys and 'multi_api_keys' in config and config['multi_api_keys']:
+        print("🔑 Multi API Key mode enabled for glossary extraction")
+        
+        # Set environment variables that UnifiedClient will read
+        os.environ['USE_MULTI_API_KEYS'] = '1'
+        os.environ['MULTI_API_KEYS'] = json.dumps(config['multi_api_keys'])
+        os.environ['FORCE_KEY_ROTATION'] = '1' if config.get('force_key_rotation', True) else '0'
+        os.environ['ROTATION_FREQUENCY'] = str(config.get('rotation_frequency', 1))
+        
+        print(f"   • Keys configured: {len(config['multi_api_keys'])}")
+        print(f"   • Force rotation: {config.get('force_key_rotation', True)}")
+        print(f"   • Rotation frequency: every {config.get('rotation_frequency', 1)} request(s)")
+    else:
+        # Ensure multi-key mode is disabled in environment
+        os.environ['USE_MULTI_API_KEYS'] = '0'
+        
+    # Create UnifiedClient normally - it will check environment variables
+    return UnifiedClient(api_key=api_key, model=model, output_dir=output_dir)
+    
+def send_with_interrupt(messages, client, temperature, max_tokens, stop_check_fn, chunk_timeout=None):
+    """Send API request with interrupt capability and optional timeout retry"""
+    result_queue = queue.Queue()
+    
+    def api_call():
+        try:
+            start_time = time.time()
+            result = client.send(messages, temperature=temperature, max_tokens=max_tokens, context='glossary')
+            elapsed = time.time() - start_time
+            result_queue.put((result, elapsed))
+        except Exception as e:
+            result_queue.put(e)
+    
+    api_thread = threading.Thread(target=api_call)
+    api_thread.daemon = True
+    api_thread.start()
+    
+    timeout = chunk_timeout if chunk_timeout is not None else 86400
+    check_interval = 0.1
+    elapsed = 0
+    
+    while elapsed < timeout:
+        try:
+            # Check for results with shorter timeout
+            result = result_queue.get(timeout=check_interval)
+            if isinstance(result, Exception):
+                raise result
+            if isinstance(result, tuple):
+                api_result, api_time = result
+                if chunk_timeout and api_time > chunk_timeout:
+                    if hasattr(client, '_in_cleanup'):
+                        client._in_cleanup = True
+                    if hasattr(client, 'cancel_current_operation'):
+                        client.cancel_current_operation()
+                    raise UnifiedClientError(f"API call took {api_time:.1f}s (timeout: {chunk_timeout}s)")
+                return api_result
+            return result
+        except queue.Empty:
+            if stop_check_fn():
+                # More aggressive cancellation
+                print("🛑 Stop requested - cancelling API call immediately...")
+                
+                # Set cleanup flag
+                if hasattr(client, '_in_cleanup'):
+                    client._in_cleanup = True
+                
+                # Try to cancel the operation
+                if hasattr(client, 'cancel_current_operation'):
+                    client.cancel_current_operation()
+                
+                # Don't wait for the thread to finish - just raise immediately
+                raise UnifiedClientError("Glossary extraction stopped by user")
+            
+            elapsed += check_interval
+    
+    # Timeout occurred
+    if hasattr(client, '_in_cleanup'):
+        client._in_cleanup = True
+    if hasattr(client, 'cancel_current_operation'):
+        client.cancel_current_operation()
+    raise UnifiedClientError(f"API call timed out after {timeout} seconds")
+
+# Parse token limit from environment variable (same logic as translation)
+def parse_glossary_token_limit():
+    """Parse token limit from environment variable"""
+    env_value = os.getenv("GLOSSARY_TOKEN_LIMIT", "1000000").strip()
+    
+    if not env_value or env_value == "":
+        return None, "unlimited"
+    
+    if env_value.lower() == "unlimited":
+        return None, "unlimited"
+    
+    if env_value.isdigit() and int(env_value) > 0:
+        limit = int(env_value)
+        return limit, str(limit)
+    
+    # Default fallback
+    return 1000000, "1000000 (default)"
+
+MAX_GLOSSARY_TOKENS, GLOSSARY_LIMIT_STR = parse_glossary_token_limit()
+
+# Global stop flag for GUI integration
+_stop_requested = False
+
+def set_stop_flag(value):
+    """Set the global stop flag"""
+    global _stop_requested
+    _stop_requested = value
+    
+    # When clearing the stop flag, also clear the multi-key environment variable
+    if not value:
+        os.environ['TRANSLATION_CANCELLED'] = '0'
+        
+        # Also clear UnifiedClient global flag
+        try:
+            import unified_api_client
+            if hasattr(unified_api_client, 'UnifiedClient'):
+                unified_api_client.UnifiedClient._global_cancelled = False
+        except:
+            pass
+
+def is_stop_requested():
+    """Check if stop was requested"""
+    global _stop_requested
+    return _stop_requested
+
+# ─── resilient tokenizer setup ───
+try:
+    enc = tiktoken.encoding_for_model(MODEL)
+except Exception:
+    try:
+        enc = tiktoken.get_encoding("cl100k_base")
+    except Exception:
+        enc = None
+
+def count_tokens(text: str) -> int:
+    if enc:
+        return len(enc.encode(text))
+    # crude fallback: assume ~1 token per 4 chars
+    return max(1, len(text) // 4)
+
+from ebooklib import epub
+from bs4 import BeautifulSoup
+from unified_api_client import UnifiedClient
+from typing import List, Dict
+import re
+
+PROGRESS_FILE = "glossary_progress.json"
+
+def remove_honorifics(name):
+    """Remove common honorifics from names"""
+    if not name:
+        return name
+    
+    # Check if honorifics filtering is disabled
+    if os.getenv('GLOSSARY_DISABLE_HONORIFICS_FILTER', '0') == '1':
+        return name.strip()
+    
+    # Modern Korean honorifics
+    korean_honorifics = [
+        '님', '씨', '씨는', '군', '양', '선생님', '선생', '사장님', '사장', 
+        '과장님', '과장', '대리님', '대리', '주임님', '주임', '이사님', '이사',
+        '부장님', '부장', '차장님', '차장', '팀장님', '팀장', '실장님', '실장',
+        '교수님', '교수', '박사님', '박사', '원장님', '원장', '회장님', '회장',
+        '소장님', '소장', '전무님', '전무', '상무님', '상무', '이사장님', '이사장'
+    ]
+    
+    # Archaic/Historical Korean honorifics
+    korean_archaic = [
+        '공', '옹', '어른', '나리', '나으리', '대감', '영감', '마님', '마마',
+        '대군', '군', '옹주', '공주', '왕자', '세자', '영애', '영식', '도령',
+        '낭자', '낭군', '서방', '영감님', '대감님', '마님', '아씨', '도련님',
+        '아가씨', '나으리', '진사', '첨지', '영의정', '좌의정', '우의정',
+        '판서', '참판', '정승', '대원군'
+    ]
+    
+    # Modern Japanese honorifics
+    japanese_honorifics = [
+        'さん', 'さま', '様', 'くん', '君', 'ちゃん', 'せんせい', '先生',
+        'どの', '殿', 'たん', 'ぴょん', 'ぽん', 'ちん', 'りん', 'せんぱい',
+        '先輩', 'こうはい', '後輩', 'し', '氏', 'ふじん', '夫人', 'かちょう',
+        '課長', 'ぶちょう', '部長', 'しゃちょう', '社長'
+    ]
+    
+    # Archaic/Historical Japanese honorifics
+    japanese_archaic = [
+        'どの', '殿', 'たいゆう', '大夫', 'きみ', '公', 'あそん', '朝臣',
+        'おみ', '臣', 'むらじ', '連', 'みこと', '命', '尊', 'ひめ', '姫',
+        'みや', '宮', 'おう', '王', 'こう', '侯', 'はく', '伯', 'し', '子',
+        'だん', '男', 'じょ', '女', 'ひこ', '彦', 'ひめみこ', '姫御子',
+        'すめらみこと', '天皇', 'きさき', '后', 'みかど', '帝'
+    ]
+    
+    # Modern Chinese honorifics
+    chinese_honorifics = [
+        '先生', '女士', '小姐', '老师', '师傅', '大人', '公', '君', '总',
+        '老总', '老板', '经理', '主任', '处长', '科长', '股长', '教授',
+        '博士', '院长', '校长', '同志', '师兄', '师姐', '师弟', '师妹',
+        '学长', '学姐', '前辈', '阁下'
+    ]
+    
+    # Archaic/Historical Chinese honorifics
+    chinese_archaic = [
+        '公', '侯', '伯', '子', '男', '王', '君', '卿', '大夫', '士',
+        '陛下', '殿下', '阁下', '爷', '老爷', '大人', '夫人', '娘娘',
+        '公子', '公主', '郡主', '世子', '太子', '皇上', '皇后', '贵妃',
+        '娘子', '相公', '官人', '郎君', '小姐', '姑娘', '公公', '嬷嬷',
+        '大侠', '少侠', '前辈', '晚辈', '在下', '足下', '兄台', '仁兄',
+        '贤弟', '老夫', '老朽', '本座', '本尊', '真人', '上人', '尊者'
+    ]
+    
+    # Combine all honorifics
+    all_honorifics = (
+        korean_honorifics + korean_archaic +
+        japanese_honorifics + japanese_archaic +
+        chinese_honorifics + chinese_archaic
+    )
+    
+    # Remove honorifics from the end of the name
+    name_cleaned = name.strip()
+    
+    # Sort by length (longest first) to avoid partial matches
+    sorted_honorifics = sorted(all_honorifics, key=len, reverse=True)
+    
+    for honorific in sorted_honorifics:
+        if name_cleaned.endswith(honorific):
+            name_cleaned = name_cleaned[:-len(honorific)].strip()
+            # Only remove one honorific per pass
+            break
+    
+    return name_cleaned
+
+def set_output_redirect(log_callback=None):
+    """Redirect print statements to a callback function for GUI integration"""
+    if log_callback:
+        import sys
+        import io
+        
+        class CallbackWriter:
+            def __init__(self, callback):
+                self.callback = callback
+                self.buffer = ""
+                
+            def write(self, text):
+                if text.strip():
+                    self.callback(text.strip())
+                    
+            def flush(self):
+                pass
+                
+        sys.stdout = CallbackWriter(log_callback)
+
+def load_config(path: str) -> Dict:
+    with open(path, 'r', encoding='utf-8') as f:
+        cfg = json.load(f)
+
+    # override context_limit_chapters if GUI passed GLOSSARY_CONTEXT_LIMIT
+    env_limit = os.getenv("GLOSSARY_CONTEXT_LIMIT")
+    if env_limit is not None:
+        try:
+            cfg['context_limit_chapters'] = int(env_limit)
+        except ValueError:
+            pass  # keep existing config value on parse error
+
+    # override temperature if GUI passed GLOSSARY_TEMPERATURE
+    env_temp = os.getenv("GLOSSARY_TEMPERATURE")
+    if env_temp is not None:
+        try:
+            cfg['temperature'] = float(env_temp)
+        except ValueError:
+            pass  # keep existing config value on parse error
+
+    return cfg
+
+def get_custom_entry_types():
+    """Get custom entry types configuration from environment"""
+    try:
+        types_json = os.getenv('GLOSSARY_CUSTOM_ENTRY_TYPES', '{}')
+        result = json.loads(types_json)
+        # If empty, return defaults
+        if not result:
+            return {
+                'character': {'enabled': True, 'has_gender': True},
+                'term': {'enabled': True, 'has_gender': False}
+            }
+        return result
+    except:
+        # Default configuration
+        return {
+            'character': {'enabled': True, 'has_gender': True},
+            'term': {'enabled': True, 'has_gender': False}
+        }
+
+def save_glossary_json(glossary: List[Dict], output_path: str):
+    """Save glossary in the new simple format with automatic sorting by type"""
+    # Get custom types for sorting order
+    custom_types = get_custom_entry_types()
+    
+    # Create sorting order: character=0, term=1, others alphabetically starting from 2
+    type_order = {'character': 0, 'term': 1}
+    other_types = sorted([t for t in custom_types.keys() if t not in ['character', 'term']])
+    for i, t in enumerate(other_types):
+        type_order[t] = i + 2
+    
+    # Sort glossary by type order, then by raw_name
+    sorted_glossary = sorted(glossary, key=lambda x: (
+        type_order.get(x.get('type', 'term'), 999),  # Unknown types go last
+        x.get('raw_name', '').lower()
+    ))
+    
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(sorted_glossary, f, ensure_ascii=False, indent=2)
+
+def save_glossary_csv(glossary: List[Dict], output_path: str):
+    """Save glossary in CSV or token-efficient format based on environment variable"""
+    import csv
+    
+    csv_path = output_path.replace('.json', '.csv')
+    
+    # Get custom types for sorting order and gender info
+    custom_types = get_custom_entry_types()
+    
+    # Create sorting order
+    type_order = {'character': 0, 'term': 1}
+    other_types = sorted([t for t in custom_types.keys() if t not in ['character', 'term']])
+    for i, t in enumerate(other_types):
+        type_order[t] = i + 2
+    
+    # Sort glossary
+    sorted_glossary = sorted(glossary, key=lambda x: (
+        type_order.get(x.get('type', 'term'), 999),
+        x.get('raw_name', '').lower()
+    ))
+    
+    # Check if we should use legacy CSV format
+    use_legacy_format = os.getenv('GLOSSARY_USE_LEGACY_CSV', '0') == '1'
+    
+    if use_legacy_format:
+        # LEGACY CSV FORMAT
+        with open(csv_path, 'w', encoding='utf-8', newline='') as f:
+            writer = csv.writer(f)
+            
+            # Build header row
+            header = ['type', 'raw_name', 'translated_name', 'gender']
+            
+            # Add any custom fields to header
+            custom_fields_json = os.getenv('GLOSSARY_CUSTOM_FIELDS', '[]')
+            try:
+                custom_fields = json.loads(custom_fields_json)
+                header.extend(custom_fields)
+            except:
+                custom_fields = []
+            
+            # Write header row
+            writer.writerow(header)
+            
+            # Write data rows
+            for entry in sorted_glossary:
+                entry_type = entry.get('type', 'term')
+                type_config = custom_types.get(entry_type, {})
+                
+                # Base row: type, raw_name, translated_name
+                row = [entry_type, entry.get('raw_name', ''), entry.get('translated_name', '')]
+                
+                # Add gender only if type supports it
+                if type_config.get('has_gender', False):
+                    row.append(entry.get('gender', ''))
+                
+                # Add custom field values
+                for field in custom_fields:
+                    row.append(entry.get(field, ''))
+                
+                # Count how many fields we SHOULD have
+                expected_fields = 4 + len(custom_fields)  # type, raw_name, translated_name, gender + custom fields
+                
+                # Only trim if we have MORE than expected (extra trailing empties)
+                while len(row) > expected_fields and row[-1] == '':
+                    row.pop()
+                
+                # Ensure minimum required fields (type, raw_name, translated_name)
+                while len(row) < 3:
+                    row.append('')
+                
+                # Write row
+                writer.writerow(row)
+        
+        print(f"✅ Saved legacy CSV format: {csv_path}")
+    
+    else:
+        # NEW TOKEN-EFFICIENT FORMAT (DEFAULT)
+        # Group entries by type
+        grouped_entries = {}
+        for entry in sorted_glossary:
+            entry_type = entry.get('type', 'term')
+            if entry_type not in grouped_entries:
+                grouped_entries[entry_type] = []
+            grouped_entries[entry_type].append(entry)
+        
+        # Get custom fields configuration
+        custom_fields_json = os.getenv('GLOSSARY_CUSTOM_FIELDS', '[]')
+        try:
+            custom_fields = json.loads(custom_fields_json)
+        except:
+            custom_fields = []
+        
+        # Write as plain text format for token efficiency
+        with open(csv_path, 'w', encoding='utf-8') as f:
+            # Write header
+            f.write("Glossary: Characters, Terms, and Important Elements\n\n")
+            
+            # Process each type group
+            for entry_type in sorted(grouped_entries.keys(), key=lambda x: type_order.get(x, 999)):
+                entries = grouped_entries[entry_type]
+                type_config = custom_types.get(entry_type, {})
+                
+                # Write section header
+                section_name = entry_type.upper() + 'S' if not entry_type.upper().endswith('S') else entry_type.upper()
+                f.write(f"=== {section_name} ===\n")
+                
+                # Write entries for this type with indentation
+                for entry in entries:
+                    # Build the entry line
+                    raw_name = entry.get('raw_name', '')
+                    translated_name = entry.get('translated_name', '')
+                    
+                    # Start with asterisk and name
+                    line = f"* {translated_name} ({raw_name})"
+                    
+                    # Add gender if applicable and not Unknown
+                    if type_config.get('has_gender', False):
+                        gender = entry.get('gender', '')
+                        if gender and gender != 'Unknown':
+                            line += f" [{gender}]"
+                    
+                    # Add custom field values if they exist
+                    custom_field_parts = []
+                    for field in custom_fields:
+                        value = entry.get(field, '').strip()
+                        if value:
+                            # For description fields, add as continuation
+                            if field.lower() in ['description', 'notes', 'details']:
+                                line += f": {value}"
+                            else:
+                                custom_field_parts.append(f"{field}: {value}")
+                    
+                    # Add other custom fields in parentheses
+                    if custom_field_parts:
+                        line += f" ({', '.join(custom_field_parts)})"
+                    
+                    # Write the line
+                    f.write(line + "\n")
+                
+                # Add blank line between sections
+                f.write("\n")
+        
+        print(f"✅ Saved token-efficient glossary: {csv_path}")
+        
+        # Print summary for both formats
+        type_counts = {}
+        for entry_type in grouped_entries:
+            type_counts[entry_type] = len(grouped_entries[entry_type])
+        total = sum(type_counts.values())
+        print(f"   Total entries: {total}")
+        for entry_type, count in type_counts.items():
+            print(f"   - {entry_type}: {count} entries")
+            
+def extract_chapters_from_epub(epub_path: str) -> List[str]:
+    chapters = []
+    items = []
+    
+    # Add this helper function
+    def is_html_document(item):
+        """Check if an EPUB item is an HTML document"""
+        if hasattr(item, 'media_type'):
+            return item.media_type in [
+                'application/xhtml+xml',
+                'text/html',
+                'application/html+xml',
+                'text/xml'
+            ]
+        # Fallback for items that don't have media_type
+        if hasattr(item, 'get_name'):
+            name = item.get_name()
+            return name.lower().endswith(('.html', '.xhtml', '.htm'))
+        return False
+    
+    try:
+        # Add stop check before reading
+        if is_stop_requested():
+            return []
+            
+        book = epub.read_epub(epub_path)
+        # Replace the problematic line with media type checking
+        items = [item for item in book.get_items() if is_html_document(item)]
+    except Exception as e:
+        print(f"[Warning] Manifest load failed, falling back to raw EPUB scan: {e}")
+        try:
+            with zipfile.ZipFile(epub_path, 'r') as zf:
+                names = [n for n in zf.namelist() if n.lower().endswith(('.html', '.xhtml'))]
+                for name in names:
+                    # Add stop check in loop
+                    if is_stop_requested():
+                        return chapters
+                        
+                    try:
+                        data = zf.read(name)
+                        items.append(type('X', (), {
+                            'get_content': lambda self, data=data: data,
+                            'get_name': lambda self, name=name: name,
+                            'media_type': 'text/html'  # Add media_type for consistency
+                        })())
+                    except Exception:
+                        print(f"[Warning] Could not read zip file entry: {name}")
+        except Exception as ze:
+            print(f"[Fatal] Cannot open EPUB as zip: {ze}")
+            return chapters
+            
+    for item in items:
+        # Add stop check before processing each chapter
+        if is_stop_requested():
+            return chapters
+            
+        try:
+            raw = item.get_content()
+            soup = BeautifulSoup(raw, 'html.parser')
+            text = soup.get_text("\n", strip=True)
+            if text:
+                chapters.append(text)
+        except Exception as e:
+            name = item.get_name() if hasattr(item, 'get_name') else repr(item)
+            print(f"[Warning] Skipped corrupted chapter {name}: {e}")
+            
+    return chapters
+
+def trim_context_history(history: List[Dict], limit: int, rolling_window: bool = False) -> List[Dict]:
+    """
+    Handle context history with either reset or rolling window mode
+    
+    Args:
+        history: List of conversation history
+        limit: Maximum number of exchanges to keep
+        rolling_window: Whether to use rolling window mode
+    """
+    # Count current exchanges
+    current_exchanges = len(history)
+    
+    # Handle based on mode
+    if limit > 0 and current_exchanges >= limit:
+        if rolling_window:
+            # Rolling window: keep the most recent exchanges
+            print(f"🔄 Rolling glossary context window: keeping last {limit} chapters")
+            # Keep only the most recent exchanges
+            history = history[-(limit-1):] if limit > 1 else []
+        else:
+            # Reset mode (original behavior)
+            print(f"🔄 Reset glossary context after {limit} chapters")
+            return []  # Return empty to reset context
+    
+    # Convert to message format
+    trimmed = []
+    for entry in history:
+        trimmed.append({"role": "user", "content": entry["user"]})
+        trimmed.append({"role": "assistant", "content": entry["assistant"]})
+    return trimmed
+
+def load_progress() -> Dict:
+    if os.path.exists(PROGRESS_FILE):
+        with open(PROGRESS_FILE, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    return {"completed": [], "glossary": [], "context_history": []}
+
+def parse_api_response(response_text: str) -> List[Dict]:
+    """Parse API response to extract glossary entries - handles custom types"""
+    entries = []
+    
+    # Get enabled types from custom configuration
+    custom_types = get_custom_entry_types()
+    enabled_types = [t for t, cfg in custom_types.items() if cfg.get('enabled', True)]
+    
+    # First try JSON parsing
+    try:
+        # Clean up response text
+        cleaned_text = response_text.strip()
+        
+        # Remove markdown code blocks if present
+        if '```json' in cleaned_text or '```' in cleaned_text:
+            import re
+            code_block_match = re.search(r'```(?:json)?\s*(.*?)\s*```', cleaned_text, re.DOTALL)
+            if code_block_match:
+                cleaned_text = code_block_match.group(1)
+        
+        # Try to find JSON array or object
+        import re
+        json_match = re.search(r'[\[\{].*[\]\}]', cleaned_text, re.DOTALL)
+        if json_match:
+            json_str = json_match.group(0)
+            data = json.loads(json_str)
+            
+            if isinstance(data, list):
+                for item in data:
+                    if isinstance(item, dict):
+                        # Check if entry type is enabled
+                        entry_type = item.get('type', '').lower()
+                        
+                        # Handle legacy format where type is the key
+                        if not entry_type:
+                            for type_name in enabled_types:
+                                if type_name in item:
+                                    entry_type = type_name
+                                    fixed_entry = {
+                                        'type': type_name,
+                                        'raw_name': item.get(type_name, ''),
+                                        'translated_name': item.get('translated_name', '')
+                                    }
+                                    
+                                    # Add gender if type supports it
+                                    if custom_types.get(type_name, {}).get('has_gender', False):
+                                        fixed_entry['gender'] = item.get('gender', 'Unknown')
+                                    
+                                    # Copy other fields
+                                    for k, v in item.items():
+                                        if k not in [type_name, 'translated_name', 'gender', 'type', 'raw_name']:
+                                            fixed_entry[k] = v
+                                    
+                                    entries.append(fixed_entry)
+                                    break
+                        else:
+                            # Standard format with type field
+                            if entry_type in enabled_types:
+                                entries.append(item)
+                
+                return entries
+                
+            elif isinstance(data, dict):
+                # Handle single entry
+                entry_type = data.get('type', '').lower()
+                if entry_type in enabled_types:
+                    return [data]
+                
+                # Check for wrapper
+                for key in ['entries', 'glossary', 'characters', 'terms', 'data']:
+                    if key in data and isinstance(data[key], list):
+                        return parse_api_response(json.dumps(data[key]))
+                
+                return []
+                
+    except (json.JSONDecodeError, AttributeError) as e:
+        print(f"[Debug] JSON parsing failed: {e}")
+        pass
+    
+    # CSV-like format parsing
+    lines = response_text.strip().split('\n')
+    
+    for line in lines:
+        line = line.strip()
+        if not line or line.startswith('#'):
+            continue
+        
+        # Skip header lines
+        if 'type' in line.lower() and 'raw_name' in line.lower():
+            continue
+        
+        # Parse CSV
+        parts = []
+        current_part = []
+        in_quotes = False
+        
+        for char in line + ',':
+            if char == '"':
+                in_quotes = not in_quotes
+            elif char == ',' and not in_quotes:
+                parts.append(''.join(current_part).strip())
+                current_part = []
+            else:
+                current_part.append(char)
+        
+        if parts and parts[-1] == '':
+            parts = parts[:-1]
+        
+        if len(parts) >= 3:
+            entry_type = parts[0].lower()
+            
+            # Check if type is enabled
+            if entry_type not in enabled_types:
+                continue
+            
+            entry = {
+                'type': entry_type,
+                'raw_name': parts[1],
+                'translated_name': parts[2]
+            }
+            
+            # Add gender if type supports it and it's provided
+            type_config = custom_types.get(entry_type, {})
+            if type_config.get('has_gender', False) and len(parts) > 3 and parts[3]:
+                entry['gender'] = parts[3]
+            elif type_config.get('has_gender', False):
+                entry['gender'] = 'Unknown'
+            
+            # Add any custom fields
+            custom_fields_json = os.getenv('GLOSSARY_CUSTOM_FIELDS', '[]')
+            try:
+                custom_fields = json.loads(custom_fields_json)
+                start_idx = 4  # Always 4, not conditional
+                for i, field in enumerate(custom_fields):
+                    if len(parts) > start_idx + i:
+                        field_value = parts[start_idx + i]
+                        if field_value:  # Only add if not empty
+                            entry[field] = field_value
+            except:
+                pass
+            
+            entries.append(entry)
+    
+    return entries
+
+def validate_extracted_entry(entry):
+    """Validate that extracted entry has required fields and enabled type"""
+    if 'type' not in entry:
+        return False
+    
+    # Check if type is enabled
+    custom_types = get_custom_entry_types()
+    entry_type = entry.get('type', '').lower()
+    
+    if entry_type not in custom_types:
+        return False
+    
+    if not custom_types[entry_type].get('enabled', True):
+        return False
+    
+    # Must have raw_name and translated_name
+    if 'raw_name' not in entry or not entry['raw_name']:
+        return False
+    if 'translated_name' not in entry or not entry['translated_name']:
+        return False
+    
+    return True
+
+def build_prompt(chapter_text: str) -> tuple:
+    """Build the extraction prompt with custom types - returns (system_prompt, user_prompt)"""
+    custom_prompt = os.getenv('GLOSSARY_SYSTEM_PROMPT', '').strip()
+    
+    if not custom_prompt:
+        # If no custom prompt, create a default
+        custom_prompt = """Extract all character names and important terms from the text.
+
+{fields}
+
+Only include entries that appear in the text.
+Return the data in the exact format specified above."""
+    
+    # Check if the prompt contains {fields} placeholder
+    if '{fields}' in custom_prompt:
+        # Get enabled types
+        custom_types = get_custom_entry_types()
+        
+        enabled_types = [(t, cfg) for t, cfg in custom_types.items() if cfg.get('enabled', True)]
+        
+        # Get custom fields
+        custom_fields_json = os.getenv('GLOSSARY_CUSTOM_FIELDS', '[]')
+        try:
+            custom_fields = json.loads(custom_fields_json)
+        except:
+            custom_fields = []
+        
+        # Build fields specification based on what the prompt expects
+        # Check if the prompt mentions CSV or JSON to determine format
+        if 'CSV' in custom_prompt.upper():
+            # CSV format
+            fields_spec = []
+            
+            # Show the header format
+            header_parts = ['type', 'raw_name', 'translated_name', 'gender']
+            if custom_fields:
+                header_parts.extend(custom_fields)
+            fields_spec.append(','.join(header_parts))
+            
+            # Show examples for each type
+            for type_name, type_config in enabled_types:
+                example_parts = [type_name, '<name in original language>', '<English translation>']
+                
+                # Add gender field
+                if type_config.get('has_gender', False):
+                    example_parts.append('<Male/Female/Unknown>')
+                else:
+                    example_parts.append('')  # Empty for non-character types
+                
+                # Add custom field placeholders
+                for field in custom_fields:
+                    example_parts.append(f'<{field} value>')
+                
+                fields_spec.append(','.join(example_parts))
+            
+            fields_str = '\n'.join(fields_spec)
+        else:
+            # JSON format (default)
+            fields_spec = []
+            fields_spec.append("Extract entities and return as a JSON array.")
+            fields_spec.append("Each entry must be a JSON object with these exact fields:")
+            fields_spec.append("")
+            
+            for type_name, type_config in enabled_types:
+                fields_spec.append(f"For {type_name}s:")
+                fields_spec.append(f'  "type": "{type_name}" (required)')
+                fields_spec.append('  "raw_name": the name in original language/script (required)')
+                fields_spec.append('  "translated_name": English translation or romanization (required)')
+                if type_config.get('has_gender', False):
+                    fields_spec.append('  "gender": "Male", "Female", or "Unknown" (required for characters)')
+                fields_spec.append("")
+            
+            # Add custom fields info
+            if custom_fields:
+                fields_spec.append("Additional custom fields to include:")
+                for field in custom_fields:
+                    fields_spec.append(f'  "{field}": appropriate value')
+                fields_spec.append("")
+            
+            # Add example
+            if enabled_types:
+                fields_spec.append("Example output format:")
+                fields_spec.append('[')
+                examples = []
+                if 'character' in [t[0] for t in enabled_types]:
+                    example = '  {"type": "character", "raw_name": "田中太郎", "translated_name": "Tanaka Taro", "gender": "Male"'
+                    for field in custom_fields:
+                        example += f', "{field}": "example value"'
+                    example += '}'
+                    examples.append(example)
+                if 'term' in [t[0] for t in enabled_types]:
+                    example = '  {"type": "term", "raw_name": "東京駅", "translated_name": "Tokyo Station"'
+                    for field in custom_fields:
+                        example += f', "{field}": "example value"'
+                    example += '}'
+                    examples.append(example)
+                fields_spec.append(',\n'.join(examples))
+                fields_spec.append(']')
+            
+            fields_str = '\n'.join(fields_spec)
+        
+        # Replace {fields} placeholder
+        system_prompt = custom_prompt.replace('{fields}', fields_str)
+    else:
+        # No {fields} placeholder - use the prompt as-is
+        system_prompt = custom_prompt
+    
+    # Remove any {chapter_text} placeholders from system prompt
+    system_prompt = system_prompt.replace('{chapter_text}', '')
+    system_prompt = system_prompt.replace('{{chapter_text}}', '')
+    system_prompt = system_prompt.replace('{text}', '')
+    system_prompt = system_prompt.replace('{{text}}', '')
+    
+    # Strip any trailing "Text:" or similar
+    system_prompt = system_prompt.rstrip()
+    if system_prompt.endswith('Text:'):
+        system_prompt = system_prompt[:-5].rstrip()
+    
+    # User prompt is just the chapter text
+    user_prompt = chapter_text
+    
+    return (system_prompt, user_prompt)
+
+
+def skip_duplicate_entries(glossary):
+    """
+    Skip entries with duplicate raw names using fuzzy matching.
+    Returns deduplicated list maintaining first occurrence of each unique raw name.
+    """
+    import difflib
+    
+    # Get fuzzy threshold from environment
+    fuzzy_threshold = float(os.getenv('GLOSSARY_FUZZY_THRESHOLD', '0.9'))
+    
+    seen_raw_names = []  # List of (cleaned_name, original_entry) tuples
+    deduplicated = []
+    skipped_count = 0
+    
+    for entry in glossary:
+        # Get raw_name and clean it
+        raw_name = entry.get('raw_name', '')
+        if not raw_name:
+            continue
+            
+        # Remove honorifics for comparison (unless disabled)
+        cleaned_name = remove_honorifics(raw_name)
+        
+        # Check for fuzzy matches with seen names
+        is_duplicate = False
+        for seen_clean, seen_original in seen_raw_names:
+            similarity = difflib.SequenceMatcher(None, cleaned_name.lower(), seen_clean.lower()).ratio()
+            
+            if similarity >= fuzzy_threshold:
+                skipped_count += 1
+                print(f"[Skip] Duplicate entry: {raw_name} (cleaned: {cleaned_name}) - {similarity*100:.1f}% match with {seen_original}")
+                is_duplicate = True
+                break
+        
+        if not is_duplicate:
+            # Add to seen list and keep the entry
+            seen_raw_names.append((cleaned_name, entry.get('raw_name', '')))
+            deduplicated.append(entry)
+    
+    if skipped_count > 0:
+        print(f"⏭️ Skipped {skipped_count} duplicate entries (threshold: {fuzzy_threshold:.2f})")
+        print(f"✅ Kept {len(deduplicated)} unique entries")
+    
+    return deduplicated
+
+# Batch processing functions
+def process_chapter_batch(chapters_batch: List[Tuple[int, str]], 
+                         client: UnifiedClient,
+                         config: Dict,
+                         contextual_enabled: bool,
+                         history: List[Dict],
+                         ctx_limit: int,
+                         rolling_window: bool,
+                         check_stop,
+                         chunk_timeout: int = None) -> List[Dict]:
+    """
+    Process a batch of chapters in parallel with improved interrupt support
+    """
+    temp = float(os.getenv("GLOSSARY_TEMPERATURE") or config.get('temperature', 0.1))
+    
+    env_max_output = os.getenv("MAX_OUTPUT_TOKENS")
+    if env_max_output and env_max_output.isdigit():
+        mtoks = int(env_max_output)
+    else:
+        mtoks = config.get('max_tokens', 4196)
+    
+    results = []
+    
+    with ThreadPoolExecutor(max_workers=len(chapters_batch)) as executor:
+        futures = {}
+        
+        for idx, chap in chapters_batch:
+            if check_stop():
+                break
+                
+            # Get system and user prompts
+            system_prompt, user_prompt = build_prompt(chap)
+
+            # Build messages correctly with system and user prompts
+            if not contextual_enabled:
+                msgs = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ]
+            else:
+                msgs = [{"role": "system", "content": system_prompt}] \
+                     + trim_context_history(history, ctx_limit, rolling_window) \
+                     + [{"role": "user", "content": user_prompt}]
+
+            
+            # Submit to thread pool
+            future = executor.submit(
+                process_single_chapter_api_call,
+                idx, chap, msgs, client, temp, mtoks, check_stop, chunk_timeout
+            )
+            futures[future] = (idx, chap)
+        
+        # Process results with better cancellation
+        for future in as_completed(futures):  # Removed timeout - let futures complete
+            if check_stop():
+                print("🛑 Stop detected - cancelling all pending operations...")
+                # Cancel all pending futures immediately
+                cancelled = cancel_all_futures(list(futures.keys()))
+                if cancelled > 0:
+                    print(f"✅ Cancelled {cancelled} pending API calls")
+                # Shutdown executor immediately
+                executor.shutdown(wait=False)
+                break
+                
+            idx, chap = futures[future]
+            try:
+                result = future.result(timeout=0.5)  # Short timeout on result retrieval
+                # Ensure chap is added to result here if not already present
+                if 'chap' not in result:
+                    result['chap'] = chap
+                results.append(result)
+            except Exception as e:
+                if "stopped by user" in str(e).lower():
+                    print(f"✅ Chapter {idx+1} stopped by user")
+                else:
+                    print(f"Error processing chapter {idx+1}: {e}")
+                results.append({
+                    'idx': idx,
+                    'data': [],
+                    'resp': "",
+                    'chap': chap,
+                    'error': str(e)
+                })
+    
+    # Sort results by chapter index
+    results.sort(key=lambda x: x['idx'])
+    return results
+
+def process_single_chapter_api_call(idx: int, chap: str, msgs: List[Dict], 
+                                  client: UnifiedClient, temp: float, mtoks: int,
+                                  stop_check_fn, chunk_timeout: int = None) -> Dict:
+    """Process a single chapter API call with thread-safe payload handling"""
+    
+    # APPLY INTERRUPTIBLE THREADING DELAY FIRST
+    thread_delay = float(os.getenv("THREAD_SUBMISSION_DELAY_SECONDS", "0.5"))
+    if thread_delay > 0:
+        # Check if we need to wait (same logic as unified_api_client)
+        if hasattr(client, '_thread_submission_lock') and hasattr(client, '_last_thread_submission_time'):
+            with client._thread_submission_lock:
+                current_time = time.time()
+                time_since_last = current_time - client._last_thread_submission_time
+                
+                if time_since_last < thread_delay:
+                    sleep_time = thread_delay - time_since_last
+                    thread_name = threading.current_thread().name
+                    
+                    # PRINT BEFORE THE DELAY STARTS
+                    print(f"🧵 [{thread_name}] Applying thread delay: {sleep_time:.1f}s for Chapter {idx+1}")
+                    
+                    # Interruptible sleep - check stop flag every 0.1 seconds
+                    elapsed = 0
+                    check_interval = 0.1
+                    while elapsed < sleep_time:
+                        if stop_check_fn():
+                            print(f"🛑 Threading delay interrupted by stop flag")
+                            raise UnifiedClientError("Glossary extraction stopped by user during threading delay")
+                        
+                        sleep_chunk = min(check_interval, sleep_time - elapsed)
+                        time.sleep(sleep_chunk)
+                        elapsed += sleep_chunk
+                
+                client._last_thread_submission_time = time.time()
+                if not hasattr(client, '_thread_submission_count'):
+                    client._thread_submission_count = 0
+                client._thread_submission_count += 1
+    start_time = time.time()
+    print(f"[BATCH] Starting API call for Chapter {idx+1} at {time.strftime('%H:%M:%S')}")
+    
+    # Thread-safe payload directory
+    thread_name = threading.current_thread().name
+    thread_id = threading.current_thread().ident
+    thread_dir = os.path.join("Payloads", "glossary", f"{thread_name}_{thread_id}")
+    os.makedirs(thread_dir, exist_ok=True)
+    
+    try:
+        # Save request payload before API call
+        payload_file = os.path.join(thread_dir, f"chapter_{idx+1}_request.json")
+        with open(payload_file, 'w', encoding='utf-8') as f:
+            json.dump({
+                'chapter': idx + 1,
+                'messages': msgs,
+                'temperature': temp,
+                'max_tokens': mtoks,
+                'timestamp': time.strftime('%Y-%m-%d %H:%M:%S')
+            }, f, indent=2, ensure_ascii=False)
+        
+        # Use send_with_interrupt for API call
+        raw = send_with_interrupt(
+            messages=msgs,
+            client=client, 
+            temperature=temp,
+            max_tokens=mtoks,
+            stop_check_fn=stop_check_fn,
+            chunk_timeout=chunk_timeout
+        )
+
+        # Handle the response - it might be a tuple or a string
+        if raw is None:
+            print(f"⚠️ API returned None for chapter {idx+1}")
+            return {
+                'idx': idx,
+                'data': [],
+                'resp': "",
+                'chap': chap,
+                'error': "API returned None"
+            }
+
+        if isinstance(raw, tuple):
+            resp = raw[0] if raw[0] is not None else ""
+        elif isinstance(raw, str):
+            resp = raw
+        elif hasattr(raw, 'content'):
+            resp = raw.content if raw.content is not None else ""
+        elif hasattr(raw, 'text'):
+            resp = raw.text if raw.text is not None else ""
+        else:
+            resp = str(raw) if raw is not None else ""
+
+        # Ensure resp is never None
+        if resp is None:
+            resp = ""
+        
+        # Save the raw response in thread-safe location
+        response_file = os.path.join(thread_dir, f"chapter_{idx+1}_response.txt")
+        with open(response_file, "w", encoding="utf-8", errors="replace") as f:
+            f.write(resp)
+        
+        # Parse response using the new parser
+        data = parse_api_response(resp)
+        
+        # More detailed debug logging
+        print(f"[BATCH] Chapter {idx+1} - Raw response length: {len(resp)} chars")
+        print(f"[BATCH] Chapter {idx+1} - Parsed {len(data)} entries before validation")
+        
+        # Filter out invalid entries
+        valid_data = []
+        for entry in data:
+            if validate_extracted_entry(entry):
+                # Clean the raw_name
+                if 'raw_name' in entry:
+                    entry['raw_name'] = entry['raw_name'].strip()
+                valid_data.append(entry)
+            else:
+                print(f"[BATCH] Chapter {idx+1} - Invalid entry: {entry}")
+        
+        elapsed = time.time() - start_time
+        print(f"[BATCH] Completed Chapter {idx+1} in {elapsed:.1f}s at {time.strftime('%H:%M:%S')} - Extracted {len(valid_data)} valid entries")
+        
+        return {
+            'idx': idx,
+            'data': valid_data,
+            'resp': resp,
+            'chap': chap,  # Include the chapter text in the result
+            'error': None
+        }
+            
+    except UnifiedClientError as e:
+        print(f"[Error] API call interrupted/failed for chapter {idx+1}: {e}")
+        return {
+            'idx': idx,
+            'data': [],
+            'resp': "",
+            'chap': chap,  # Include chapter even on error
+            'error': str(e)
+        }
+    except Exception as e:
+        print(f"[Error] Unexpected error for chapter {idx+1}: {e}")
+        import traceback
+        print(f"[Error] Traceback: {traceback.format_exc()}")
+        return {
+            'idx': idx,
+            'data': [],
+            'resp': "",
+            'chap': chap,  # Include chapter even on error
+            'error': str(e)
+        }
+
+# Update main function to support batch processing:
+def main(log_callback=None, stop_callback=None):
+    """Modified main function that can accept a logging callback and stop callback"""
+    if log_callback:
+        set_output_redirect(log_callback)
+    
+    # Set up stop checking
+    def check_stop():
+        if stop_callback and stop_callback():
+            print("❌ Glossary extraction stopped by user request.")
+            return True
+        return is_stop_requested()
+        
+    start = time.time()
+    
+    # Handle both command line and GUI calls
+    if '--epub' in sys.argv:
+        # Command line mode
+        parser = argparse.ArgumentParser(description='Extract glossary from EPUB/TXT')
+        parser.add_argument('--epub', required=True, help='Path to EPUB/TXT file')
+        parser.add_argument('--output', required=True, help='Output glossary path')
+        parser.add_argument('--config', help='Config file path')
+        
+        args = parser.parse_args()
+        epub_path = args.epub
+    else:
+        # GUI mode - get from environment
+        epub_path = os.getenv("EPUB_PATH", "")
+        if not epub_path and len(sys.argv) > 1:
+            epub_path = sys.argv[1]
+        
+        # Create args object for GUI mode
+        import types
+        args = types.SimpleNamespace()
+        args.epub = epub_path
+        args.output = os.getenv("OUTPUT_PATH", "glossary.json")
+        args.config = os.getenv("CONFIG_PATH", "config.json")
+
+    is_text_file = epub_path.lower().endswith('.txt')
+    
+    if is_text_file:
+        # Import text processor
+        from extract_glossary_from_txt import extract_chapters_from_txt
+        chapters = extract_chapters_from_txt(epub_path)
+        file_base = os.path.splitext(os.path.basename(epub_path))[0]
+    else:
+        # Existing EPUB code
+        chapters = extract_chapters_from_epub(epub_path)
+        epub_base = os.path.splitext(os.path.basename(epub_path))[0]
+        file_base = epub_base
+
+    # If user didn't override --output, derive it from the EPUB filename:
+    if args.output == 'glossary.json':
+        args.output = f"{file_base}_glossary.json" 
+
+    # ensure we have a Glossary subfolder next to the JSON/MD outputs
+    glossary_dir = os.path.join(os.path.dirname(args.output), "Glossary")
+    os.makedirs(glossary_dir, exist_ok=True)
+
+    # override the module‐level PROGRESS_FILE to include epub name
+    global PROGRESS_FILE
+    PROGRESS_FILE = os.path.join(
+        glossary_dir,
+        f"{file_base}_glossary_progress.json"
+    )
+
+    config = load_config(args.config)
+    
+    # Get API key from environment variables (set by GUI) or config file
+    api_key = (os.getenv("API_KEY") or 
+               os.getenv("OPENAI_API_KEY") or 
+               os.getenv("OPENAI_OR_Gemini_API_KEY") or
+               os.getenv("GEMINI_API_KEY") or
+               config.get('api_key'))
+
+    # Get model from environment or config
+    model = os.getenv("MODEL") or config.get('model', 'gemini-1.5-flash')
+
+    # Define output directory (use current directory as default)
+    out = os.path.dirname(args.output) if hasattr(args, 'output') else os.getcwd()
+
+    # Use the variables we just retrieved
+    client = create_client_with_multi_key_support(api_key, model, out, config)
+    
+    # Check for batch mode
+    batch_enabled = os.getenv("BATCH_TRANSLATION", "0") == "1"
+    batch_size = int(os.getenv("BATCH_SIZE", "5"))
+    conservative_batching = os.getenv("CONSERVATIVE_BATCHING", "0") == "1"
+    
+    print(f"[DEBUG] BATCH_TRANSLATION = {os.getenv('BATCH_TRANSLATION')} (enabled: {batch_enabled})")
+    print(f"[DEBUG] BATCH_SIZE = {batch_size}")
+    print(f"[DEBUG] CONSERVATIVE_BATCHING = {os.getenv('CONSERVATIVE_BATCHING')} (enabled: {conservative_batching})")
+    
+    if batch_enabled:
+        print(f"🚀 Glossary batch mode enabled with size: {batch_size}")
+        print(f"📑 Note: Glossary extraction uses direct batching (not affected by conservative batching setting)")
+    
+    #API call delay
+    api_delay = float(os.getenv("SEND_INTERVAL_SECONDS", "2"))
+    print(f"⏱️  API call delay: {api_delay} seconds")
+    
+    # Get compression factor from environment
+    compression_factor = float(os.getenv("COMPRESSION_FACTOR", "1.0"))
+    print(f"📐 Compression Factor: {compression_factor}")
+
+    # Initialize chapter splitter with compression factor
+    chapter_splitter = ChapterSplitter(model_name=model, compression_factor=compression_factor)
+    
+    # Get temperature from environment or config
+    temp = float(os.getenv("GLOSSARY_TEMPERATURE") or config.get('temperature', 0.1))
+    
+    env_max_output = os.getenv("MAX_OUTPUT_TOKENS")
+    if env_max_output and env_max_output.isdigit():
+        mtoks = int(env_max_output)
+        print(f"[DEBUG] Output Token Limit: {mtoks} (from GUI)")
+    else:
+        mtoks = config.get('max_tokens', 4196)
+        print(f"[DEBUG] Output Token Limit: {mtoks} (from config)")
+    
+    # Get context limit from environment or config
+    ctx_limit = int(os.getenv("GLOSSARY_CONTEXT_LIMIT") or config.get('context_limit_chapters', 3))
+
+    # Parse chapter range from environment
+    chapter_range = os.getenv("CHAPTER_RANGE", "").strip()
+    range_start = None
+    range_end = None
+    if chapter_range and re.match(r"^\d+\s*-\s*\d+$", chapter_range):
+        range_start, range_end = map(int, chapter_range.split("-", 1))
+        print(f"📊 Chapter Range Filter: {range_start} to {range_end}")
+    elif chapter_range:
+        print(f"⚠️ Invalid chapter range format: {chapter_range} (use format: 5-10)")
+
+    # Log settings
+    format_parts = ["type", "raw_name", "translated_name", "gender"]
+    custom_fields_json = os.getenv('GLOSSARY_CUSTOM_FIELDS', '[]')
+    try:
+        custom_fields = json.loads(custom_fields_json)
+        if custom_fields:
+            format_parts.extend(custom_fields)
+    except:
+        pass
+    print(f"📑 Glossary Format: Simple ({', '.join(format_parts)})")
+    
+    # Check honorifics filter toggle
+    honorifics_disabled = os.getenv('GLOSSARY_DISABLE_HONORIFICS_FILTER', '0') == '1'
+    if honorifics_disabled:
+        print("📑 Honorifics Filtering: ❌ DISABLED")
+    else:
+        print("📑 Honorifics Filtering: ✅ ENABLED")
+    
+    # Log custom fields
+    custom_fields_json = os.getenv('GLOSSARY_CUSTOM_FIELDS', '[]')
+    try:
+        custom_fields = json.loads(custom_fields_json)
+        if custom_fields:
+            print(f"📑 Custom Fields: {', '.join(custom_fields)}")
+    except:
+        pass
+    
+    # Check if custom prompt is being used
+    if os.getenv('GLOSSARY_SYSTEM_PROMPT'):
+        print("📑 Using custom extraction prompt")
+    else:
+        print("📑 Using default extraction prompt")
+
+    if is_text_file:
+        from extract_glossary_from_txt import extract_chapters_from_txt
+        chapters = extract_chapters_from_txt(args.epub)
+    else:
+        chapters = extract_chapters_from_epub(args.epub)
+    
+    if not chapters:
+        print("No chapters found. Exiting.")
+        return
+
+    # Check for stop before starting processing
+    if check_stop():
+        return
+
+    prog = load_progress()
+    completed = prog['completed']
+    glossary = prog['glossary']
+    history = prog['context_history']
+    total_chapters = len(chapters)
+    
+    # Get both settings
+    contextual_enabled = os.getenv('CONTEXTUAL', '1') == '1'
+    rolling_window = os.getenv('GLOSSARY_HISTORY_ROLLING', '0') == '1'
+    
+    # Count chapters that will be processed with range filter
+    chapters_to_process = []
+    for idx, chap in enumerate(chapters):
+        # Skip if chapter is outside the range
+        if range_start is not None and range_end is not None:
+            chapter_num = idx + 1  # 1-based chapter numbering
+            if not (range_start <= chapter_num <= range_end):
+                continue
+        if idx not in completed:
+            chapters_to_process.append((idx, chap))
+    
+    if len(chapters_to_process) < total_chapters:
+        print(f"📊 Processing {len(chapters_to_process)} out of {total_chapters} chapters")
+    
+    # Get chunk timeout from environment  
+    chunk_timeout = int(os.getenv("CHUNK_TIMEOUT", "900"))  # 15 minutes default
+    
+    # Process chapters based on mode
+    if batch_enabled and len(chapters_to_process) > 0:
+        # BATCH MODE: Process in batches with per-entry saving
+        total_batches = (len(chapters_to_process) + batch_size - 1) // batch_size
+        
+        for batch_num in range(total_batches):
+            # Check for stop at the beginning of each batch
+            if check_stop():
+                print(f"❌ Glossary extraction stopped at batch {batch_num+1}")
+                # Apply deduplication before stopping
+                if glossary:
+                    print("🔀 Applying deduplication and sorting before exit...")
+                    glossary[:] = skip_duplicate_entries(glossary)
+                    
+                    # Sort glossary
+                    custom_types = get_custom_entry_types()
+                    type_order = {'character': 0, 'term': 1}
+                    other_types = sorted([t for t in custom_types.keys() if t not in ['character', 'term']])
+                    for i, t in enumerate(other_types):
+                        type_order[t] = i + 2
+                    glossary.sort(key=lambda x: (
+                        type_order.get(x.get('type', 'term'), 999),
+                        x.get('raw_name', '').lower()
+                    ))
+                    
+                    save_progress(completed, glossary, history)
+                    save_glossary_json(glossary, os.path.join(glossary_dir, os.path.basename(args.output)))
+                    save_glossary_csv(glossary, os.path.join(glossary_dir, os.path.basename(args.output)))
+                    print(f"✅ Saved {len(glossary)} deduplicated entries before exit")
+                return
+            
+            # Get current batch
+            batch_start = batch_num * batch_size
+            batch_end = min(batch_start + batch_size, len(chapters_to_process))
+            current_batch = chapters_to_process[batch_start:batch_end]
+            
+            print(f"\n🔄 Processing Batch {batch_num+1}/{total_batches} (Chapters: {[idx+1 for idx, _ in current_batch]})")
+            print(f"[BATCH] Submitting {len(current_batch)} chapters for parallel processing...")
+            batch_start_time = time.time()
+            
+            # Process batch in parallel BUT handle results as they complete
+            temp = float(os.getenv("GLOSSARY_TEMPERATURE") or config.get('temperature', 0.1))
+            env_max_output = os.getenv("MAX_OUTPUT_TOKENS")
+            if env_max_output and env_max_output.isdigit():
+                mtoks = int(env_max_output)
+            else:
+                mtoks = config.get('max_tokens', 4196)
+            
+            batch_entry_count = 0
+            
+            with ThreadPoolExecutor(max_workers=len(current_batch)) as executor:
+                futures = {}
+                
+                # Submit all chapters in the batch
+                for idx, chap in current_batch:
+                    if check_stop():
+                        # Apply deduplication before breaking
+                        if glossary:
+                            print("🔀 Applying deduplication before stopping...")
+                            glossary[:] = skip_duplicate_entries(glossary)
+                            save_glossary_json(glossary, os.path.join(glossary_dir, os.path.basename(args.output)))
+                            save_glossary_csv(glossary, os.path.join(glossary_dir, os.path.basename(args.output)))
+                        break
+                        
+                    # Get system and user prompts
+                    system_prompt, user_prompt = build_prompt(chap)
+                    
+                    # Build messages
+                    if not contextual_enabled:
+                        msgs = [
+                            {"role": "system", "content": system_prompt},
+                            {"role": "user", "content": user_prompt}
+                        ]
+                    else:
+                        msgs = [{"role": "system", "content": system_prompt}] \
+                             + trim_context_history(history, ctx_limit, rolling_window) \
+                             + [{"role": "user", "content": user_prompt}]
+                    
+                    # Submit to thread pool
+                    future = executor.submit(
+                        process_single_chapter_api_call,
+                        idx, chap, msgs, client, temp, mtoks, check_stop, chunk_timeout
+                    )
+                    futures[future] = (idx, chap)
+                    # Small yield to keep GUI responsive when submitting many tasks
+                    if idx % 5 == 0:
+                        time.sleep(0.001)
+                    # Small yield to keep GUI responsive when submitting many tasks
+                    if idx % 5 == 0:
+                        time.sleep(0.001)
+                
+                # Process results AS THEY COMPLETE, not all at once
+                for future in as_completed(futures):
+                    if check_stop():
+                        print("🛑 Stop detected - cancelling all pending operations...")
+                        cancelled = cancel_all_futures(list(futures.keys()))
+                        if cancelled > 0:
+                            print(f"✅ Cancelled {cancelled} pending API calls")
+                        
+                        # Apply deduplication before stopping
+                        if glossary:
+                            print("🔀 Applying deduplication and sorting before exit...")
+                            glossary[:] = skip_duplicate_entries(glossary)
+                            
+                            # Sort glossary
+                            custom_types = get_custom_entry_types()
+                            type_order = {'character': 0, 'term': 1}
+                            other_types = sorted([t for t in custom_types.keys() if t not in ['character', 'term']])
+                            for i, t in enumerate(other_types):
+                                type_order[t] = i + 2
+                            glossary.sort(key=lambda x: (
+                                type_order.get(x.get('type', 'term'), 999),
+                                x.get('raw_name', '').lower()
+                            ))
+                            
+                            save_progress(completed, glossary, history)
+                            save_glossary_json(glossary, os.path.join(glossary_dir, os.path.basename(args.output)))
+                            save_glossary_csv(glossary, os.path.join(glossary_dir, os.path.basename(args.output)))
+                            print(f"✅ Saved {len(glossary)} deduplicated entries before exit")
+                        
+                        executor.shutdown(wait=False)
+                        break
+                    
+                    idx, chap = futures[future]
+                    
+                    try:
+                        result = future.result(timeout=0.5)
+                        
+                        # Process this chapter's results immediately
+                        data = result.get('data', [])
+                        resp = result.get('resp', '')
+                        error = result.get('error')
+                        
+                        if error:
+                            print(f"[Chapter {idx+1}] Error: {error}")
+                            completed.append(idx)
+                            continue
+                        
+                        # Process and save entries IMMEDIATELY as each chapter completes
+                        if data and len(data) > 0:
+                            total_ent = len(data)
+                            batch_entry_count += total_ent
+                            
+                            for eidx, entry in enumerate(data, start=1):
+                                elapsed = time.time() - start
+                                
+                                # Get entry info
+                                entry_type = entry.get("type", "?")
+                                raw_name = entry.get("raw_name", "?")
+                                trans_name = entry.get("translated_name", "?")
+                                
+                                print(f'[Chapter {idx+1}/{total_chapters}] [{eidx}/{total_ent}] ({elapsed:.1f}s elapsed) → {entry_type}: {raw_name} ({trans_name})')
+                                
+                                # Add entry immediately WITHOUT deduplication
+                                glossary.append(entry)
+                                
+                                # Save immediately after EACH entry
+                                save_progress(completed, glossary, history)
+                                save_glossary_json(glossary, os.path.join(glossary_dir, os.path.basename(args.output)))
+                                save_glossary_csv(glossary, os.path.join(glossary_dir, os.path.basename(args.output)))
+                        
+                        completed.append(idx)
+                        
+                        # Add to history if contextual is enabled
+                        if contextual_enabled and resp and chap:
+                            system_prompt, user_prompt = build_prompt(chap)
+                            history.append({"user": user_prompt, "assistant": resp})
+                        
+                    except Exception as e:
+                        if "stopped by user" in str(e).lower():
+                            print(f"✅ Chapter {idx+1} stopped by user")
+                        else:
+                            print(f"Error processing chapter {idx+1}: {e}")
+                        completed.append(idx)
+            
+            batch_elapsed = time.time() - batch_start_time
+            print(f"[BATCH] Batch {batch_num+1} completed in {batch_elapsed:.1f}s total")
+            
+            # After batch completes, apply deduplication and sorting
+            if batch_entry_count > 0:
+                print(f"\n🔀 Applying deduplication and sorting after batch {batch_num+1}/{total_batches}")
+                original_size = len(glossary)
+                
+                # Apply deduplication to entire glossary
+                glossary[:] = skip_duplicate_entries(glossary)
+                
+                # Sort glossary by type and name
+                custom_types = get_custom_entry_types()
+                type_order = {'character': 0, 'term': 1}
+                other_types = sorted([t for t in custom_types.keys() if t not in ['character', 'term']])
+                for i, t in enumerate(other_types):
+                    type_order[t] = i + 2
+                
+                glossary.sort(key=lambda x: (
+                    type_order.get(x.get('type', 'term'), 999),
+                    x.get('raw_name', '').lower()
+                ))
+                
+                deduplicated_size = len(glossary)
+                removed = original_size - deduplicated_size
+                
+                if removed > 0:
+                    print(f"✅ Removed {removed} duplicates (fuzzy threshold: {os.getenv('GLOSSARY_FUZZY_THRESHOLD', '0.90')})")
+                print(f"📊 Glossary size: {deduplicated_size} unique entries")
+                
+                # Save final deduplicated and sorted glossary
+                save_progress(completed, glossary, history)
+                save_glossary_json(glossary, os.path.join(glossary_dir, os.path.basename(args.output)))
+                save_glossary_csv(glossary, os.path.join(glossary_dir, os.path.basename(args.output)))
+            
+            # Print batch summary
+            if batch_entry_count > 0:
+                print(f"\n📊 Batch {batch_num+1}/{total_batches} Summary:")
+                print(f"   • Chapters processed: {len(current_batch)}")
+                print(f"   • Total entries extracted: {batch_entry_count}")
+                print(f"   • Glossary size: {len(glossary)} unique entries")
+            
+            # Handle context history
+            if contextual_enabled:
+                if not rolling_window and len(history) >= ctx_limit and ctx_limit > 0:
+                    print(f"🔄 Resetting glossary context (reached {ctx_limit} chapter limit)")
+                    history = []
+                    prog['context_history'] = []
+            
+            # Add delay between batches (but not after the last batch)
+            if batch_num < total_batches - 1:
+                print(f"\n⏱️  Waiting {api_delay}s before next batch...")
+                if not interruptible_sleep(api_delay, check_stop, 0.1):
+                    print(f"❌ Glossary extraction stopped during delay")
+                    # Apply deduplication before stopping
+                    if glossary:
+                        print("🔀 Applying deduplication and sorting before exit...")
+                        glossary[:] = skip_duplicate_entries(glossary)
+                        
+                        # Sort glossary
+                        custom_types = get_custom_entry_types()
+                        type_order = {'character': 0, 'term': 1}
+                        other_types = sorted([t for t in custom_types.keys() if t not in ['character', 'term']])
+                        for i, t in enumerate(other_types):
+                            type_order[t] = i + 2
+                        glossary.sort(key=lambda x: (
+                            type_order.get(x.get('type', 'term'), 999),
+                            x.get('raw_name', '').lower()
+                        ))
+                        
+                        save_progress(completed, glossary, history)
+                        save_glossary_json(glossary, os.path.join(glossary_dir, os.path.basename(args.output)))
+                        save_glossary_csv(glossary, os.path.join(glossary_dir, os.path.basename(args.output)))
+                        print(f"✅ Saved {len(glossary)} deduplicated entries before exit")
+                    return
+    
+    else:
+        # SEQUENTIAL MODE: Original behavior
+        for idx, chap in enumerate(chapters):
+            # Check for stop at the beginning of each chapter
+            if check_stop():
+                print(f"❌ Glossary extraction stopped at chapter {idx+1}")
+                return
+            
+            # Apply chapter range filter
+            if range_start is not None and range_end is not None:
+                chapter_num = idx + 1  # 1-based chapter numbering
+                if not (range_start <= chapter_num <= range_end):
+                    # Check if this is from a text file
+                    is_text_chapter = hasattr(chap, 'filename') and chap.get('filename', '').endswith('.txt')
+                    terminology = "Section" if is_text_chapter else "Chapter"
+                    print(f"[SKIP] {terminology} {chapter_num} - outside range filter")
+                    continue
+                
+            if idx in completed:
+                # Check if processing text file chapters
+                is_text_chapter = hasattr(chap, 'filename') and chap.get('filename', '').endswith('.txt')
+                terminology = "section" if is_text_chapter else "chapter"
+                print(f"Skipping {terminology} {idx+1} (already processed)")
+                continue
+                    
+            print(f"🔄 Processing Chapter {idx+1}/{total_chapters}")
+            
+            # Check if history will reset on this chapter
+            if contextual_enabled and len(history) >= ctx_limit and ctx_limit > 0 and not rolling_window:
+                print(f"  📌 Glossary context will reset after this chapter (current: {len(history)}/{ctx_limit} chapters)")        
+
+            try:
+                # Get system and user prompts from build_prompt
+                system_prompt, user_prompt = build_prompt(chap)
+                
+                if not contextual_enabled:
+                    # No context at all
+                    msgs = [
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": user_prompt}
+                    ]
+                else:
+                    # Use context with trim_context_history handling the mode
+                    msgs = [{"role": "system", "content": system_prompt}] \
+                         + trim_context_history(history, ctx_limit, rolling_window) \
+                         + [{"role": "user", "content": user_prompt}]
+                
+                total_tokens = sum(count_tokens(m["content"]) for m in msgs)
+                
+                # READ THE TOKEN LIMIT
+                env_value = os.getenv("MAX_INPUT_TOKENS", "1000000").strip()
+                if not env_value or env_value == "":
+                    token_limit = None
+                    limit_str = "unlimited"
+                elif env_value.isdigit() and int(env_value) > 0:
+                    token_limit = int(env_value)
+                    limit_str = str(token_limit)
+                else:
+                    token_limit = 1000000
+                    limit_str = "1000000 (default)"
+                
+                print(f"[DEBUG] Glossary prompt tokens = {total_tokens} / {limit_str}")
+                
+                # Check if we're over the token limit and need to split
+                if token_limit is not None and total_tokens > token_limit:
+                    print(f"⚠️ Chapter {idx+1} exceeds token limit: {total_tokens} > {token_limit}")
+                    print(f"📄 Using ChapterSplitter to split into smaller chunks...")
+                    
+                    # Calculate available tokens for content
+                    system_tokens = chapter_splitter.count_tokens(system_prompt)
+                    context_tokens = sum(chapter_splitter.count_tokens(m["content"]) for m in trim_context_history(history, ctx_limit, rolling_window))
+                    safety_margin = 1000
+                    available_tokens = token_limit - system_tokens - context_tokens - safety_margin
+                    
+                    # Since glossary extraction works with plain text, wrap it in a simple HTML structure
+                    chapter_html = f"<html><body><p>{chap.replace(chr(10)+chr(10), '</p><p>')}</p></body></html>"
+                    
+                    # Use ChapterSplitter to split the chapter
+                    chunks = chapter_splitter.split_chapter(chapter_html, available_tokens)
+                    print(f"📄 Chapter split into {len(chunks)} chunks")
+                    
+                    # Process each chunk
+                    chapter_glossary_data = []  # Collect data from all chunks
+                    
+                    for chunk_html, chunk_idx, total_chunks in chunks:
+                        if check_stop():
+                            print(f"❌ Glossary extraction stopped during chunk {chunk_idx} of chapter {idx+1}")
+                            return
+                            
+                        print(f"🔄 Processing chunk {chunk_idx}/{total_chunks} of Chapter {idx+1}")
+                        
+                        # Extract text from the chunk HTML
+                        from bs4 import BeautifulSoup
+                        soup = BeautifulSoup(chunk_html, 'html.parser')
+                        chunk_text = soup.get_text(strip=True)
+                        
+                        # Get system and user prompts for chunk
+                        chunk_system_prompt, chunk_user_prompt = build_prompt(chunk_text)
+
+                        # Build chunk messages
+                        if not contextual_enabled:
+                            chunk_msgs = [
+                                {"role": "system", "content": chunk_system_prompt},
+                                {"role": "user", "content": chunk_user_prompt}
+                            ]
+                        else:
+                            chunk_msgs = [{"role": "system", "content": chunk_system_prompt}] \
+                                       + trim_context_history(history, ctx_limit, rolling_window) \
+                                       + [{"role": "user", "content": chunk_user_prompt}]
+
+                        # API call for chunk
+                        try:
+                            chunk_raw = send_with_interrupt(
+                                messages=chunk_msgs,
+                                client=client,
+                                temperature=temp,
+                                max_tokens=mtoks,
+                                stop_check_fn=check_stop,
+                                chunk_timeout=chunk_timeout
+                            )
+                        except UnifiedClientError as e:
+                            if "stopped by user" in str(e).lower():
+                                print(f"❌ Glossary extraction stopped during chunk {chunk_idx} API call")
+                                return
+                            elif "timeout" in str(e).lower():
+                                print(f"⚠️ Chunk {chunk_idx} API call timed out: {e}")
+                                continue  # Skip this chunk
+                            else:
+                                print(f"❌ Chunk {chunk_idx} API error: {e}")
+                                continue  # Skip this chunk
+                        except Exception as e:
+                            print(f"❌ Unexpected error in chunk {chunk_idx}: {e}")
+                            continue  # Skip this chunk
+                        
+                        # Process chunk response
+                        if chunk_raw is None:
+                            print(f"❌ API returned None for chunk {chunk_idx}")
+                            continue
+
+                        # Handle different response types
+                        if isinstance(chunk_raw, tuple):
+                            chunk_resp = chunk_raw[0] if chunk_raw[0] is not None else ""
+                        elif isinstance(chunk_raw, str):
+                            chunk_resp = chunk_raw
+                        elif hasattr(chunk_raw, 'content'):
+                            chunk_resp = chunk_raw.content if chunk_raw.content is not None else ""
+                        elif hasattr(chunk_raw, 'text'):
+                            chunk_resp = chunk_raw.text if chunk_raw.text is not None else ""
+                        else:
+                            print(f"❌ Unexpected response type for chunk {chunk_idx}: {type(chunk_raw)}")
+                            chunk_resp = str(chunk_raw) if chunk_raw is not None else ""
+
+                        # Ensure resp is a string
+                        if not isinstance(chunk_resp, str):
+                            print(f"⚠️ Converting non-string response to string for chunk {chunk_idx}")
+                            chunk_resp = str(chunk_resp) if chunk_resp is not None else ""
+
+                        # Check if response is empty
+                        if not chunk_resp or chunk_resp.strip() == "":
+                            print(f"⚠️ Empty response for chunk {chunk_idx}, skipping...")
+                            continue
+                        
+                        # Save chunk response with thread-safe location
+                        thread_name = threading.current_thread().name
+                        thread_id = threading.current_thread().ident
+                        thread_dir = os.path.join("Payloads", "glossary", f"{thread_name}_{thread_id}")
+                        os.makedirs(thread_dir, exist_ok=True)
+                        
+                        with open(os.path.join(thread_dir, f"chunk_response_chap{idx+1}_chunk{chunk_idx}.txt"), "w", encoding="utf-8", errors="replace") as f:
+                            f.write(chunk_resp)
+                        
+                        # Extract data from chunk
+                        chunk_resp_data = parse_api_response(chunk_resp)
+
+                        if not chunk_resp_data:
+                            print(f"[Warning] No data found in chunk {chunk_idx}, skipping...")
+                            continue
+
+                        # The parse_api_response already returns parsed data, no need to parse again
+                        try:
+                            # Filter out invalid entries directly from chunk_resp_data
+                            valid_chunk_data = []
+                            for entry in chunk_resp_data:
+                                if validate_extracted_entry(entry):
+                                    # Clean the raw_name
+                                    if 'raw_name' in entry:
+                                        entry['raw_name'] = entry['raw_name'].strip()
+                                    valid_chunk_data.append(entry)
+                                else:
+                                    print(f"[Debug] Skipped invalid entry in chunk {chunk_idx}: {entry}")
+                            
+                            chapter_glossary_data.extend(valid_chunk_data)
+                            print(f"✅ Chunk {chunk_idx}/{total_chunks}: extracted {len(valid_chunk_data)} entries")
+                            
+                            # Add chunk to history if contextual
+                            if contextual_enabled:
+                                history.append({"user": chunk_user_prompt, "assistant": chunk_resp})
+
+                        except Exception as e:
+                            print(f"[Warning] Error processing chunk {chunk_idx} data: {e}")
+                            continue
+                        
+                        # Add delay between chunks (but not after last chunk)
+                        if chunk_idx < total_chunks:
+                            print(f"⏱️  Waiting {api_delay}s before next chunk...")
+                            if not interruptible_sleep(api_delay, check_stop, 0.1):
+                                print(f"❌ Glossary extraction stopped during chunk delay")
+                                return
+                    
+                    # Use the collected data from all chunks
+                    data = chapter_glossary_data
+                    resp = ""  # Combined response not needed for progress tracking
+                    print(f"✅ Chapter {idx+1} processed in {len(chunks)} chunks, total entries: {len(data)}")
+                    
+                else:
+                    # Original single-chapter processing
+                    # Check for stop before API call
+                    if check_stop():
+                        print(f"❌ Glossary extraction stopped before API call for chapter {idx+1}")
+                        return
+                
+                    try:
+                        # Use send_with_interrupt for API call
+                        raw = send_with_interrupt(
+                            messages=msgs,
+                            client=client,
+                            temperature=temp,
+                            max_tokens=mtoks,
+                            stop_check_fn=check_stop,
+                            chunk_timeout=chunk_timeout
+                        )
+                    except UnifiedClientError as e:
+                        if "stopped by user" in str(e).lower():
+                            print(f"❌ Glossary extraction stopped during API call for chapter {idx+1}")
+                            return
+                        elif "timeout" in str(e).lower():
+                            print(f"⚠️ API call timed out for chapter {idx+1}: {e}")
+                            continue
+                        else:
+                            print(f"❌ API error for chapter {idx+1}: {e}")
+                            continue
+                    except Exception as e:
+                        print(f"❌ Unexpected error for chapter {idx+1}: {e}")
+                        continue
+                    
+                    # Handle response
+                    if raw is None:
+                        print(f"❌ API returned None for chapter {idx+1}")
+                        continue
+
+                    # Handle different response types
+                    if isinstance(raw, tuple):
+                        resp = raw[0] if raw[0] is not None else ""
+                    elif isinstance(raw, str):
+                        resp = raw
+                    elif hasattr(raw, 'content'):
+                        resp = raw.content if raw.content is not None else ""
+                    elif hasattr(raw, 'text'):
+                        resp = raw.text if raw.text is not None else ""
+                    else:
+                        print(f"❌ Unexpected response type for chapter {idx+1}: {type(raw)}")
+                        resp = str(raw) if raw is not None else ""
+
+                    # Ensure resp is a string
+                    if not isinstance(resp, str):
+                        print(f"⚠️ Converting non-string response to string for chapter {idx+1}")
+                        resp = str(resp) if resp is not None else ""
+
+                    # NULL CHECK before checking if response is empty
+                    if resp is None:
+                        print(f"⚠️ Response is None for chapter {idx+1}, skipping...")
+                        continue
+
+                    # Check if response is empty
+                    if not resp or resp.strip() == "":
+                        print(f"⚠️ Empty response for chapter {idx+1}, skipping...")
+                        continue
+
+                    # Save the raw response with thread-safe location
+                    thread_name = threading.current_thread().name
+                    thread_id = threading.current_thread().ident
+                    thread_dir = os.path.join("Payloads", "glossary", f"{thread_name}_{thread_id}")
+                    os.makedirs(thread_dir, exist_ok=True)
+                    
+                    with open(os.path.join(thread_dir, f"response_chap{idx+1}.txt"), "w", encoding="utf-8", errors="replace") as f:
+                        f.write(resp)
+
+                    # Parse response using the new parser
+                    try:
+                        data = parse_api_response(resp)
+                    except Exception as e:
+                        print(f"❌ Error parsing response for chapter {idx+1}: {e}")
+                        print(f"   Response preview: {resp[:200] if resp else 'None'}...")
+                        continue
+                    
+                    # Filter out invalid entries
+                    valid_data = []
+                    for entry in data:
+                        if validate_extracted_entry(entry):
+                            # Clean the raw_name
+                            if 'raw_name' in entry:
+                                entry['raw_name'] = entry['raw_name'].strip()
+                            valid_data.append(entry)
+                        else:
+                            print(f"[Debug] Skipped invalid entry: {entry}")
+                    
+                    data = valid_data
+                    total_ent = len(data)
+                    
+                    # Log entries
+                    for eidx, entry in enumerate(data, start=1):
+                        if check_stop():
+                            print(f"❌ Glossary extraction stopped during entry processing for chapter {idx+1}")
+                            return
+                            
+                        elapsed = time.time() - start
+                        if idx == 0 and eidx == 1:
+                            eta = 0
+                        else:
+                            avg = elapsed / ((idx * 100) + eidx)
+                            eta = avg * (total_chapters * 100 - ((idx * 100) + eidx))
+                        
+                        # Get entry info based on new format
+                        entry_type = entry.get("type", "?")
+                        raw_name = entry.get("raw_name", "?")
+                        trans_name = entry.get("translated_name", "?")
+                        
+                        print(f'[Chapter {idx+1}/{total_chapters}] [{eidx}/{total_ent}] ({elapsed:.1f}s elapsed, ETA {eta:.1f}s) → {entry_type}: {raw_name} ({trans_name})')    
+                    
+                # Apply skip logic and save
+                glossary.extend(data)
+                glossary[:] = skip_duplicate_entries(glossary)
+                completed.append(idx)
+
+                # Only add to history if contextual is enabled
+                if contextual_enabled and 'resp' in locals() and resp:
+                    history.append({"user": user_prompt, "assistant": resp})
+                    
+                    # Reset history when limit reached without rolling window
+                    if not rolling_window and len(history) >= ctx_limit and ctx_limit > 0:
+                        print(f"🔄 Resetting glossary context (reached {ctx_limit} chapter limit)")
+                        history = []
+                        prog['context_history'] = []
+
+                save_progress(completed, glossary, history)
+                save_glossary_json(glossary, os.path.join(glossary_dir, os.path.basename(args.output)))
+                save_glossary_csv(glossary, os.path.join(glossary_dir, os.path.basename(args.output)))
+                
+                # Add delay before next API call (but not after the last chapter)
+                if idx < len(chapters) - 1:
+                    # Check if we're within the range or if there are more chapters to process
+                    next_chapter_in_range = True
+                    if range_start is not None and range_end is not None:
+                        next_chapter_num = idx + 2  # idx+1 is current, idx+2 is next
+                        next_chapter_in_range = (range_start <= next_chapter_num <= range_end)
+                    else:
+                        # No range filter, check if next chapter is already completed
+                        next_chapter_in_range = (idx + 1) not in completed
+                    
+                    if next_chapter_in_range:
+                        print(f"⏱️  Waiting {api_delay}s before next chapter...")
+                        if not interruptible_sleep(api_delay, check_stop, 0.1):
+                            print(f"❌ Glossary extraction stopped during delay")
+                            return
+                            
+                # Check for stop after processing chapter
+                if check_stop():
+                    print(f"❌ Glossary extraction stopped after processing chapter {idx+1}")
+                    return
+
+            except Exception as e:
+                print(f"Error at chapter {idx+1}: {e}")
+                import traceback
+                print(f"Full traceback: {traceback.format_exc()}")
+                # Check for stop even after error
+                if check_stop():
+                    print(f"❌ Glossary extraction stopped after error in chapter {idx+1}")
+                    return
+    
+    print(f"Done. Glossary saved to {args.output}")
+    
+    # Also save as CSV format for compatibility
+    try:
+        csv_output = args.output.replace('.json', '.csv')
+        csv_path = os.path.join(glossary_dir, os.path.basename(csv_output))
+        save_glossary_csv(glossary, os.path.join(glossary_dir, os.path.basename(args.output)))
+        print(f"Also saved as CSV: {csv_path}")
+    except Exception as e:
+        print(f"[Warning] Could not save CSV format: {e}")
+
+def save_progress(completed: List[int], glossary: List[Dict], context_history: List[Dict]):
+    """Save progress to JSON file"""
+    progress_data = {
+        "completed": completed,
+        "glossary": glossary,
+        "context_history": context_history
+    }
+    
+    try:
+        # Use atomic write to prevent corruption
+        temp_file = PROGRESS_FILE + '.tmp'
+        with open(temp_file, 'w', encoding='utf-8') as f:
+            json.dump(progress_data, f, ensure_ascii=False, indent=2)
+        
+        # Replace the old file with the new one
+        if os.path.exists(PROGRESS_FILE):
+            os.remove(PROGRESS_FILE)
+        os.rename(temp_file, PROGRESS_FILE)
+        
+    except Exception as e:
+        print(f"[Warning] Failed to save progress: {e}")
+        # Try direct write as fallback
+        try:
+            with open(PROGRESS_FILE, 'w', encoding='utf-8') as f:
+                json.dump(progress_data, f, ensure_ascii=False, indent=2)
+        except Exception as e2:
+            print(f"[Error] Could not save progress: {e2}")
+            
+if __name__=='__main__':
+    main()

extract_glossary_from_txt.py

@@ -0,0 +1,59 @@
+# extract_glossary_from_txt.py
+import os
+import json
+from typing import List
+from txt_processor import TextFileProcessor
+from chapter_splitter import ChapterSplitter
+from bs4 import BeautifulSoup
+
+def extract_chapters_from_txt(txt_path: str) -> List[str]:
+    """Extract chapters from text file for glossary extraction"""
+    processor = TextFileProcessor(txt_path, os.path.dirname(txt_path))
+    chapters = processor.extract_chapters()
+    
+    # Initialize chapter splitter
+    model_name = os.getenv("MODEL", "gpt-3.5-turbo")
+    chapter_splitter = ChapterSplitter(model_name=model_name)
+    
+    # Get max tokens from environment
+    max_input_tokens_str = os.getenv("MAX_INPUT_TOKENS", "1000000").strip()
+    if not max_input_tokens_str or max_input_tokens_str == "":
+        # Token limit disabled - use a very large number
+        max_input_tokens = 10000000  # 10M tokens
+    else:
+        max_input_tokens = int(max_input_tokens_str)
+    
+    # Calculate available tokens (leaving room for system prompt and context)
+    system_prompt_size = 2000  # Estimate for glossary system prompt
+    context_size = 5000  # Estimate for context history
+    safety_margin = 1000
+    available_tokens = max_input_tokens - system_prompt_size - context_size - safety_margin
+    
+    text_chapters = []
+    
+    for idx, chapter in enumerate(chapters):
+        # Check if chapter needs splitting
+        chapter_tokens = chapter_splitter.count_tokens(chapter['body'])
+        
+        if chapter_tokens > available_tokens:
+            print(f"Chapter {idx+1} has {chapter_tokens} tokens, splitting into smaller chunks...")
+            
+            # Use ChapterSplitter to split the HTML content
+            chunks = chapter_splitter.split_chapter(chapter['body'], available_tokens)
+            
+            # Extract text from each chunk
+            for chunk_html, chunk_idx, total_chunks in chunks:
+                soup = BeautifulSoup(chunk_html, 'html.parser')
+                text = soup.get_text(strip=True)
+                if text:
+                    text_chapters.append(text)
+                    print(f"  Added chunk {chunk_idx}/{total_chunks} ({chapter_splitter.count_tokens(text)} tokens)")
+        else:
+            # Chapter is small enough, extract text as-is
+            soup = BeautifulSoup(chapter['body'], 'html.parser')
+            text = soup.get_text(strip=True)
+            if text:
+                text_chapters.append(text)
+    
+    print(f"Total text chunks for glossary extraction: {len(text_chapters)}")
+    return text_chapters

glossary_process_worker.py

@@ -0,0 +1,198 @@
+"""
+Process-safe glossary generation worker
+========================================
+This module provides a pickleable function for glossary generation
+that can be run in a separate process using ProcessPoolExecutor.
+"""
+
+import os
+import sys
+import json
+import time
+
+def generate_glossary_in_process(output_dir, chapters_data, instructions, env_vars, log_queue=None):
+    """
+    Generate glossary in a separate process to avoid GIL blocking.
+    
+    Args:
+        output_dir: Output directory path
+        chapters_data: Serialized chapters data
+        instructions: Glossary instructions
+        env_vars: Environment variables to set
+        log_queue: Queue to send logs back to main process
+    
+    Returns:
+        Dictionary with glossary results or error info
+    """
+    import io
+    import sys
+    from io import StringIO
+    
+    # Capture ALL output - both stdout and stderr
+    captured_logs = []
+    
+    class LogCapture:
+        def __init__(self, queue=None):
+            self.queue = queue
+            self.buffer = ""
+            
+        def write(self, text):
+            if text:
+                # Buffer text and send complete lines
+                self.buffer += text
+                while '\n' in self.buffer:
+                    line, self.buffer = self.buffer.split('\n', 1)
+                    if line:
+                        captured_logs.append(line)
+                        if self.queue:
+                            try:
+                                self.queue.put(line)
+                            except:
+                                pass
+        
+        def flush(self):
+            if self.buffer:
+                captured_logs.append(self.buffer)
+                if self.queue:
+                    try:
+                        self.queue.put(self.buffer)
+                    except:
+                        pass
+                self.buffer = ""
+    
+    try:
+        # Redirect BOTH stdout and stderr to capture ALL output
+        log_capture = LogCapture(log_queue)
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        sys.stdout = log_capture
+        sys.stderr = log_capture
+        
+        # Set environment variables from parent process
+        for key, value in env_vars.items():
+            os.environ[key] = str(value)
+        
+        # Import here to avoid circular imports
+        from TransateKRtoEN import GlossaryManager
+        
+        # Create glossary manager instance
+        glossary_manager = GlossaryManager()
+        
+        # Generate glossary
+        print(f"📑 Starting glossary generation in subprocess...")
+        result = glossary_manager.save_glossary(output_dir, chapters_data, instructions)
+        
+        print(f"📑 Glossary generation completed")
+        
+        # Flush any remaining output
+        log_capture.flush()
+        
+        # Restore stdout and stderr
+        sys.stdout = old_stdout
+        sys.stderr = old_stderr
+        
+        return {
+            'success': True,
+            'result': result,
+            'pid': os.getpid(),
+            'logs': captured_logs
+        }
+        
+    except Exception as e:
+        import traceback
+        
+        # Restore stdout and stderr if needed
+        if 'old_stdout' in locals():
+            sys.stdout = old_stdout
+        if 'old_stderr' in locals():
+            sys.stderr = old_stderr
+        
+        error_msg = f"Glossary generation error: {str(e)}"
+        captured_logs.append(f"📑 ❌ {error_msg}")
+        
+        return {
+            'success': False,
+            'error': error_msg,
+            'traceback': traceback.format_exc(),
+            'pid': os.getpid(),
+            'logs': captured_logs
+        }
+
+def generate_glossary_async(output_dir, chapters, instructions, extraction_workers=None):
+    """
+    Generate glossary asynchronously using ProcessPoolExecutor.
+    
+    This function completely bypasses the GIL by running in a separate process,
+    ensuring the GUI remains fully responsive.
+    """
+    import concurrent.futures
+    import multiprocessing
+    
+    # Ensure freeze support for Windows frozen executables
+    try:
+        multiprocessing.freeze_support()
+    except Exception:
+        pass
+    
+    # Determine worker count
+    if extraction_workers is None:
+        extraction_workers = int(os.getenv("EXTRACTION_WORKERS", "1"))
+    
+    if extraction_workers == 1:
+        # Auto-detect optimal workers
+        extraction_workers = min(multiprocessing.cpu_count() or 4, 4)
+        print(f"📑 Auto-detected {extraction_workers} CPU cores for glossary generation")
+    
+    # Collect relevant environment variables
+    env_vars = {}
+    important_vars = [
+        'EXTRACTION_WORKERS', 'GLOSSARY_MIN_FREQUENCY', 'GLOSSARY_MAX_NAMES',
+        'GLOSSARY_MAX_TITLES', 'GLOSSARY_BATCH_SIZE', 'GLOSSARY_STRIP_HONORIFICS',
+        'GLOSSARY_FUZZY_THRESHOLD', 'GLOSSARY_MAX_TEXT_SIZE', 'AUTO_GLOSSARY_PROMPT',
+        'GLOSSARY_USE_SMART_FILTER', 'GLOSSARY_USE_LEGACY_CSV', 'GLOSSARY_PARALLEL_ENABLED',
+        'GLOSSARY_FILTER_MODE', 'GLOSSARY_SKIP_FREQUENCY_CHECK', 'GLOSSARY_SKIP_ALL_VALIDATION',
+        'MODEL', 'API_KEY', 'OPENAI_API_KEY', 'GEMINI_API_KEY', 'MAX_OUTPUT_TOKENS',
+        'GLOSSARY_TEMPERATURE', 'MANUAL_GLOSSARY', 'ENABLE_AUTO_GLOSSARY'
+    ]
+    
+    for var in important_vars:
+        if var in os.environ:
+            env_vars[var] = os.environ[var]
+    
+    # Use ProcessPoolExecutor for true parallelism
+    with concurrent.futures.ProcessPoolExecutor(max_workers=1) as executor:
+        # Submit the task
+        future = executor.submit(
+            generate_glossary_in_process,
+            output_dir,
+            chapters,
+            instructions,
+            env_vars
+        )
+        
+        # Return the future for the caller to monitor
+        return future
+
+def check_glossary_completion(future, timeout=0.01):
+    """
+    Check if glossary generation is complete without blocking.
+    
+    Args:
+        future: Future object from generate_glossary_async
+        timeout: Timeout in seconds for checking
+    
+    Returns:
+        Tuple of (is_done, result_or_none)
+    """
+    try:
+        if future.done():
+            result = future.result(timeout=timeout)
+            return True, result
+        else:
+            # Not done yet
+            return False, None
+    except concurrent.futures.TimeoutError:
+        return False, None
+    except Exception as e:
+        # Error occurred
+        return True, {'success': False, 'error': str(e)}

history_manager.py

@@ -0,0 +1,136 @@
+import json
+import os
+import time
+import tempfile
+import shutil
+from threading import Lock
+from contextlib import contextmanager
+
+class HistoryManager:
+    """Thread-safe history management with file locking"""
+    
+    def __init__(self, payloads_dir):
+        self.payloads_dir = payloads_dir
+        self.hist_path = os.path.join(payloads_dir, "translation_history.json")
+        self.lock = Lock()
+        self._file_locks = {}
+    
+    @contextmanager
+    def _file_lock(self, filepath):
+        """Simple file locking mechanism"""
+        lock_file = filepath + '.lock'
+        acquired = False
+        try:
+            # Try to acquire lock with timeout
+            start_time = time.time()
+            while time.time() - start_time < 30:  # 30 second timeout
+                try:
+                    # Create lock file atomically
+                    fd = os.open(lock_file, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+                    os.close(fd)
+                    acquired = True
+                    break
+                except FileExistsError:
+                    time.sleep(0.1)
+            
+            if not acquired:
+                raise TimeoutError(f"Could not acquire lock for {filepath}")
+                
+            yield
+            
+        finally:
+            if acquired and os.path.exists(lock_file):
+                try:
+                    os.remove(lock_file)
+                except:
+                    pass
+    
+    def load_history(self):
+        """Load history with retry logic and file locking"""
+        with self.lock:
+            for attempt in range(3):
+                try:
+                    with self._file_lock(self.hist_path):
+                        if os.path.exists(self.hist_path):
+                            with open(self.hist_path, "r", encoding="utf-8") as f:
+                                return json.load(f)
+                        return []
+                except (json.JSONDecodeError, IOError) as e:
+                    print(f"[WARNING] Failed to load history (attempt {attempt + 1}): {e}")
+                    if attempt < 2:
+                        time.sleep(0.5)
+                    else:
+                        # Return empty history if all attempts fail
+                        return []
+        return []
+    
+    def save_history(self, history):
+        """Save history atomically with file locking"""
+        with self.lock:
+            with self._file_lock(self.hist_path):
+                # Write to temporary file first
+                temp_fd, temp_path = tempfile.mkstemp(dir=self.payloads_dir, text=True)
+                try:
+                    with os.fdopen(temp_fd, 'w', encoding='utf-8') as f:
+                        json.dump(history, f, ensure_ascii=False, indent=2)
+                    
+                    # Atomically replace the old file
+                    shutil.move(temp_path, self.hist_path)
+                    
+                except Exception as e:
+                    # Clean up temp file on error
+                    if os.path.exists(temp_path):
+                        os.remove(temp_path)
+                    raise e
+    
+    def append_to_history(self, user_content, assistant_content, hist_limit, reset_on_limit=True, rolling_window=False):
+        """
+        Append to history with automatic reset or rolling window when limit is reached
+        
+        Args:
+            user_content: User message content
+            assistant_content: Assistant message content
+            hist_limit: Maximum number of exchanges to keep (0 = no history)
+            reset_on_limit: Whether to reset when limit is reached (old behavior)
+            rolling_window: Whether to use rolling window mode (new behavior)
+        """
+        # CRITICAL FIX: If hist_limit is 0 or negative, don't maintain any history
+        if hist_limit <= 0:
+            # Don't load, save, or maintain any history when contextual is disabled
+            return []
+        
+        history = self.load_history()
+        
+        # Count current exchanges (each exchange = 2 messages: user + assistant)
+        current_exchanges = len(history) // 2
+        
+        # Handle limit reached
+        if current_exchanges >= hist_limit:
+            if rolling_window:
+                # Rolling window mode: keep only the most recent (limit-1) exchanges
+                # We keep limit-1 to make room for the new exchange
+                messages_to_keep = (hist_limit - 1) * 2
+                if messages_to_keep > 0:
+                    history = history[-messages_to_keep:]
+                    print(f"🔄 Rolling history window: keeping last {hist_limit-1} exchanges")
+                else:
+                    history = []
+            elif reset_on_limit:
+                # Old behavior: complete reset
+                history = []
+                print(f"🔄 Reset history after reaching limit of {hist_limit} exchanges")
+        
+        # Append new entries
+        history.append({"role": "user", "content": user_content})
+        history.append({"role": "assistant", "content": assistant_content})
+        
+        self.save_history(history)
+        return history
+
+    def will_reset_on_next_append(self, hist_limit, rolling_window=False):
+        """Check if the next append will trigger a reset or rolling window"""
+        if hist_limit <= 0:
+            return False
+        history = self.load_history()
+        current_exchanges = len(history) // 2
+        return current_exchanges >= hist_limit

individual_endpoint_dialog.py

@@ -0,0 +1,229 @@
+# individual_endpoint_dialog.py
+"""
+Individual Endpoint Configuration Dialog for Glossarion
+- Uses the application's WindowManager for consistent UI
+- Allows enabling/disabling per-key custom endpoint (e.g., Azure, Ollama/local OpenAI-compatible)
+- Persists changes to the in-memory key object and refreshes the parent list
+"""
+import tkinter as tk
+from tkinter import ttk, messagebox
+import ttkbootstrap as tb
+from typing import Callable
+
+try:
+    # For type hints only; not required at runtime
+    from multi_api_key_manager import APIKeyEntry  # noqa: F401
+except Exception:
+    pass
+
+
+class IndividualEndpointDialog:
+    def __init__(self, parent, translator_gui, key, refresh_callback: Callable[[], None], status_callback: Callable[[str], None]):
+        self.parent = parent
+        self.translator_gui = translator_gui
+        self.key = key
+        self.refresh_callback = refresh_callback
+        self.status_callback = status_callback
+        self.dialog = None
+        self.canvas = None
+
+        self._build()
+
+    def _build(self):
+        title = f"Configure Individual Endpoint — {getattr(self.key, 'model', '')}"
+
+        if hasattr(self.translator_gui, 'wm'):
+            # Use WindowManager scrollable dialog for consistency
+            self.dialog, scrollable_frame, self.canvas = self.translator_gui.wm.setup_scrollable(
+                self.parent,
+                title,
+                width=700,
+                height=420,
+                max_width_ratio=0.85,
+                max_height_ratio=0.45
+            )
+        else:
+            self.dialog = tk.Toplevel(self.parent)
+            self.dialog.title(title)
+            self.dialog.geometry("700x420")
+            scrollable_frame = self.dialog
+
+        main = tk.Frame(scrollable_frame, padx=20, pady=16)
+        main.pack(fill=tk.BOTH, expand=True)
+
+        # Header
+        header = tk.Frame(main)
+        header.pack(fill=tk.X, pady=(0, 10))
+        tk.Label(header, text="Per-Key Custom Endpoint", font=("TkDefaultFont", 14, "bold")).pack(side=tk.LEFT)
+
+        # Enable toggle
+        self.enable_var = tk.BooleanVar(value=bool(getattr(self.key, 'use_individual_endpoint', False)))
+        tb.Checkbutton(header, text="Enable", variable=self.enable_var, bootstyle="round-toggle",
+                       command=self._toggle_fields).pack(side=tk.RIGHT)
+
+        # Description
+        desc = (
+            "Use a custom endpoint for this API key only. Works with OpenAI-compatible servers\n"
+            "like Azure OpenAI or local providers (e.g., Ollama at http://localhost:11434/v1)."
+        )
+        tk.Label(main, text=desc, fg='gray', justify=tk.LEFT).pack(anchor=tk.W)
+
+        # Form
+        form = tk.LabelFrame(main, text="Endpoint Settings", padx=14, pady=12)
+        form.pack(fill=tk.BOTH, expand=False, pady=(10, 0))
+
+        # Endpoint URL
+        tk.Label(form, text="Endpoint Base URL:").grid(row=0, column=0, sticky=tk.W, padx=(0, 10), pady=6)
+        self.endpoint_var = tk.StringVar(value=getattr(self.key, 'azure_endpoint', '') or '')
+        self.endpoint_entry = tb.Entry(form, textvariable=self.endpoint_var)
+        self.endpoint_entry.grid(row=0, column=1, sticky=tk.EW, pady=6)
+
+        # Azure API version (optional; required if using Azure)
+        tk.Label(form, text="Azure API Version:").grid(row=1, column=0, sticky=tk.W, padx=(0, 10), pady=6)
+        self.api_version_var = tk.StringVar(value=getattr(self.key, 'azure_api_version', '2025-01-01-preview') or '2025-01-01-preview')
+        self.api_version_combo = ttk.Combobox(
+            form,
+            textvariable=self.api_version_var,
+            values=[
+                '2025-01-01-preview',
+                '2024-12-01-preview',
+                '2024-10-01-preview',
+                '2024-08-01-preview',
+                '2024-06-01',
+                '2024-02-01',
+                '2023-12-01-preview'
+            ],
+            width=24,
+            state='readonly'
+        )
+        self.api_version_combo.grid(row=1, column=1, sticky=tk.W, pady=6)
+
+        # Helper text
+        hint = (
+            "Hints:\n"
+            "- Ollama: http://localhost:11434/v1\n"
+            "- Azure OpenAI: https://<resource>.openai.azure.com/ (version required)\n"
+            "- Other OpenAI-compatible: Provide the base URL ending with /v1 if applicable"
+        )
+        tk.Label(form, text=hint, fg='gray', justify=tk.LEFT, font=('TkDefaultFont', 9)).grid(
+            row=2, column=0, columnspan=2, sticky=tk.W, pady=(4, 0)
+        )
+
+        # Grid weights
+        form.columnconfigure(1, weight=1)
+
+        # Buttons
+        btns = tk.Frame(main)
+        btns.pack(fill=tk.X, pady=(14, 0))
+
+        tb.Button(btns, text="Save", bootstyle="success", command=self._on_save).pack(side=tk.RIGHT)
+        tb.Button(btns, text="Cancel", bootstyle="secondary", command=self._on_close).pack(side=tk.RIGHT, padx=(0, 8))
+        tb.Button(btns, text="Disable", bootstyle="danger-outline", command=self._on_disable).pack(side=tk.LEFT)
+
+        # Initial toggle state
+        self._toggle_fields()
+
+        # Window close protocol
+        self.dialog.protocol("WM_DELETE_WINDOW", self._on_close)
+
+        # Auto-size with WM if available
+        if hasattr(self.translator_gui, 'wm') and self.canvas is not None:
+            self.translator_gui.wm.auto_resize_dialog(self.dialog, self.canvas, max_width_ratio=0.9, max_height_ratio=0.45)
+
+    def _toggle_fields(self):
+        enabled = self.enable_var.get()
+        state = tk.NORMAL if enabled else tk.DISABLED
+        self.endpoint_entry.config(state=state)
+        # API version is only relevant for Azure but we leave it enabled while toggle is on
+        self.api_version_combo.config(state='readonly' if enabled else 'disabled')
+
+    def _is_azure_endpoint(self, url: str) -> bool:
+        if not url:
+            return False
+        url_l = url.lower()
+        return (".openai.azure.com" in url_l) or ("azure.com/openai" in url_l) or ("/openai/deployments/" in url_l)
+
+    def _validate(self) -> bool:
+        if not self.enable_var.get():
+            return True
+        url = (self.endpoint_var.get() or '').strip()
+        if not url:
+            messagebox.showerror("Validation Error", "Endpoint Base URL is required when Enable is ON.")
+            return False
+        if not (url.startswith("http://") or url.startswith("https://")):
+            messagebox.showerror("Validation Error", "Endpoint URL must start with http:// or https://")
+            return False
+        if self._is_azure_endpoint(url):
+            ver = (self.api_version_var.get() or '').strip()
+            if not ver:
+                messagebox.showerror("Validation Error", "Azure API Version is required for Azure endpoints.")
+                return False
+        return True
+
+    def _persist_to_config_if_possible(self):
+        """Best-effort persistence: update translator_gui.config['multi_api_keys'] for this key entry.
+        We match by api_key and model to find the entry. If not found, skip silently.
+        """
+        try:
+            cfg = getattr(self.translator_gui, 'config', None)
+            if not isinstance(cfg, dict):
+                return
+            key_list = cfg.get('multi_api_keys', [])
+            # Find by api_key AND model (best-effort)
+            api_key = getattr(self.key, 'api_key', None)
+            model = getattr(self.key, 'model', None)
+            for entry in key_list:
+                if entry.get('api_key') == api_key and entry.get('model') == model:
+                    entry['use_individual_endpoint'] = bool(getattr(self.key, 'use_individual_endpoint', False))
+                    entry['azure_endpoint'] = getattr(self.key, 'azure_endpoint', None)
+                    entry['azure_api_version'] = getattr(self.key, 'azure_api_version', None)
+                    break
+            # Save without message
+            if hasattr(self.translator_gui, 'save_config'):
+                self.translator_gui.save_config(show_message=False)
+        except Exception:
+            # Non-fatal
+            pass
+
+    def _on_save(self):
+        if not self._validate():
+            return
+        enabled = self.enable_var.get()
+        url = (self.endpoint_var.get() or '').strip()
+        ver = (self.api_version_var.get() or '').strip()
+
+        # Apply to key object
+        self.key.use_individual_endpoint = enabled
+        self.key.azure_endpoint = url if enabled else None
+        # Keep API version even if disabled, but it's only used when enabled
+        self.key.azure_api_version = ver or getattr(self.key, 'azure_api_version', '2025-01-01-preview')
+
+        # Notify parent UI
+        if callable(self.refresh_callback):
+            try:
+                self.refresh_callback()
+            except Exception:
+                pass
+        if callable(self.status_callback):
+            try:
+                if enabled and url:
+                    self.status_callback(f"Individual endpoint set: {url}")
+                else:
+                    self.status_callback("Individual endpoint disabled")
+            except Exception:
+                pass
+
+        # Best-effort persistence to config
+        self._persist_to_config_if_possible()
+
+        self.dialog.destroy()
+
+    def _on_disable(self):
+        # Disable quickly
+        self.enable_var.set(False)
+        self._toggle_fields()
+        # Apply immediately and close
+        self._on_save()
+
+    def _on_close(self):
+        self.dialog.destroy()

launch_Glossarion.bat

@@ -0,0 +1,11 @@
+@echo off
+REM ensure we’re in the script’s folder:
+cd /d "%~dp0"
+
+REM call the real python
+python translator_gui.py
+
+REM or, alternatively:
+REM py -3 translator_gui.py
+
+pause

launch_Glossarion.vbs

@@ -0,0 +1,3 @@
+Set WshShell = CreateObject("WScript.Shell")
+WshShell.Run "pythonw.exe translator_gui.py", 0
+Set WshShell = Nothing

launch_web.bat

@@ -0,0 +1,37 @@
+@echo off
+title Glossarion Web Interface
+echo.
+echo ========================================
+echo    Glossarion Web Interface Launcher
+echo ========================================
+echo.
+
+REM Change to the script directory
+cd /d "%~dp0"
+
+REM Check if Python is available
+python --version >nul 2>&1
+if errorlevel 1 (
+    echo ERROR: Python is not installed or not in PATH
+    echo Please install Python 3.8 or higher
+    pause
+    exit /b 1
+)
+
+echo Starting Glossarion Web Interface...
+echo.
+echo The browser will open automatically once the server is ready.
+echo Press Ctrl+C in the console to stop the server when done.
+echo.
+
+REM Start PowerShell script in background to wait for server and open browser
+start "" /B powershell -ExecutionPolicy Bypass -File "%~dp0wait_and_open.ps1" -url "http://127.0.0.1:7860"
+
+REM Start the web interface
+python glossarion_web.py
+
+echo.
+echo ========================================
+echo Server stopped. You can close this window.
+echo ========================================
+pause

launch_web_advanced.bat

@@ -0,0 +1,107 @@
+@echo off
+title Glossarion Web Interface - Advanced Launcher
+color 0A
+echo.
+echo ========================================
+echo   Glossarion Web Interface
+echo   Advanced Launcher
+echo ========================================
+echo.
+
+REM Change to the script directory
+cd /d "%~dp0"
+
+REM Check if Python is available
+python --version >nul 2>&1
+if errorlevel 1 (
+    color 0C
+    echo ERROR: Python is not installed or not in PATH
+    echo Please install Python 3.8 or higher
+    pause
+    exit /b 1
+)
+
+echo Select launch mode:
+echo.
+echo [1] Local Only (http://127.0.0.1:7860)
+echo [2] Network Accessible (http://0.0.0.0:7860)
+echo [3] Public Share Link (uses Gradio sharing)
+echo [4] Custom Port (specify your own)
+echo [5] Exit
+echo.
+set /p choice="Enter choice (1-5): "
+
+if "%choice%"=="1" (
+    set SERVER_NAME=127.0.0.1
+    set SERVER_PORT=7860
+    set SHARE=False
+    goto :launch
+)
+
+if "%choice%"=="2" (
+    set SERVER_NAME=0.0.0.0
+    set SERVER_PORT=7860
+    set SHARE=False
+    echo.
+    echo WARNING: This will make the server accessible to other devices on your network.
+    echo.
+    goto :launch
+)
+
+if "%choice%"=="3" (
+    set SERVER_NAME=0.0.0.0
+    set SERVER_PORT=7860
+    set SHARE=True
+    echo.
+    echo NOTE: This will create a public link that expires in 72 hours.
+    echo.
+    goto :launch
+)
+
+if "%choice%"=="4" (
+    set /p SERVER_PORT="Enter port number (default 7860): "
+    if "%SERVER_PORT%"=="" set SERVER_PORT=7860
+    set SERVER_NAME=127.0.0.1
+    set SHARE=False
+    goto :launch
+)
+
+if "%choice%"=="5" (
+    exit /b 0
+)
+
+echo Invalid choice. Exiting.
+pause
+exit /b 1
+
+:launch
+echo.
+echo ========================================
+echo Starting Glossarion Web Interface...
+echo ========================================
+echo.
+echo Configuration:
+echo - Host: %SERVER_NAME%
+echo - Port: %SERVER_PORT%
+echo - Public Share: %SHARE%
+echo.
+echo The browser will open automatically once the server is ready.
+echo Press Ctrl+C in the console to stop the server when done.
+echo.
+
+REM Set environment variables for Python script to use
+set GRADIO_SERVER_NAME=%SERVER_NAME%
+set GRADIO_SERVER_PORT=%SERVER_PORT%
+set GRADIO_SHARE=%SHARE%
+
+REM Start PowerShell script in background to wait for server and open browser
+start "" /B powershell -ExecutionPolicy Bypass -File "%~dp0wait_and_open.ps1" -url "http://127.0.0.1:%SERVER_PORT%"
+
+REM Start the web interface
+python glossarion_web.py
+
+echo.
+echo ========================================
+echo Server stopped. You can close this window.
+echo ========================================
+pause

memory_usage_reporter.py

@@ -0,0 +1,225 @@
+# memory_usage_reporter.py
+"""
+Background memory usage reporter.
+- Logs process RSS, VMS, peak (if available), GC counts, and optional tracemalloc stats
+- Writes to logs/memory.log and also propagates to root logger (run.log) via a child logger
+- Designed to be lightweight and safe in GUI apps
+"""
+import os
+import sys
+import time
+import threading
+import logging
+import gc
+from logging.handlers import RotatingFileHandler
+
+try:
+    import psutil
+except Exception:
+    psutil = None
+
+# Global singletons
+_GLOBAL_THREAD = None
+_GLOBAL_STOP = threading.Event()
+
+
+def _ensure_logs_dir() -> str:
+    # Prefer explicit override from main app
+    try:
+        env_dir = os.environ.get("GLOSSARION_LOG_DIR")
+        if env_dir:
+            dir_path = os.path.expanduser(env_dir)
+            os.makedirs(dir_path, exist_ok=True)
+            return dir_path
+    except Exception:
+        pass
+
+    def _can_write(p: str) -> bool:
+        try:
+            os.makedirs(p, exist_ok=True)
+            test_file = os.path.join(p, ".write_test")
+            with open(test_file, "w", encoding="utf-8") as f:
+                f.write("ok")
+            os.remove(test_file)
+            return True
+        except Exception:
+            return False
+
+    # Frozen exe: try next to the executable first
+    try:
+        if getattr(sys, 'frozen', False) and hasattr(sys, 'executable'):
+            exe_dir = os.path.dirname(sys.executable)
+            candidate = os.path.join(exe_dir, "logs")
+            if _can_write(candidate):
+                return candidate
+    except Exception:
+        pass
+
+    # User-local app data (persistent and writable)
+    try:
+        base = os.environ.get('LOCALAPPDATA') or os.environ.get('APPDATA') or os.path.expanduser('~')
+        candidate = os.path.join(base, 'Glossarion', 'logs')
+        if _can_write(candidate):
+            return candidate
+    except Exception:
+        pass
+
+    # Development fallback: next to this file
+    try:
+        base_dir = os.path.abspath(os.path.dirname(__file__))
+        candidate = os.path.join(base_dir, "logs")
+        if _can_write(candidate):
+            return candidate
+    except Exception:
+        pass
+
+    # Final fallback: CWD
+    fallback = os.path.join(os.getcwd(), "logs")
+    os.makedirs(fallback, exist_ok=True)
+    return fallback
+
+
+def _make_logger() -> logging.Logger:
+    logger = logging.getLogger("memory")
+    logger.setLevel(logging.INFO)
+
+    # Avoid duplicate handlers if called more than once
+    if not any(isinstance(h, RotatingFileHandler) for h in logger.handlers):
+        logs_dir = _ensure_logs_dir()
+        file_path = os.path.join(logs_dir, "memory.log")
+        fh = RotatingFileHandler(file_path, maxBytes=2 * 1024 * 1024, backupCount=3, encoding="utf-8")
+        fmt = logging.Formatter(
+            fmt="%(asctime)s %(levelname)s [%(process)d:%(threadName)s] %(name)s: %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+        fh.setFormatter(fmt)
+        logger.addHandler(fh)
+
+    # Do NOT propagate to root; keep memory logs out of console and only in memory.log
+    logger.propagate = False
+    return logger
+
+
+def _get_process() -> "psutil.Process | None":
+    if psutil is None:
+        return None
+    try:
+        return psutil.Process()
+    except Exception:
+        return None
+
+
+def _format_bytes(num: int) -> str:
+    try:
+        for unit in ["B", "KB", "MB", "GB", "TB"]:
+            if num < 1024.0:
+                return f"{num:,.1f}{unit}"
+            num /= 1024.0
+        return f"{num:,.1f}PB"
+    except Exception:
+        return str(num)
+
+
+def _collect_stats(proc) -> dict:
+    stats = {}
+    try:
+        if proc is not None:
+            mi = proc.memory_info()
+            stats["rss"] = mi.rss
+            stats["vms"] = getattr(mi, "vms", 0)
+            # Peak RSS on Windows via psutil.Process.memory_info() may expose peak_wset in private API; skip for portability
+        else:
+            stats["rss"] = 0
+            stats["vms"] = 0
+    except Exception:
+        stats["rss"] = stats.get("rss", 0)
+        stats["vms"] = stats.get("vms", 0)
+
+    # GC stats
+    try:
+        counts = gc.get_count()
+        stats["gc"] = counts
+    except Exception:
+        stats["gc"] = (0, 0, 0)
+
+    return stats
+
+
+def _worker(interval_sec: float, include_tracemalloc: bool):
+    log = _make_logger()
+    proc = _get_process()
+
+    # Optional tracemalloc
+    if include_tracemalloc:
+        try:
+            import tracemalloc
+            if not tracemalloc.is_tracing():
+                tracemalloc.start()
+            tm_enabled = True
+        except Exception:
+            tm_enabled = False
+    else:
+        tm_enabled = False
+
+    while not _GLOBAL_STOP.is_set():
+        try:
+            st = _collect_stats(proc)
+            rss = st.get("rss", 0)
+            vms = st.get("vms", 0)
+            gc0, gc1, gc2 = st.get("gc", (0, 0, 0))
+
+            msg = (
+                f"RSS={_format_bytes(rss)} VMS={_format_bytes(vms)} "
+                f"GC={gc0}/{gc1}/{gc2}"
+            )
+
+            if tm_enabled:
+                try:
+                    import tracemalloc
+                    cur, peak = tracemalloc.get_traced_memory()
+                    msg += f" TM_CUR={_format_bytes(cur)} TM_PEAK={_format_bytes(peak)}"
+                except Exception:
+                    pass
+
+            log.info(msg)
+        except Exception as e:
+            try:
+                log.warning("memory reporter error: %s", e)
+            except Exception:
+                pass
+        finally:
+            # Sleep in small chunks to react faster to stop
+            for _ in range(int(max(1, interval_sec * 10))):
+                if _GLOBAL_STOP.is_set():
+                    break
+                time.sleep(0.1)
+
+
+def start_global_memory_logger(interval_sec: float = 3.0, include_tracemalloc: bool = False) -> None:
+    """Start the background memory logger once per process.
+
+    interval_sec: how often to log
+    include_tracemalloc: if True, also log tracemalloc current/peak
+    """
+    global _GLOBAL_THREAD
+    if _GLOBAL_THREAD and _GLOBAL_THREAD.is_alive():
+        return
+
+    _GLOBAL_STOP.clear()
+    t = threading.Thread(target=_worker, args=(interval_sec, include_tracemalloc), name="mem-logger", daemon=True)
+    _GLOBAL_THREAD = t
+    try:
+        t.start()
+    except Exception:
+        # Do not raise to avoid breaking GUI startup
+        pass
+
+
+def stop_global_memory_logger() -> None:
+    try:
+        _GLOBAL_STOP.set()
+        if _GLOBAL_THREAD and _GLOBAL_THREAD.is_alive():
+            # Give it a moment to exit
+            _GLOBAL_THREAD.join(timeout=2.0)
+    except Exception:
+        pass

model_options.py

@@ -0,0 +1,128 @@
+# model_options.py
+"""
+Centralized model catalog for Glossarion UIs.
+Returned list should mirror the main GUI model dropdown.
+"""
+from typing import List
+
+def get_model_options() -> List[str]:
+    return [
+    
+        # OpenAI Models
+        "gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-4.1-nano", "gpt-4.1-mini", "gpt-4.1",
+        "gpt-3.5-turbo", "gpt-3.5-turbo-16k", "gpt-4", "gpt-4-32k",
+        "gpt-5-mini","gpt-5","gpt-5-nano",
+        "o1-preview", "o1-mini", "o3", "o4-mini",
+        
+        # Google Gemini Models
+        "gemini-2.0-flash","gemini-2.0-flash-lite",
+        "gemini-2.5-flash","gemini-2.5-flash-lite", "gemini-2.5-pro", "gemini-pro", "gemini-pro-vision",
+        
+        # Anthropic Claude Models
+        "claude-opus-4-20250514", "claude-sonnet-4-20250514",
+        "claude-3-5-sonnet-20241022", "claude-3-7-sonnet-20250219",
+        "claude-3-opus-20240229", "claude-3-sonnet-20240229", "claude-3-haiku-20240307",
+        "claude-2.1", "claude-2", "claude-instant-1.2",
+        
+        # Grok Models
+        "grok-grok-4-0709", "grok-3", "grok-3-mini",
+        
+        # Vertex AI Model Garden - Claude models (confirmed)
+        "claude-4-opus@20250514",
+        "claude-4-sonnet@20250514",
+        "claude-opus-4@20250514",
+        "claude-sonnet-4@20250514",
+        "claude-3-7-sonnet@20250219",
+        "claude-3-5-sonnet@20240620",
+        "claude-3-5-sonnet-v2@20241022",
+        "claude-3-opus@20240229",
+        "claude-3-sonnet@20240229",
+        "claude-3-haiku@20240307",
+
+        
+        # Alternative format with vertex_ai prefix
+        "vertex/claude-3-7-sonnet@20250219",
+        "vertex/claude-3-5-sonnet@20240620",
+        "vertex/claude-3-opus@20240229",
+        "vertex/claude-4-opus@20250514",
+        "vertex/claude-4-sonnet@20250514",
+        "vertex/gemini-1.5-pro",
+        "vertex/gemini-1.5-flash",
+        "vertex/gemini-2.0-flash",
+        "vertex/gemini-2.5-pro",
+        "vertex/gemini-2.5-flash",
+        "vertex/gemini-2.5-flash-lite",
+
+        # Chute AI
+        "chutes/openai/gpt-oss-120b",
+        "chutes/deepseek-ai/DeepSeek-V3.1",
+        
+        # DeepSeek Models
+        "deepseek-chat", "deepseek-coder", "deepseek-coder-33b-instruct",
+        
+        # Mistral Models
+        "mistral-large", "mistral-medium", "mistral-small", "mistral-tiny",
+        "mixtral-8x7b-instruct", "mixtral-8x22b", "codestral-latest",
+        
+        # Meta Llama Models (via Together/other providers)
+        "llama-2-7b-chat", "llama-2-13b-chat", "llama-2-70b-chat",
+        "llama-3-8b-instruct", "llama-3-70b-instruct", "codellama-34b-instruct",
+        
+        # Yi Models
+        "yi-34b-chat", "yi-34b-chat-200k", "yi-6b-chat",
+        
+        # Qwen Models
+        "qwen-72b-chat", "qwen-14b-chat", "qwen-7b-chat", "qwen-plus", "qwen-turbo",
+        
+        # Cohere Models
+        "command", "command-light", "command-nightly", "command-r", "command-r-plus",
+        
+        # AI21 Models
+        "j2-ultra", "j2-mid", "j2-light", "jamba-instruct",
+        
+        # Perplexity Models
+        "perplexity-70b-online", "perplexity-7b-online", "pplx-70b-online", "pplx-7b-online",
+        
+        # Groq Models (usually with suffix)
+        "llama-3-70b-groq", "llama-3-8b-groq", "mixtral-8x7b-groq",
+        
+        # Chinese Models
+        "glm-4", "glm-3-turbo", "chatglm-6b", "chatglm2-6b", "chatglm3-6b",
+        "baichuan-13b-chat", "baichuan2-13b-chat",
+        "moonshot-v1-8k", "moonshot-v1-32k", "moonshot-v1-128k",
+        
+        # Other Models
+        "falcon-40b-instruct", "falcon-7b-instruct",
+        "phi-2", "phi-3-mini", "phi-3-small", "phi-3-medium",
+        "orca-2-13b", "orca-2-7b",
+        "vicuna-13b", "vicuna-7b",
+        "alpaca-7b",
+        "wizardlm-70b", "wizardlm-13b",
+        "openchat-3.5",
+        
+        # For POE, prefix with 'poe/'
+        "poe/gpt-4", "poe/gpt-4o", "poe/gpt-4.5", "poe/gpt-4.1",
+        "poe/claude-3-opus", "poe/claude-4-opus", "poe/claude-3-sonnet", "poe/claude-4-sonnet",
+        "poe/claude", "poe/Assistant",
+        "poe/gemini-2.5-flash", "poe/gemini-2.5-pro",
+        
+        # For OR, prevfix with 'or/'
+        "or/google/gemini-2.5-pro",
+        "or/google/gemini-2.5-flash",
+        "or/google/gemini-2.5-flash-lite",
+        "or/openai/gpt-5",
+        "or/openai/gpt-5-mini",
+        "or/openai/gpt-5-nano",
+        "or/openai/chatgpt-4o-latest",   
+        "or/deepseek/deepseek-r1-0528:free", 
+        "or/google/gemma-3-27b-it:free",
+        
+        # For ElectronHub, prefix with 'eh/'
+        "eh/gpt-4", "eh/gpt-3.5-turbo", "eh/claude-3-opus", "eh/claude-3-sonnet",
+        "eh/llama-2-70b-chat", "eh/yi-34b-chat-200k", "eh/mistral-large",
+        "eh/gemini-pro", "eh/deepseek-coder-33b",
+        
+        # Last Resort
+        "deepl",  # Will use DeepL API
+        "google-translate",  # Will use Google Cloud Translate
+    ]

ocr_manager.py

@@ -0,0 +1,1879 @@
+# ocr_manager.py
+"""
+OCR Manager for handling multiple OCR providers
+Handles installation, model downloading, and OCR processing
+Updated with HuggingFace donut model and proper bubble detection integration
+"""
+import os
+import sys
+import cv2
+import json
+import subprocess
+import threading
+import traceback
+from typing import List, Dict, Optional, Tuple, Any
+import numpy as np
+from dataclasses import dataclass
+from PIL import Image
+import logging
+import time
+import random
+import base64
+import io
+import requests
+
+try:
+    import gptqmodel
+    HAS_GPTQ = True
+except ImportError:
+    try:
+        import auto_gptq
+        HAS_GPTQ = True
+    except ImportError:
+        HAS_GPTQ = False
+
+try:
+    import optimum
+    HAS_OPTIMUM = True
+except ImportError:
+    HAS_OPTIMUM = False
+
+try:
+    import accelerate
+    HAS_ACCELERATE = True
+except ImportError:
+    HAS_ACCELERATE = False
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class OCRResult:
+    """Unified OCR result format with built-in sanitization to prevent data corruption."""
+    text: str
+    bbox: Tuple[int, int, int, int]  # x, y, w, h
+    confidence: float
+    vertices: Optional[List[Tuple[int, int]]] = None
+
+    def __post_init__(self):
+        """
+        This special method is called automatically after the object is created.
+        It acts as a final safeguard to ensure the 'text' attribute is ALWAYS a clean string.
+        """
+        # --- THIS IS THE DEFINITIVE FIX ---
+        # If the text we received is a tuple, we extract the first element.
+        # This makes it impossible for a tuple to exist in a finished object.
+        if isinstance(self.text, tuple):
+            # Log that we are fixing a critical data error.
+            print(f"CRITICAL WARNING: Corrupted tuple detected in OCRResult. Sanitizing '{self.text}' to '{self.text[0]}'.")
+            self.text = self.text[0]
+        
+        # Ensure the final result is always a stripped string.
+        self.text = str(self.text).strip()
+    
+class OCRProvider:
+    """Base class for OCR providers"""
+    
+    def __init__(self, log_callback=None):
+        self.log_callback = log_callback
+        self.is_installed = False
+        self.is_loaded = False
+        self.model = None
+        self.stop_flag = None
+        self._stopped = False
+        
+    def _log(self, message: str, level: str = "info"):
+        """Log message with stop suppression"""
+        # Suppress logs when stopped (allow only essential stop confirmation messages)
+        if self._check_stop():
+            essential_stop_keywords = [
+                "⏹️ Translation stopped by user",
+                "⏹️ OCR processing stopped",
+                "cleanup", "🧹"
+            ]
+            if not any(keyword in message for keyword in essential_stop_keywords):
+                return
+        
+        if self.log_callback:
+            self.log_callback(message, level)
+        else:
+            print(f"[{level.upper()}] {message}")
+    
+    def set_stop_flag(self, stop_flag):
+        """Set the stop flag for checking interruptions"""
+        self.stop_flag = stop_flag
+        self._stopped = False
+    
+    def _check_stop(self) -> bool:
+        """Check if stop has been requested"""
+        if self._stopped:
+            return True
+        if self.stop_flag and self.stop_flag.is_set():
+            self._stopped = True
+            return True
+        # Check global manga translator cancellation
+        try:
+            from manga_translator import MangaTranslator
+            if MangaTranslator.is_globally_cancelled():
+                self._stopped = True
+                return True
+        except Exception:
+            pass
+        return False
+    
+    def reset_stop_flags(self):
+        """Reset stop flags when starting new processing"""
+        self._stopped = False
+    
+    def check_installation(self) -> bool:
+        """Check if provider is installed"""
+        raise NotImplementedError
+    
+    def install(self, progress_callback=None) -> bool:
+        """Install the provider"""
+        raise NotImplementedError
+    
+    def load_model(self, **kwargs) -> bool:
+        """Load the OCR model"""
+        raise NotImplementedError
+    
+    def detect_text(self, image: np.ndarray, **kwargs) -> List[OCRResult]:
+        """Detect text in image"""
+        raise NotImplementedError
+
+class CustomAPIProvider(OCRProvider):
+    """Custom API OCR provider that uses existing GUI variables"""
+    
+    def __init__(self, log_callback=None):
+        super().__init__(log_callback)
+        
+        # Use EXISTING environment variables from TranslatorGUI
+        self.api_url = os.environ.get('OPENAI_CUSTOM_BASE_URL', '')
+        self.api_key = os.environ.get('API_KEY', '') or os.environ.get('OPENAI_API_KEY', '')
+        self.model_name = os.environ.get('MODEL', 'gpt-4o-mini')
+        
+        # OCR prompt - use system prompt or a dedicated OCR prompt variable
+        self.ocr_prompt = os.environ.get('OCR_SYSTEM_PROMPT', 
+            os.environ.get('SYSTEM_PROMPT', 
+            "YOU ARE AN OCR SYSTEM. YOUR ONLY JOB IS TEXT EXTRACTION.\n\n"
+            "CRITICAL RULES:\n"
+            "1. DO NOT TRANSLATE ANYTHING\n"
+            "2. DO NOT MODIFY THE TEXT\n"
+            "3. DO NOT EXPLAIN OR COMMENT\n"
+            "4. ONLY OUTPUT THE EXACT TEXT YOU SEE\n"
+            "5. PRESERVE NATURAL TEXT FLOW - DO NOT ADD UNNECESSARY LINE BREAKS\n\n"
+            "If you see Korean text, output it in Korean.\n"
+            "If you see Japanese text, output it in Japanese.\n"
+            "If you see Chinese text, output it in Chinese.\n"
+            "If you see English text, output it in English.\n\n"
+            "IMPORTANT: Only use line breaks where they naturally occur in the original text "
+            "(e.g., between dialogue lines or paragraphs). Do not break text mid-sentence or "
+            "between every word/character.\n\n"
+            "For vertical text common in manga/comics, transcribe it as a continuous line unless "
+            "there are clear visual breaks.\n\n"
+            "NEVER translate. ONLY extract exactly what is written.\n"
+            "Output ONLY the raw text, nothing else."
+            ))
+        
+        # Use existing temperature and token settings  
+        self.temperature = float(os.environ.get('TRANSLATION_TEMPERATURE', '0.01'))
+        # Don't hardcode to 8192 - get fresh value when actually used
+        self.max_tokens = int(os.environ.get('MAX_OUTPUT_TOKENS', '4096'))
+        
+        # Image settings from existing compression variables
+        self.image_format = 'jpeg' if os.environ.get('IMAGE_COMPRESSION_FORMAT', 'auto') != 'png' else 'png'
+        self.image_quality = int(os.environ.get('JPEG_QUALITY', '100'))
+        
+        # Simple defaults
+        self.api_format = 'openai'  # Most custom endpoints are OpenAI-compatible
+        self.timeout = int(os.environ.get('CHUNK_TIMEOUT', '30'))
+        self.api_headers = {}  # Additional custom headers
+        
+        # Retry configuration for Custom API OCR calls
+        self.max_retries = int(os.environ.get('CUSTOM_OCR_MAX_RETRIES', '3'))
+        self.retry_initial_delay = float(os.environ.get('CUSTOM_OCR_RETRY_INITIAL_DELAY', '0.8'))
+        self.retry_backoff = float(os.environ.get('CUSTOM_OCR_RETRY_BACKOFF', '1.8'))
+        self.retry_jitter = float(os.environ.get('CUSTOM_OCR_RETRY_JITTER', '0.4'))
+        self.retry_on_empty = os.environ.get('CUSTOM_OCR_RETRY_ON_EMPTY', '1') == '1'
+        
+    def check_installation(self) -> bool:
+        """Always installed - uses UnifiedClient"""
+        self.is_installed = True
+        return True
+    
+    def install(self, progress_callback=None) -> bool:
+        """No installation needed for API-based provider"""
+        return self.check_installation()
+    
+    def load_model(self, **kwargs) -> bool:
+        """Initialize UnifiedClient with current settings"""
+        try:
+            from unified_api_client import UnifiedClient
+            
+            # Support passing API key from GUI if available
+            if 'api_key' in kwargs:
+                api_key = kwargs['api_key']
+            else:
+                api_key = os.environ.get('API_KEY', '') or os.environ.get('OPENAI_API_KEY', '')
+            
+            if 'model' in kwargs:
+                model = kwargs['model']
+            else:
+                model = os.environ.get('MODEL', 'gpt-4o-mini')
+            
+            if not api_key:
+                self._log("❌ No API key configured", "error")
+                return False
+            
+            # Create UnifiedClient just like translations do
+            self.client = UnifiedClient(model=model, api_key=api_key)
+            
+            #self._log(f"✅ Using {model} for OCR via UnifiedClient")
+            self.is_loaded = True
+            return True
+            
+        except Exception as e:
+            self._log(f"❌ Failed to initialize UnifiedClient: {str(e)}", "error")
+            return False
+    
+    def _test_connection(self) -> bool:
+        """Test API connection with a simple request"""
+        try:
+            # Create a small test image
+            test_image = np.ones((100, 100, 3), dtype=np.uint8) * 255
+            cv2.putText(test_image, "TEST", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
+            
+            # Encode image
+            image_base64 = self._encode_image(test_image)
+            
+            # Prepare test request based on API format
+            if self.api_format == 'openai':
+                test_payload = {
+                    "model": self.model_name,
+                    "messages": [
+                        {
+                            "role": "user",
+                            "content": [
+                                {"type": "text", "text": "What text do you see?"},
+                                {"type": "image_url", "image_url": {"url": f"data:image/{self.image_format};base64,{image_base64}"}}
+                            ]
+                        }
+                    ],
+                    "max_tokens": 50
+                }
+            else:
+                # For other formats, just try a basic health check
+                return True
+            
+            headers = self._prepare_headers()
+            response = requests.post(
+                self.api_url,
+                headers=headers,
+                json=test_payload,
+                timeout=10
+            )
+            
+            return response.status_code == 200
+            
+        except Exception:
+            return False
+    
+    def _encode_image(self, image: np.ndarray) -> str:
+        """Encode numpy array to base64 string"""
+        # Convert BGR to RGB if needed
+        if len(image.shape) == 3 and image.shape[2] == 3:
+            image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        else:
+            image_rgb = image
+        
+        # Convert to PIL Image
+        pil_image = Image.fromarray(image_rgb)
+        
+        # Save to bytes buffer
+        buffer = io.BytesIO()
+        if self.image_format.lower() == 'png':
+            pil_image.save(buffer, format='PNG')
+        else:
+            pil_image.save(buffer, format='JPEG', quality=self.image_quality)
+        
+        # Encode to base64
+        buffer.seek(0)
+        image_base64 = base64.b64encode(buffer.read()).decode('utf-8')
+        
+        return image_base64
+    
+    def _prepare_headers(self) -> dict:
+        """Prepare request headers"""
+        headers = {
+            "Content-Type": "application/json"
+        }
+        
+        # Add API key if configured
+        if self.api_key:
+            if self.api_format == 'anthropic':
+                headers["x-api-key"] = self.api_key
+            else:
+                headers["Authorization"] = f"Bearer {self.api_key}"
+        
+        # Add any custom headers
+        headers.update(self.api_headers)
+        
+        return headers
+    
+    def _prepare_request_payload(self, image_base64: str) -> dict:
+        """Prepare request payload based on API format"""
+        if self.api_format == 'openai':
+            return {
+                "model": self.model_name,
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": self.ocr_prompt},
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:image/{self.image_format};base64,{image_base64}"
+                                }
+                            }
+                        ]
+                    }
+                ],
+                "max_tokens": self.max_tokens,
+                "temperature": self.temperature
+            }
+        
+        elif self.api_format == 'anthropic':
+            return {
+                "model": self.model_name,
+                "max_tokens": self.max_tokens,
+                "temperature": self.temperature,
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": self.ocr_prompt
+                            },
+                            {
+                                "type": "image",
+                                "source": {
+                                    "type": "base64",
+                                    "media_type": f"image/{self.image_format}",
+                                    "data": image_base64
+                                }
+                            }
+                        ]
+                    }
+                ]
+            }
+        
+        else:
+            # Custom format - use environment variable for template
+            template = os.environ.get('CUSTOM_OCR_REQUEST_TEMPLATE', '{}')
+            payload = json.loads(template)
+            
+            # Replace placeholders
+            payload_str = json.dumps(payload)
+            payload_str = payload_str.replace('{{IMAGE_BASE64}}', image_base64)
+            payload_str = payload_str.replace('{{PROMPT}}', self.ocr_prompt)
+            payload_str = payload_str.replace('{{MODEL}}', self.model_name)
+            payload_str = payload_str.replace('{{MAX_TOKENS}}', str(self.max_tokens))
+            payload_str = payload_str.replace('{{TEMPERATURE}}', str(self.temperature))
+            
+            return json.loads(payload_str)
+    
+    def _extract_text_from_response(self, response_data: dict) -> str:
+        """Extract text from API response based on format"""
+        try:
+            if self.api_format == 'openai':
+                # OpenAI format: response.choices[0].message.content
+                return response_data.get('choices', [{}])[0].get('message', {}).get('content', '')
+            
+            elif self.api_format == 'anthropic':
+                # Anthropic format: response.content[0].text
+                content = response_data.get('content', [])
+                if content and isinstance(content, list):
+                    return content[0].get('text', '')
+                return ''
+            
+            else:
+                # Custom format - use environment variable for path
+                response_path = os.environ.get('CUSTOM_OCR_RESPONSE_PATH', 'text')
+                
+                # Navigate through the response using the path
+                result = response_data
+                for key in response_path.split('.'):
+                    if isinstance(result, dict):
+                        result = result.get(key, '')
+                    elif isinstance(result, list) and key.isdigit():
+                        idx = int(key)
+                        result = result[idx] if idx < len(result) else ''
+                    else:
+                        result = ''
+                        break
+                
+                return str(result)
+                
+        except Exception as e:
+            self._log(f"Failed to extract text from response: {e}", "error")
+            return ''
+    
+    def detect_text(self, image: np.ndarray, **kwargs) -> List[OCRResult]:
+        """Process image using UnifiedClient.send_image()"""
+        results = []
+        
+        try:
+            # Get fresh max_tokens from environment - GUI will have set this
+            max_tokens = int(os.environ.get('MAX_OUTPUT_TOKENS', '4096'))
+            if not self.is_loaded:
+                if not self.load_model():
+                    return results
+            
+            import cv2
+            from PIL import Image
+            import base64
+            import io
+            
+            # Convert numpy array to PIL Image
+            image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            pil_image = Image.fromarray(image_rgb)
+            h, w = image.shape[:2]
+            
+            # Convert PIL Image to base64 string
+            buffer = io.BytesIO()
+            
+            # Use the image format from settings
+            if self.image_format.lower() == 'png':
+                pil_image.save(buffer, format='PNG')
+            else:
+                pil_image.save(buffer, format='JPEG', quality=self.image_quality)
+            
+            buffer.seek(0)
+            image_base64 = base64.b64encode(buffer.read()).decode('utf-8')
+            
+            # For OpenAI vision models, we need BOTH:
+            # 1. System prompt with instructions
+            # 2. User message that includes the image
+            messages = [
+                {
+                    "role": "system",
+                    "content": self.ocr_prompt  # The OCR instruction as system prompt
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "Image:"  # Minimal text, just to have something
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{image_base64}"
+                            }
+                        }
+                    ]
+                }
+            ]
+            
+            # Now send this properly formatted message
+            # The UnifiedClient should handle this correctly
+            # But we're NOT using send_image, we're using regular send
+
+            # Retry-aware call
+            from unified_api_client import UnifiedClientError  # local import to avoid hard dependency at module import time
+            max_attempts = max(1, self.max_retries)
+            attempt = 0
+            last_error = None
+
+            # Common refusal/error phrases that indicate a non-OCR response
+            refusal_phrases = [
+                "I can't extract", "I cannot extract",
+                "I'm sorry", "I am sorry",
+                "I'm unable", "I am unable",
+                "cannot process images",
+                "I can't help with that",
+                "cannot view images",
+                "no text in the image"
+            ]
+
+            while attempt < max_attempts:
+                # Check for stop before each attempt
+                if self._check_stop():
+                    self._log("⏹️ OCR processing stopped by user", "warning")
+                    return results
+                
+                try:
+                    response = self.client.send(
+                        messages=messages,
+                        temperature=self.temperature,
+                        max_tokens=max_tokens
+                    )
+
+                    # Extract content from response object
+                    content, finish_reason = response
+
+                    # Validate content
+                    has_content = bool(content and str(content).strip())
+                    refused = False
+                    if has_content:
+                        # Filter out explicit failure markers
+                        if "[" in content and "FAILED]" in content:
+                            refused = True
+                        elif any(phrase.lower() in content.lower() for phrase in refusal_phrases):
+                            refused = True
+
+                    # Decide success or retry
+                    if has_content and not refused:
+                        text = str(content).strip()
+                        results.append(OCRResult(
+                            text=text,
+                            bbox=(0, 0, w, h),
+                            confidence=kwargs.get('confidence', 0.85),
+                            vertices=[(0, 0), (w, 0), (w, h), (0, h)]
+                        ))
+                        self._log(f"✅ Detected: {text[:50]}...")
+                        break  # success
+                    else:
+                        reason = "empty result" if not has_content else "refusal/non-OCR response"
+                        last_error = f"{reason} (finish_reason: {finish_reason})"
+                        # Check if we should retry on empty or refusal
+                        should_retry = (not has_content and self.retry_on_empty) or refused
+                        attempt += 1
+                        if attempt >= max_attempts or not should_retry:
+                            # No more retries or shouldn't retry
+                            if not has_content:
+                                self._log(f"⚠️ No text detected (finish_reason: {finish_reason})")
+                            else:
+                                self._log(f"❌ Model returned non-OCR response: {str(content)[:120]}", "warning")
+                            break
+                        # Backoff before retrying
+                        delay = self.retry_initial_delay * (self.retry_backoff ** (attempt - 1)) + random.uniform(0, self.retry_jitter)
+                        self._log(f"🔄 Retry {attempt}/{max_attempts - 1} after {delay:.1f}s due to {reason}...", "warning")
+                        time.sleep(delay)
+                        time.sleep(0.1)  # Brief pause for stability
+                        self._log("💤 OCR retry pausing briefly for stability", "debug")
+                        continue
+
+                except UnifiedClientError as ue:
+                    msg = str(ue)
+                    last_error = msg
+                    # Do not retry on explicit user cancellation
+                    if 'cancelled' in msg.lower() or 'stopped by user' in msg.lower():
+                        self._log(f"❌ OCR cancelled: {msg}", "error")
+                        break
+                    attempt += 1
+                    if attempt >= max_attempts:
+                        self._log(f"❌ OCR failed after {attempt} attempts: {msg}", "error")
+                        break
+                    delay = self.retry_initial_delay * (self.retry_backoff ** (attempt - 1)) + random.uniform(0, self.retry_jitter)
+                    self._log(f"🔄 API error, retry {attempt}/{max_attempts - 1} after {delay:.1f}s: {msg}", "warning")
+                    time.sleep(delay)
+                    time.sleep(0.1)  # Brief pause for stability
+                    self._log("💤 OCR API error retry pausing briefly for stability", "debug")
+                    continue
+                except Exception as e_inner:
+                    last_error = str(e_inner)
+                    attempt += 1
+                    if attempt >= max_attempts:
+                        self._log(f"❌ OCR exception after {attempt} attempts: {last_error}", "error")
+                        break
+                    delay = self.retry_initial_delay * (self.retry_backoff ** (attempt - 1)) + random.uniform(0, self.retry_jitter)
+                    self._log(f"🔄 Exception, retry {attempt}/{max_attempts - 1} after {delay:.1f}s: {last_error}", "warning")
+                    time.sleep(delay)
+                    time.sleep(0.1)  # Brief pause for stability
+                    self._log("💤 OCR exception retry pausing briefly for stability", "debug")
+                    continue
+        
+        except Exception as e:
+            self._log(f"❌ Error: {str(e)}", "error")
+            import traceback
+            self._log(traceback.format_exc(), "debug")
+        
+        return results
+
+class MangaOCRProvider(OCRProvider):
+    """Manga OCR provider using HuggingFace model directly"""
+    
+    def __init__(self, log_callback=None):
+        super().__init__(log_callback)
+        self.processor = None
+        self.model = None
+        self.tokenizer = None
+        
+    def check_installation(self) -> bool:
+        """Check if transformers is installed"""
+        try:
+            import transformers
+            import torch
+            self.is_installed = True
+            return True
+        except ImportError:
+            return False 
+    
+    def install(self, progress_callback=None) -> bool:
+        """Install transformers and torch"""
+        pass
+    
+    def _is_valid_local_model_dir(self, path: str) -> bool:
+        """Check that a local HF model directory has required files."""
+        try:
+            if not path or not os.path.isdir(path):
+                return False
+            needed_any_weights = any(
+                os.path.exists(os.path.join(path, name)) for name in (
+                    'pytorch_model.bin',
+                    'model.safetensors'
+                )
+            )
+            has_config = os.path.exists(os.path.join(path, 'config.json'))
+            has_processor = (
+                os.path.exists(os.path.join(path, 'preprocessor_config.json')) or
+                os.path.exists(os.path.join(path, 'processor_config.json'))
+            )
+            has_tokenizer = (
+                os.path.exists(os.path.join(path, 'tokenizer.json')) or
+                os.path.exists(os.path.join(path, 'tokenizer_config.json'))
+            )
+            return has_config and needed_any_weights and has_processor and has_tokenizer
+        except Exception:
+            return False
+    
+    def load_model(self, **kwargs) -> bool:
+        """Load the manga-ocr model, preferring a local directory to avoid re-downloading"""
+        try:
+            if not self.is_installed and not self.check_installation():
+                self._log("❌ Transformers not installed", "error")
+                return False
+
+            # Always disable progress bars to avoid tqdm issues in some environments
+            import os
+            os.environ.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1")
+
+            from transformers import VisionEncoderDecoderModel, AutoTokenizer, AutoImageProcessor
+            import torch
+
+            # Prefer a local model directory if present to avoid any Hub access
+            candidates = []
+            env_local = os.environ.get("MANGA_OCR_LOCAL_DIR")
+            if env_local:
+                candidates.append(env_local)
+
+            # Project root one level up from this file
+            root_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+            candidates.append(os.path.join(root_dir, 'models', 'manga-ocr-base'))
+            candidates.append(os.path.join(root_dir, 'models', 'kha-white', 'manga-ocr-base'))
+
+            model_source = None
+            local_only = False
+            # Find a valid local dir
+            for cand in candidates:
+                if self._is_valid_local_model_dir(cand):
+                    model_source = cand
+                    local_only = True
+                    break
+
+            # If no valid local dir, use Hub
+            if not model_source:
+                model_source = "kha-white/manga-ocr-base"
+                # Make sure we are not forcing offline mode
+                if os.environ.get("HF_HUB_OFFLINE") == "1":
+                    try:
+                        del os.environ["HF_HUB_OFFLINE"]
+                    except Exception:
+                        pass
+                self._log("🔥 Loading manga-ocr model from Hugging Face Hub")
+                self._log(f"   Repo: {model_source}")
+            else:
+                # Only set offline when local dir is fully valid
+                os.environ.setdefault("HF_HUB_OFFLINE", "1")
+                self._log("🔥 Loading manga-ocr model from local directory")
+                self._log(f"   Local path: {model_source}")
+
+            # Decide target device once; we will move after full CPU load to avoid meta tensors
+            use_cuda = torch.cuda.is_available()
+
+            # Try loading components, falling back to Hub if local-only fails
+            def _load_components(source: str, local_flag: bool):
+                self._log("   Loading tokenizer...")
+                tok = AutoTokenizer.from_pretrained(source, local_files_only=local_flag)
+
+                self._log("   Loading image processor...")
+                try:
+                    from transformers import AutoProcessor
+                except Exception:
+                    AutoProcessor = None
+                try:
+                    proc = AutoImageProcessor.from_pretrained(source, local_files_only=local_flag)
+                except Exception as e_proc:
+                    if AutoProcessor is not None:
+                        self._log(f"   ⚠️ AutoImageProcessor failed: {e_proc}. Trying AutoProcessor...", "warning")
+                        proc = AutoProcessor.from_pretrained(source, local_files_only=local_flag)
+                    else:
+                        raise
+
+                self._log("   Loading model...")
+                # Prevent meta tensors by forcing full materialization on CPU at load time
+                os.environ.setdefault('TORCHDYNAMO_DISABLE', '1')
+                mdl = VisionEncoderDecoderModel.from_pretrained(
+                    source,
+                    local_files_only=local_flag,
+                    low_cpu_mem_usage=False,
+                    dtype=torch.float32,
+                    device_map=None
+                )
+                return tok, proc, mdl
+
+            try:
+                self.tokenizer, self.processor, self.model = _load_components(model_source, local_only)
+            except Exception as e_local:
+                if local_only:
+                    # Fallback to Hub once if local fails
+                    self._log(f"   ⚠️ Local model load failed: {e_local}", "warning")
+                    try:
+                        if os.environ.get("HF_HUB_OFFLINE") == "1":
+                            del os.environ["HF_HUB_OFFLINE"]
+                    except Exception:
+                        pass
+                    model_source = "kha-white/manga-ocr-base"
+                    local_only = False
+                    self._log("   Retrying from Hugging Face Hub...")
+                    self.tokenizer, self.processor, self.model = _load_components(model_source, local_only)
+                else:
+                    raise
+
+            # Move to CUDA only after full CPU materialization
+            target_device = 'cpu'
+            if use_cuda:
+                try:
+                    self.model = self.model.to('cuda')
+                    target_device = 'cuda'
+                except Exception as move_err:
+                    self._log(f"   ⚠️ Could not move model to CUDA: {move_err}", "warning")
+                    target_device = 'cpu'
+
+            # Finalize eval mode
+            self.model.eval()
+
+            # Sanity-check: ensure no parameter remains on 'meta' device
+            try:
+                for n, p in self.model.named_parameters():
+                    dev = getattr(p, 'device', None)
+                    if dev is not None and getattr(dev, 'type', '') == 'meta':
+                        raise RuntimeError(f"Parameter {n} is on 'meta' after load")
+            except Exception as sanity_err:
+                self._log(f"❌ Manga-OCR model load sanity check failed: {sanity_err}", "error")
+                return False
+
+            self._log(f"   ✅ Model loaded on {target_device.upper()}")
+            self.is_loaded = True
+            self._log("✅ Manga OCR model ready")
+            return True
+
+        except Exception as e:
+            self._log(f"❌ Failed to load manga-ocr model: {str(e)}", "error")
+            import traceback
+            self._log(traceback.format_exc(), "error")
+            try:
+                if 'local_only' in locals() and local_only:
+                    self._log("Hint: Local load failed. Ensure your models/manga-ocr-base contains required files (config.json, preprocessor_config.json, tokenizer.json or tokenizer_config.json, and model weights).", "warning")
+            except Exception:
+                pass
+            return False
+    
+    def _run_ocr(self, pil_image):
+        """Run OCR on a PIL image using the HuggingFace model"""
+        import torch
+        
+        # Process image (keyword arg for broader compatibility across transformers versions)
+        inputs = self.processor(images=pil_image, return_tensors="pt")
+        pixel_values = inputs["pixel_values"]
+        
+        # Move to same device as model
+        try:
+            model_device = next(self.model.parameters()).device
+        except StopIteration:
+            model_device = torch.device('cpu')
+        pixel_values = pixel_values.to(model_device)
+        
+        # Generate text
+        with torch.no_grad():
+            generated_ids = self.model.generate(pixel_values)
+        
+        # Decode
+        generated_text = self.tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
+        
+        return generated_text
+    
+    def detect_text(self, image: np.ndarray, **kwargs) -> List[OCRResult]:
+        """
+        Process the image region passed to it.
+        This could be a bubble region or the full image.
+        """
+        results = []
+        
+        # Check for stop at start
+        if self._check_stop():
+            self._log("⏹️ Manga-OCR processing stopped by user", "warning")
+            return results
+        
+        try:
+            if not self.is_loaded:
+                if not self.load_model():
+                    return results
+            
+            import cv2
+            from PIL import Image
+            
+            # Get confidence from kwargs
+            confidence = kwargs.get('confidence', 0.7)
+            
+            # Convert numpy array to PIL
+            image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            pil_image = Image.fromarray(image_rgb)
+            h, w = image.shape[:2]
+            
+            self._log("🔍 Processing region with manga-ocr...")
+            
+            # Check for stop before inference
+            if self._check_stop():
+                self._log("⏹️ Manga-OCR inference stopped by user", "warning")
+                return results
+            
+            # Run OCR on the image region
+            text = self._run_ocr(pil_image)
+            
+            if text and text.strip():
+                # Return result for this region with its actual bbox
+                results.append(OCRResult(
+                    text=text.strip(),
+                    bbox=(0, 0, w, h),  # Relative to the region passed in
+                    confidence=confidence,
+                    vertices=[(0, 0), (w, 0), (w, h), (0, h)]
+                ))
+                self._log(f"✅ Detected text: {text[:50]}...")
+            
+        except Exception as e:
+            self._log(f"❌ Error in manga-ocr: {str(e)}", "error")
+            
+        return results
+
+class Qwen2VL(OCRProvider):
+    """OCR using Qwen2-VL - Vision Language Model that can read Korean text"""
+    
+    def __init__(self, log_callback=None):
+        super().__init__(log_callback)
+        self.processor = None
+        self.model = None
+        self.tokenizer = None
+        
+        # Get OCR prompt from environment or use default
+        self.ocr_prompt = os.environ.get('OCR_SYSTEM_PROMPT', 
+            "YOU ARE AN OCR SYSTEM. YOUR ONLY JOB IS TEXT EXTRACTION.\n\n"
+            "CRITICAL RULES:\n"
+            "1. DO NOT TRANSLATE ANYTHING\n"
+            "2. DO NOT MODIFY THE TEXT\n"
+            "3. DO NOT EXPLAIN OR COMMENT\n"
+            "4. ONLY OUTPUT THE EXACT TEXT YOU SEE\n"
+            "5. PRESERVE NATURAL TEXT FLOW - DO NOT ADD UNNECESSARY LINE BREAKS\n\n"
+            "If you see Korean text, output it in Korean.\n"
+            "If you see Japanese text, output it in Japanese.\n"
+            "If you see Chinese text, output it in Chinese.\n"
+            "If you see English text, output it in English.\n\n"
+            "IMPORTANT: Only use line breaks where they naturally occur in the original text "
+            "(e.g., between dialogue lines or paragraphs). Do not break text mid-sentence or "
+            "between every word/character.\n\n"
+            "For vertical text common in manga/comics, transcribe it as a continuous line unless "
+            "there are clear visual breaks.\n\n"
+            "NEVER translate. ONLY extract exactly what is written.\n"
+            "Output ONLY the raw text, nothing else."
+        )
+    
+    def set_ocr_prompt(self, prompt: str):
+        """Allow setting the OCR prompt dynamically"""
+        self.ocr_prompt = prompt
+        
+    def check_installation(self) -> bool:
+        """Check if required packages are installed"""
+        try:
+            import transformers
+            import torch
+            self.is_installed = True
+            return True
+        except ImportError:
+            return False
+    
+    def install(self, progress_callback=None) -> bool:
+        """Install requirements for Qwen2-VL"""
+        pass
+    
+    def load_model(self, model_size=None, **kwargs) -> bool:
+        """Load Qwen2-VL model with size selection"""
+        self._log(f"DEBUG: load_model called with model_size={model_size}")
+
+        try:
+            if not self.is_installed and not self.check_installation():
+                self._log("❌ Not installed", "error")
+                return False
+            
+            self._log("🔥 Loading Qwen2-VL for Advanced OCR...")
+
+
+            
+            from transformers import AutoProcessor, AutoTokenizer
+            import torch
+            
+            # Model options
+            model_options = {
+                "1": "Qwen/Qwen2-VL-2B-Instruct",
+                "2": "Qwen/Qwen2-VL-7B-Instruct",
+                "3": "Qwen/Qwen2-VL-72B-Instruct",
+                "4": "custom"
+            }
+            # CHANGE: Default to 7B instead of 2B
+            # Check for saved preference first
+            if model_size is None:
+                # Try to get from environment or config
+                import os
+                model_size = os.environ.get('QWEN2VL_MODEL_SIZE', '1')
+            
+            # Determine which model to load
+            if model_size and str(model_size).startswith("custom:"):
+                # Custom model passed with ID
+                model_id = str(model_size).replace("custom:", "")
+                self.loaded_model_size = "Custom"
+                self.model_id = model_id
+                self._log(f"Loading custom model: {model_id}")
+            elif model_size == "4":
+                # Custom option selected but no ID - shouldn't happen
+                self._log("❌ Custom model selected but no ID provided", "error")
+                return False
+            elif model_size and str(model_size) in model_options:
+                # Standard model option
+                option = model_options[str(model_size)]
+                if option == "custom":
+                    self._log("❌ Custom model needs an ID", "error")
+                    return False
+                model_id = option
+                # Set loaded_model_size for status display
+                if model_size == "1":
+                    self.loaded_model_size = "2B"
+                elif model_size == "2":
+                    self.loaded_model_size = "7B"
+                elif model_size == "3":
+                    self.loaded_model_size = "72B"
+            else:
+                # CHANGE: Default to 7B (option "2") instead of 2B
+                model_id = model_options["1"]  # Changed from "1" to "2"
+                self.loaded_model_size = "2B"   # Changed from "2B" to "7B"
+                self._log("No model size specified, defaulting to 2B")  # Changed message
+            
+            self._log(f"Loading model: {model_id}")
+            
+            # Load processor and tokenizer
+            self.processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
+            self.tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
+            
+            # Load the model - let it figure out the class dynamically
+            if torch.cuda.is_available():
+                self._log(f"GPU: {torch.cuda.get_device_name(0)}")
+                # Use auto model class
+                from transformers import AutoModelForVision2Seq
+                self.model = AutoModelForVision2Seq.from_pretrained(
+                    model_id,
+                    dtype=torch.float16,
+                    device_map="auto",
+                    trust_remote_code=True
+                )
+                self._log("✅ Model loaded on GPU")
+            else:
+                self._log("Loading on CPU...")
+                from transformers import AutoModelForVision2Seq
+                self.model = AutoModelForVision2Seq.from_pretrained(
+                    model_id,
+                    dtype=torch.float32,
+                    trust_remote_code=True
+                )
+                self._log("✅ Model loaded on CPU")
+            
+            self.model.eval()
+            self.is_loaded = True
+            self._log("✅ Qwen2-VL ready for Advanced OCR!")
+            return True
+            
+        except Exception as e:
+            self._log(f"❌ Failed to load: {str(e)}", "error")
+            import traceback
+            self._log(traceback.format_exc(), "debug")
+            return False       
+
+    def detect_text(self, image: np.ndarray, **kwargs) -> List[OCRResult]:
+        """Process image with Qwen2-VL for Korean text extraction"""
+        results = []
+        if hasattr(self, 'model_id'):
+            self._log(f"DEBUG: Using model: {self.model_id}", "debug")
+            
+        # Check if OCR prompt was passed in kwargs (for dynamic updates)
+        if 'ocr_prompt' in kwargs:
+            self.ocr_prompt = kwargs['ocr_prompt']
+        
+        try:
+            if not self.is_loaded:
+                if not self.load_model():
+                    return results
+            
+            import cv2
+            from PIL import Image
+            import torch
+            
+            # Convert to PIL
+            image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            pil_image = Image.fromarray(image_rgb)
+            h, w = image.shape[:2]
+            
+            self._log(f"🔍 Processing with Qwen2-VL ({w}x{h} pixels)...")
+            
+            # Use the configurable OCR prompt
+            messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "image",
+                            "image": pil_image,
+                        },
+                        {
+                            "type": "text", 
+                            "text": self.ocr_prompt  # Use the configurable prompt
+                        }
+                    ]
+                }
+            ]
+            
+            # Alternative simpler prompt if the above still causes issues:
+            # "text": "OCR: Extract text as-is"
+            
+            # Process with Qwen2-VL
+            text = self.processor.apply_chat_template(
+                messages, 
+                tokenize=False, 
+                add_generation_prompt=True
+            )
+
+            inputs = self.processor(
+                text=[text],
+                images=[pil_image],
+                padding=True,
+                return_tensors="pt"
+            )
+
+            # Get the device and dtype the model is currently on
+            model_device = next(self.model.parameters()).device
+            model_dtype = next(self.model.parameters()).dtype
+
+            # Move inputs to the same device as the model and cast float tensors to model dtype
+            try:
+                # Move first
+                inputs = inputs.to(model_device)
+                # Then align dtypes only for floating tensors (e.g., pixel_values)
+                for k, v in inputs.items():
+                    if isinstance(v, torch.Tensor) and torch.is_floating_point(v):
+                        inputs[k] = v.to(model_dtype)
+            except Exception:
+                # Fallback: ensure at least pixel_values is correct if present
+                try:
+                    if isinstance(inputs, dict) and "pixel_values" in inputs:
+                        pv = inputs["pixel_values"].to(model_device)
+                        if torch.is_floating_point(pv):
+                            inputs["pixel_values"] = pv.to(model_dtype)
+                except Exception:
+                    pass
+
+            # Ensure pixel_values explicitly matches model dtype if present
+            try:
+                if isinstance(inputs, dict) and "pixel_values" in inputs:
+                    inputs["pixel_values"] = inputs["pixel_values"].to(device=model_device, dtype=model_dtype)
+            except Exception:
+                pass
+
+            # Generate text with stricter parameters to avoid creative responses
+            use_amp = (hasattr(torch, 'cuda') and model_device.type == 'cuda' and model_dtype in (torch.float16, torch.bfloat16))
+            autocast_dev = 'cuda' if model_device.type == 'cuda' else 'cpu'
+            autocast_dtype = model_dtype if model_dtype in (torch.float16, torch.bfloat16) else None
+
+            with torch.no_grad():
+                if use_amp and autocast_dtype is not None:
+                    with torch.autocast(autocast_dev, dtype=autocast_dtype):
+                        generated_ids = self.model.generate(
+                            **inputs,
+                            max_new_tokens=128,      # Reduced from 512 - manga bubbles are typically short
+                            do_sample=False,        # Keep deterministic
+                            temperature=0.01,       # Keep your very low temperature
+                            top_p=1.0,             # Keep no nucleus sampling
+                            repetition_penalty=1.0, # Keep no repetition penalty
+                            num_beams=1,           # Ensure greedy decoding (faster than beam search)
+                            use_cache=True,        # Enable KV cache for speed
+                            early_stopping=True,   # Stop at EOS token
+                            pad_token_id=self.tokenizer.pad_token_id,      # Proper padding
+                            eos_token_id=self.tokenizer.eos_token_id,      # Proper stopping
+                        )
+                else:
+                    generated_ids = self.model.generate(
+                        **inputs,
+                        max_new_tokens=128,      # Reduced from 512 - manga bubbles are typically short
+                        do_sample=False,        # Keep deterministic
+                        temperature=0.01,       # Keep your very low temperature
+                        top_p=1.0,             # Keep no nucleus sampling
+                        repetition_penalty=1.0, # Keep no repetition penalty
+                        num_beams=1,           # Ensure greedy decoding (faster than beam search)
+                        use_cache=True,        # Enable KV cache for speed
+                        early_stopping=True,   # Stop at EOS token
+                        pad_token_id=self.tokenizer.pad_token_id,      # Proper padding
+                        eos_token_id=self.tokenizer.eos_token_id,      # Proper stopping
+                    )
+            
+            # Decode the output
+            generated_ids_trimmed = [
+                out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+            ]
+            output_text = self.processor.batch_decode(
+                generated_ids_trimmed, 
+                skip_special_tokens=True, 
+                clean_up_tokenization_spaces=False
+            )[0]
+            
+            if output_text and output_text.strip():
+                text = output_text.strip()
+                
+                # ADDED: Filter out any response that looks like an explanation or apology
+                # Common patterns that indicate the model is being "helpful" instead of just extracting
+                unwanted_patterns = [
+                    "죄송합니다",  # "I apologize"
+                    "sorry",
+                    "apologize",
+                    "이미지에는",  # "in this image"
+                    "텍스트가 없습니다",  # "there is no text"
+                    "I cannot",
+                    "I don't see",
+                    "There is no",
+                    "질문이 있으시면",  # "if you have questions"
+                ]
+                
+                # Check if response contains unwanted patterns
+                text_lower = text.lower()
+                is_explanation = any(pattern.lower() in text_lower for pattern in unwanted_patterns)
+                
+                # Also check if the response is suspiciously long for a bubble
+                # Most manga bubbles are short, if we get 50+ chars it might be an explanation
+                is_too_long = len(text) > 100 and ('.' in text or ',' in text or '!' in text)
+                
+                if is_explanation or is_too_long:
+                    self._log(f"⚠️ Model returned explanation instead of text, ignoring", "warning")
+                    # Return empty result or just skip this region
+                    return results
+                
+                # Check language
+                has_korean = any('\uAC00' <= c <= '\uD7AF' for c in text)
+                has_japanese = any('\u3040' <= c <= '\u309F' or '\u30A0' <= c <= '\u30FF' for c in text)
+                has_chinese = any('\u4E00' <= c <= '\u9FFF' for c in text)
+                
+                if has_korean:
+                    self._log(f"✅ Korean detected: {text[:50]}...")
+                elif has_japanese:
+                    self._log(f"✅ Japanese detected: {text[:50]}...")
+                elif has_chinese:
+                    self._log(f"✅ Chinese detected: {text[:50]}...")
+                else:
+                    self._log(f"✅ Text: {text[:50]}...")
+                
+                results.append(OCRResult(
+                    text=text,
+                    bbox=(0, 0, w, h),
+                    confidence=0.9,
+                    vertices=[(0, 0), (w, 0), (w, h), (0, h)]
+                ))
+            else:
+                self._log("⚠️ No text detected", "warning")
+        
+        except Exception as e:
+            self._log(f"❌ Error: {str(e)}", "error")
+            import traceback
+            self._log(traceback.format_exc(), "debug")
+        
+        return results
+    
+class EasyOCRProvider(OCRProvider):
+    """EasyOCR provider for multiple languages"""
+    
+    def __init__(self, log_callback=None, languages=None):
+        super().__init__(log_callback)
+        # Default to safe language combination
+        self.languages = languages or ['ja', 'en']  # Safe default
+        self._validate_language_combination()
+
+    def _validate_language_combination(self):
+        """Validate and fix EasyOCR language combinations"""
+        # EasyOCR language compatibility rules
+        incompatible_pairs = [
+            (['ja', 'ko'], 'Japanese and Korean cannot be used together'),
+            (['ja', 'zh'], 'Japanese and Chinese cannot be used together'),
+            (['ko', 'zh'], 'Korean and Chinese cannot be used together')
+        ]
+        
+        for incompatible, reason in incompatible_pairs:
+            if all(lang in self.languages for lang in incompatible):
+                self._log(f"⚠️ EasyOCR: {reason}", "warning")
+                # Keep first language + English
+                self.languages = [self.languages[0], 'en']
+                self._log(f"🔧 Auto-adjusted to: {self.languages}", "info")
+                break
+    
+    def check_installation(self) -> bool:
+        """Check if easyocr is installed"""
+        try:
+            import easyocr
+            self.is_installed = True
+            return True
+        except ImportError:
+            return False
+    
+    def install(self, progress_callback=None) -> bool:
+        """Install easyocr"""
+        pass
+    
+    def load_model(self, **kwargs) -> bool:
+        """Load easyocr model"""
+        try:
+            if not self.is_installed and not self.check_installation():
+                self._log("❌ easyocr not installed", "error")
+                return False
+            
+            self._log(f"🔥 Loading easyocr model for languages: {self.languages}...")
+            import easyocr
+            
+            # This will download models on first run
+            self.model = easyocr.Reader(self.languages, gpu=True)
+            self.is_loaded = True
+            
+            self._log("✅ easyocr model loaded successfully")
+            return True
+            
+        except Exception as e:
+            self._log(f"❌ Failed to load easyocr: {str(e)}", "error")
+            # Try CPU mode if GPU fails
+            try:
+                import easyocr
+                self.model = easyocr.Reader(self.languages, gpu=False)
+                self.is_loaded = True
+                self._log("✅ easyocr loaded in CPU mode")
+                return True
+            except:
+                return False
+    
+    def detect_text(self, image: np.ndarray, **kwargs) -> List[OCRResult]:
+        """Detect text using easyocr"""
+        results = []
+        
+        try:
+            if not self.is_loaded:
+                if not self.load_model():
+                    return results
+            
+            # EasyOCR can work directly with numpy arrays
+            ocr_results = self.model.readtext(image, detail=1)
+            
+            # Parse results
+            for (bbox, text, confidence) in ocr_results:
+                # bbox is a list of 4 points
+                xs = [point[0] for point in bbox]
+                ys = [point[1] for point in bbox]
+                x_min, x_max = min(xs), max(xs)
+                y_min, y_max = min(ys), max(ys)
+                
+                results.append(OCRResult(
+                    text=text,
+                    bbox=(int(x_min), int(y_min), int(x_max - x_min), int(y_max - y_min)),
+                    confidence=confidence,
+                    vertices=[(int(p[0]), int(p[1])) for p in bbox]
+                ))
+            
+            self._log(f"✅ Detected {len(results)} text regions")
+            
+        except Exception as e:
+            self._log(f"❌ Error in easyocr detection: {str(e)}", "error")
+        
+        return results
+
+
+class PaddleOCRProvider(OCRProvider):
+    """PaddleOCR provider with memory safety measures"""
+    
+    def check_installation(self) -> bool:
+        """Check if paddleocr is installed"""
+        try:
+            from paddleocr import PaddleOCR
+            self.is_installed = True
+            return True
+        except ImportError:
+            return False
+    
+    def install(self, progress_callback=None) -> bool:
+        """Install paddleocr"""
+        pass
+    
+    def load_model(self, **kwargs) -> bool:
+        """Load paddleocr model with memory-safe configurations"""
+        try:
+            if not self.is_installed and not self.check_installation():
+                self._log("❌ paddleocr not installed", "error")
+                return False
+            
+            self._log("🔥 Loading PaddleOCR model...")
+            
+            # Set memory-safe environment variables BEFORE importing
+            import os
+            os.environ['OMP_NUM_THREADS'] = '1'  # Prevent OpenMP conflicts
+            os.environ['MKL_NUM_THREADS'] = '1'  # Prevent MKL conflicts
+            os.environ['OPENBLAS_NUM_THREADS'] = '1'  # Prevent OpenBLAS conflicts
+            os.environ['FLAGS_use_mkldnn'] = '0'  # Disable MKL-DNN
+            
+            from paddleocr import PaddleOCR
+            
+            # Try memory-safe configurations
+            configs_to_try = [
+                # Config 1: Most memory-safe configuration
+                {
+                    'use_angle_cls': False,  # Disable angle to save memory
+                    'lang': 'ch',
+                    'rec_batch_num': 1,  # Process one at a time
+                    'max_text_length': 100,  # Limit text length
+                    'drop_score': 0.5,  # Higher threshold to reduce detections
+                    'cpu_threads': 1,  # Single thread to avoid conflicts
+                },
+                # Config 2: Minimal memory footprint
+                {
+                    'lang': 'ch',
+                    'rec_batch_num': 1,
+                    'cpu_threads': 1,
+                },
+                # Config 3: Absolute minimal
+                {
+                    'lang': 'ch'
+                },
+                # Config 4: Empty config
+                {}
+            ]
+            
+            for i, config in enumerate(configs_to_try):
+                try:
+                    self._log(f"   Trying configuration {i+1}/{len(configs_to_try)}: {config}")
+                    
+                    # Force garbage collection before loading
+                    import gc
+                    gc.collect()
+                    
+                    self.model = PaddleOCR(**config)
+                    self.is_loaded = True
+                    self.current_config = config
+                    self._log(f"✅ PaddleOCR loaded successfully with config: {config}")
+                    return True
+                except Exception as e:
+                    error_str = str(e)
+                    self._log(f"   Config {i+1} failed: {error_str}", "debug")
+                    
+                    # Clean up on failure
+                    if hasattr(self, 'model'):
+                        del self.model
+                    gc.collect()
+                    continue
+            
+            self._log(f"❌ PaddleOCR failed to load with any configuration", "error")
+            return False
+            
+        except Exception as e:
+            self._log(f"❌ Failed to load paddleocr: {str(e)}", "error")
+            import traceback
+            self._log(traceback.format_exc(), "debug")
+            return False
+    
+    def detect_text(self, image: np.ndarray, **kwargs) -> List[OCRResult]:
+        """Detect text with memory safety measures"""
+        results = []
+        
+        try:
+            if not self.is_loaded:
+                if not self.load_model():
+                    return results
+            
+            import cv2
+            import numpy as np
+            import gc
+            
+            # Memory safety: Ensure image isn't too large
+            h, w = image.shape[:2] if len(image.shape) >= 2 else (0, 0)
+            
+            # Limit image size to prevent memory issues
+            MAX_DIMENSION = 1500
+            if h > MAX_DIMENSION or w > MAX_DIMENSION:
+                scale = min(MAX_DIMENSION/h, MAX_DIMENSION/w)
+                new_h, new_w = int(h*scale), int(w*scale)
+                self._log(f"⚠️ Resizing large image from {w}x{h} to {new_w}x{new_h} for memory safety", "warning")
+                image = cv2.resize(image, (new_w, new_h), interpolation=cv2.INTER_AREA)
+                scale_factor = 1/scale
+            else:
+                scale_factor = 1.0
+            
+            # Ensure correct format
+            if len(image.shape) == 2:  # Grayscale
+                image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+            elif len(image.shape) == 4:  # Batch
+                image = image[0]
+            
+            # Ensure uint8 type
+            if image.dtype != np.uint8:
+                if image.max() <= 1.0:
+                    image = (image * 255).astype(np.uint8)
+                else:
+                    image = image.astype(np.uint8)
+            
+            # Make a copy to avoid memory corruption
+            image_copy = image.copy()
+            
+            # Force garbage collection before OCR
+            gc.collect()
+            
+            # Process with timeout protection
+            import signal
+            import threading
+            
+            ocr_results = None
+            ocr_error = None
+            
+            def run_ocr():
+                nonlocal ocr_results, ocr_error
+                try:
+                    ocr_results = self.model.ocr(image_copy)
+                except Exception as e:
+                    ocr_error = e
+            
+            # Run OCR in a separate thread with timeout
+            ocr_thread = threading.Thread(target=run_ocr)
+            ocr_thread.daemon = True
+            ocr_thread.start()
+            ocr_thread.join(timeout=30)  # 30 second timeout
+            
+            if ocr_thread.is_alive():
+                self._log("❌ PaddleOCR timeout - taking too long", "error")
+                return results
+            
+            if ocr_error:
+                raise ocr_error
+            
+            # Parse results
+            results = self._parse_ocr_results(ocr_results)
+            
+            # Scale coordinates back if image was resized
+            if scale_factor != 1.0 and results:
+                for r in results:
+                    x, y, width, height = r.bbox
+                    r.bbox = (int(x*scale_factor), int(y*scale_factor), 
+                            int(width*scale_factor), int(height*scale_factor))
+                    r.vertices = [(int(v[0]*scale_factor), int(v[1]*scale_factor)) 
+                                for v in r.vertices]
+            
+            if results:
+                self._log(f"✅ Detected {len(results)} text regions", "info")
+            else:
+                self._log("No text regions found", "debug")
+            
+            # Clean up
+            del image_copy
+            gc.collect()
+            
+        except Exception as e:
+            error_msg = str(e) if str(e) else type(e).__name__
+            
+            if "memory" in error_msg.lower() or "0x" in error_msg:
+                self._log("❌ Memory access violation in PaddleOCR", "error")
+                self._log("   This is a known Windows issue with PaddleOCR", "info")
+                self._log("   Please switch to EasyOCR or manga-ocr instead", "warning")
+            elif "trace_order.size()" in error_msg:
+                self._log("❌ PaddleOCR internal error", "error")
+                self._log("   Please switch to EasyOCR or manga-ocr", "warning")
+            else:
+                self._log(f"❌ Error in paddleocr detection: {error_msg}", "error")
+            
+            import traceback
+            self._log(traceback.format_exc(), "debug")
+        
+        return results
+    
+    def _parse_ocr_results(self, ocr_results) -> List[OCRResult]:
+        """Parse OCR results safely"""
+        results = []
+        
+        if isinstance(ocr_results, bool) and ocr_results == False:
+            return results
+        
+        if ocr_results is None or not isinstance(ocr_results, list):
+            return results
+        
+        if len(ocr_results) == 0:
+            return results
+        
+        # Handle batch format
+        if isinstance(ocr_results[0], list) and len(ocr_results[0]) > 0:
+            first_item = ocr_results[0][0]
+            if isinstance(first_item, list) and len(first_item) > 0:
+                if isinstance(first_item[0], (list, tuple)) and len(first_item[0]) == 2:
+                    ocr_results = ocr_results[0]
+        
+        # Parse detections
+        for detection in ocr_results:
+            if not detection or isinstance(detection, bool):
+                continue
+            
+            if not isinstance(detection, (list, tuple)) or len(detection) < 2:
+                continue
+            
+            try:
+                bbox_points = detection[0]
+                text_data = detection[1]
+                
+                if not isinstance(bbox_points, (list, tuple)) or len(bbox_points) != 4:
+                    continue
+                
+                if not isinstance(text_data, (tuple, list)) or len(text_data) < 2:
+                    continue
+                
+                text = str(text_data[0]).strip()
+                confidence = float(text_data[1])
+                
+                if not text or confidence < 0.3:
+                    continue
+                
+                xs = [float(p[0]) for p in bbox_points]
+                ys = [float(p[1]) for p in bbox_points]
+                x_min, x_max = min(xs), max(xs)
+                y_min, y_max = min(ys), max(ys)
+                
+                if (x_max - x_min) < 5 or (y_max - y_min) < 5:
+                    continue
+                
+                results.append(OCRResult(
+                    text=text,
+                    bbox=(int(x_min), int(y_min), int(x_max - x_min), int(y_max - y_min)),
+                    confidence=confidence,
+                    vertices=[(int(p[0]), int(p[1])) for p in bbox_points]
+                ))
+                
+            except Exception:
+                continue
+        
+        return results
+
+class DocTROCRProvider(OCRProvider):
+    """DocTR OCR provider"""
+    
+    def check_installation(self) -> bool:
+        """Check if doctr is installed"""
+        try:
+            from doctr.models import ocr_predictor
+            self.is_installed = True
+            return True
+        except ImportError:
+            return False
+    
+    def install(self, progress_callback=None) -> bool:
+        """Install doctr"""
+        pass
+    
+    def load_model(self, **kwargs) -> bool:
+        """Load doctr model"""
+        try:
+            if not self.is_installed and not self.check_installation():
+                self._log("❌ doctr not installed", "error")
+                return False
+            
+            self._log("🔥 Loading DocTR model...")
+            from doctr.models import ocr_predictor
+            
+            # Load pretrained model
+            self.model = ocr_predictor(pretrained=True)
+            self.is_loaded = True
+            
+            self._log("✅ DocTR model loaded successfully")
+            return True
+            
+        except Exception as e:
+            self._log(f"❌ Failed to load doctr: {str(e)}", "error")
+            return False
+    
+    def detect_text(self, image: np.ndarray, **kwargs) -> List[OCRResult]:
+        """Detect text using doctr"""
+        results = []
+        
+        try:
+            if not self.is_loaded:
+                if not self.load_model():
+                    return results
+            
+            from doctr.io import DocumentFile
+            
+            # DocTR expects document format
+            # Convert numpy array to PIL and save temporarily
+            import tempfile
+            import cv2
+            
+            with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
+                cv2.imwrite(tmp.name, image)
+                doc = DocumentFile.from_images(tmp.name)
+            
+            # Run OCR
+            result = self.model(doc)
+            
+            # Parse results
+            h, w = image.shape[:2]
+            for page in result.pages:
+                for block in page.blocks:
+                    for line in block.lines:
+                        for word in line.words:
+                            # Handle different geometry formats
+                            geometry = word.geometry
+                            
+                            if len(geometry) == 4:
+                                # Standard format: (x1, y1, x2, y2)
+                                x1, y1, x2, y2 = geometry
+                            elif len(geometry) == 2:
+                                # Alternative format: ((x1, y1), (x2, y2))
+                                (x1, y1), (x2, y2) = geometry
+                            else:
+                                self._log(f"Unexpected geometry format: {geometry}", "warning")
+                                continue
+                            
+                            # Convert relative coordinates to absolute
+                            x1, x2 = int(x1 * w), int(x2 * w)
+                            y1, y2 = int(y1 * h), int(y2 * h)
+                            
+                            results.append(OCRResult(
+                                text=word.value,
+                                bbox=(x1, y1, x2 - x1, y2 - y1),
+                                confidence=word.confidence,
+                                vertices=[(x1, y1), (x2, y1), (x2, y2), (x1, y2)]
+                            ))
+            
+            # Clean up temp file
+            try:
+                os.unlink(tmp.name)
+            except:
+                pass
+            
+            self._log(f"DocTR detected {len(results)} text regions")
+            
+        except Exception as e:
+            self._log(f"Error in doctr detection: {str(e)}", "error")
+            import traceback
+            self._log(traceback.format_exc(), "error")
+        
+        return results
+
+
+class RapidOCRProvider(OCRProvider):
+    """RapidOCR provider for fast local OCR"""
+    
+    def check_installation(self) -> bool:
+        """Check if rapidocr is installed"""
+        try:
+            import rapidocr_onnxruntime
+            self.is_installed = True
+            return True
+        except ImportError:
+            return False
+    
+    def install(self, progress_callback=None) -> bool:
+        """Install rapidocr (requires manual pip install)"""
+        # RapidOCR requires manual installation
+        if progress_callback:
+            progress_callback("RapidOCR requires manual pip installation")
+        self._log("Run: pip install rapidocr-onnxruntime", "info")
+        return False  # Always return False since we can't auto-install
+    
+    def load_model(self, **kwargs) -> bool:
+        """Load RapidOCR model"""
+        try:
+            if not self.is_installed and not self.check_installation():
+                self._log("RapidOCR not installed", "error")
+                return False
+            
+            self._log("Loading RapidOCR...")
+            from rapidocr_onnxruntime import RapidOCR
+            
+            self.model = RapidOCR()
+            self.is_loaded = True
+            
+            self._log("RapidOCR model loaded successfully")
+            return True
+            
+        except Exception as e:
+            self._log(f"Failed to load RapidOCR: {str(e)}", "error")
+            return False
+    
+    def detect_text(self, image: np.ndarray, **kwargs) -> List[OCRResult]:
+        """Detect text using RapidOCR"""
+        if not self.is_loaded:
+            self._log("RapidOCR model not loaded", "error")
+            return []
+        
+        results = []
+        
+        try:
+            # Convert numpy array to PIL Image for RapidOCR
+            if len(image.shape) == 3:
+                # BGR to RGB
+                image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            else:
+                image_rgb = image
+            
+            # RapidOCR expects PIL Image or numpy array
+            ocr_results, _ = self.model(image_rgb)
+            
+            if ocr_results:
+                for result in ocr_results:
+                    # RapidOCR returns [bbox, text, confidence]
+                    bbox_points = result[0]  # 4 corner points
+                    text = result[1]
+                    confidence = float(result[2])
+                    
+                    if not text or not text.strip():
+                        continue
+                    
+                    # Convert 4-point bbox to x,y,w,h format
+                    xs = [point[0] for point in bbox_points]
+                    ys = [point[1] for point in bbox_points]
+                    x_min, x_max = min(xs), max(xs)
+                    y_min, y_max = min(ys), max(ys)
+                    
+                    results.append(OCRResult(
+                        text=text.strip(),
+                        bbox=(int(x_min), int(y_min), int(x_max - x_min), int(y_max - y_min)),
+                        confidence=confidence,
+                        vertices=[(int(p[0]), int(p[1])) for p in bbox_points]
+                    ))
+            
+            self._log(f"Detected {len(results)} text regions")
+            
+        except Exception as e:
+            self._log(f"Error in RapidOCR detection: {str(e)}", "error")
+        
+        return results
+
+class OCRManager:
+    """Manager for multiple OCR providers"""
+    
+    def __init__(self, log_callback=None):
+        self.log_callback = log_callback
+        self.providers = {
+            'custom-api': CustomAPIProvider(log_callback) ,
+            'manga-ocr': MangaOCRProvider(log_callback),
+            'easyocr': EasyOCRProvider(log_callback),
+            'paddleocr': PaddleOCRProvider(log_callback),
+            'doctr': DocTROCRProvider(log_callback),
+            'rapidocr': RapidOCRProvider(log_callback),
+            'Qwen2-VL': Qwen2VL(log_callback)
+        }
+        self.current_provider = None
+        self.stop_flag = None
+        
+    def get_provider(self, name: str) -> Optional[OCRProvider]:
+        """Get OCR provider by name"""
+        return self.providers.get(name)
+    
+    def set_current_provider(self, name: str):
+        """Set current active provider"""
+        if name in self.providers:
+            self.current_provider = name
+            return True
+        return False
+    
+    def check_provider_status(self, name: str) -> Dict[str, bool]:
+        """Check installation and loading status of provider"""
+        provider = self.providers.get(name)
+        if not provider:
+            return {'installed': False, 'loaded': False}
+        
+        result = {
+            'installed': provider.check_installation(),
+            'loaded': provider.is_loaded
+        }
+        if self.log_callback:
+            self.log_callback(f"DEBUG: check_provider_status({name}) returning loaded={result['loaded']}", "debug")
+        return result
+    
+    def install_provider(self, name: str, progress_callback=None) -> bool:
+        """Install a provider"""
+        provider = self.providers.get(name)
+        if not provider:
+            return False
+        
+        return provider.install(progress_callback)
+    
+    def load_provider(self, name: str, **kwargs) -> bool:
+        """Load a provider's model with optional parameters"""
+        provider = self.providers.get(name)
+        if not provider:
+            return False
+        
+        return provider.load_model(**kwargs)  # <-- Passes model_size and any other kwargs
+    
+    def shutdown(self):
+        """Release models/processors/tokenizers for all providers and clear caches."""
+        try:
+            import gc
+            for name, provider in list(self.providers.items()):
+                try:
+                    if hasattr(provider, 'model'):
+                        provider.model = None
+                    if hasattr(provider, 'processor'):
+                        provider.processor = None
+                    if hasattr(provider, 'tokenizer'):
+                        provider.tokenizer = None
+                    if hasattr(provider, 'reader'):
+                        provider.reader = None
+                    if hasattr(provider, 'is_loaded'):
+                        provider.is_loaded = False
+                except Exception:
+                    pass
+            gc.collect()
+            try:
+                import torch
+                torch.cuda.empty_cache()
+            except Exception:
+                pass
+        except Exception:
+            pass
+
+    def detect_text(self, image: np.ndarray, provider_name: str = None, **kwargs) -> List[OCRResult]:
+        """Detect text using specified or current provider"""
+        provider_name = provider_name or self.current_provider
+        if not provider_name:
+            return []
+        
+        provider = self.providers.get(provider_name)
+        if not provider:
+            return []
+        
+        return provider.detect_text(image, **kwargs)
+    
+    def set_stop_flag(self, stop_flag):
+        """Set stop flag for all providers"""
+        self.stop_flag = stop_flag
+        for provider in self.providers.values():
+            if hasattr(provider, 'set_stop_flag'):
+                provider.set_stop_flag(stop_flag)
+    
+    def reset_stop_flags(self):
+        """Reset stop flags for all providers"""
+        for provider in self.providers.values():
+            if hasattr(provider, 'reset_stop_flags'):
+                provider.reset_stop_flags()

splash_utils.py

@@ -0,0 +1,347 @@
+#splah_utils.py
+import time
+import atexit
+
+class SplashManager:
+    """Simple splash screen manager that works with main thread"""
+    
+    def __init__(self):
+        self.splash_window = None
+        self._status_text = "Initializing..."
+        self.progress_value = 0  # Track actual progress 0-100
+        self.canvas_width = 320  # Progress bar dimensions (increased from 300)
+        self.canvas_height = 36  # Increased from 30
+        self._after_id = None
+        
+    def start_splash(self):
+        """Create splash window on main thread"""
+        try:
+            import tkinter as tk
+            
+            print("🎨 Starting splash screen...")
+            
+            # Create splash window on main thread
+            self.splash_window = tk.Tk()
+            self.splash_window.title("Loading Glossarion...")
+            self.splash_window.geometry("450x350")
+            self.splash_window.configure(bg='#2b2b2b')
+            self.splash_window.resizable(False, False)
+            self.splash_window.overrideredirect(True)
+            
+            # Center the window
+            self.splash_window.update_idletasks()
+            x = (self.splash_window.winfo_screenwidth() // 2) - 225
+            y = (self.splash_window.winfo_screenheight() // 2) - 175
+            self.splash_window.geometry(f"450x350+{x}+{y}")
+            
+            # Add content
+            main_frame = tk.Frame(self.splash_window, bg='#2b2b2b', relief='raised', bd=2)
+            main_frame.pack(fill='both', expand=True, padx=2, pady=2)
+            
+            # Load the actual Halgakos.ico icon
+            self._load_icon(main_frame)
+            
+            # Title
+            title_label = tk.Label(main_frame, text="Glossarion v4.8.5", 
+                                  bg='#2b2b2b', fg='#4a9eff', font=('Arial', 20, 'bold'))
+            title_label.pack(pady=(10, 5))
+            
+            # Subtitle
+            subtitle_label = tk.Label(main_frame, text="Advanced AI Translation Suite", 
+                                     bg='#2b2b2b', fg='#cccccc', font=('Arial', 12))
+            subtitle_label.pack(pady=(0, 15))
+            
+            # Status
+            self.status_label = tk.Label(main_frame, text=self._status_text, 
+                                        bg='#2b2b2b', fg='#ffffff', font=('Arial', 11))
+            self.status_label.pack(pady=(10, 10))
+            
+            # Progress bar container
+            progress_frame = tk.Frame(main_frame, bg='#2b2b2b')
+            progress_frame.pack(pady=(5, 15))  # Adjusted padding for larger bar
+            
+            # Progress bar background
+            self.progress_bg = tk.Canvas(progress_frame, width=self.canvas_width, height=self.canvas_height, 
+                                        bg='#2b2b2b', highlightthickness=0)
+            self.progress_bg.pack()
+            
+            # Create border
+            self.progress_bg.create_rectangle(1, 1, self.canvas_width-1, self.canvas_height-1, 
+                                            outline='#666666', width=2)
+            
+            # Create background
+            self.progress_bg.create_rectangle(3, 3, self.canvas_width-3, self.canvas_height-3, 
+                                            fill='#1a1a1a', outline='')
+            
+            # Progress bar fill (will be updated)
+            self.progress_fill = None
+            
+            # Progress percentage text - moved up and with better font
+            text_x = self.canvas_width // 2  # 160 for 320px width
+            text_y = 13.5  # Positioned slightly above center for visual balance
+            
+            # Use a cleaner, more modern font
+            progress_font = ('Montserrat', 12, 'bold')  # Increased size to 12
+            
+            # Create outline for better readability
+            for dx in [-1, 0, 1]:
+                for dy in [-1, 0, 1]:
+                    if dx != 0 or dy != 0:
+                        self.progress_bg.create_text(text_x + dx, text_y + dy, text="0%", 
+                                                   fill='#000000', font=progress_font,
+                                                   tags="outline", anchor='center')
+            
+            # Main text on top (white)
+            self.progress_text = self.progress_bg.create_text(text_x, text_y, text="0%", 
+                                                             fill='#ffffff', font=progress_font,
+                                                             anchor='center')
+            
+            # Version info
+            version_label = tk.Label(main_frame, text="Starting up...", 
+                                   bg='#2b2b2b', fg='#888888', font=('Arial', 9))
+            version_label.pack(side='bottom', pady=(0, 15))
+            
+            # Start progress animation
+            self._animate_progress()
+            
+            # Update the display
+            self.splash_window.update()
+            
+            # Register cleanup
+            atexit.register(self.close_splash)
+            return True
+            
+        except Exception as e:
+            print(f"⚠️ Could not start splash: {e}")
+            return False
+    
+    def _load_icon(self, parent):
+        """Load the Halgakos.ico icon"""
+        try:
+            # Get icon path - handle both development and packaged modes
+            import os
+            import sys
+            import tkinter as tk
+            
+            if getattr(sys, 'frozen', False):
+                # Running as .exe
+                base_dir = sys._MEIPASS
+            else:
+                # Running as .py files
+                base_dir = os.path.dirname(os.path.abspath(__file__))
+            
+            ico_path = os.path.join(base_dir, 'Halgakos.ico')
+            
+            if os.path.isfile(ico_path):
+                try:
+                    # Try PIL first for better quality
+                    from PIL import Image, ImageTk
+                    pil_image = Image.open(ico_path)
+                    pil_image = pil_image.resize((128, 128), Image.Resampling.LANCZOS)
+                    icon_photo = ImageTk.PhotoImage(pil_image, master=self.splash_window)
+                    icon_label = tk.Label(parent, image=icon_photo, bg='#2b2b2b')
+                    icon_label.image = icon_photo  # Keep reference
+                    icon_label.pack(pady=(20, 10))
+                    return
+                except ImportError:
+                    # Fallback to basic tkinter
+                    try:
+                        icon_image = tk.PhotoImage(file=ico_path)
+                        icon_label = tk.Label(parent, image=icon_image, bg='#2b2b2b')
+                        icon_label.image = icon_image
+                        icon_label.pack(pady=(20, 10))
+                        return
+                    except tk.TclError:
+                        pass
+        except Exception:
+            pass
+        
+        # Fallback emoji if icon loading fails
+        import tkinter as tk
+        icon_frame = tk.Frame(parent, bg='#4a9eff', width=128, height=128)
+        icon_frame.pack(pady=(20, 10))
+        icon_frame.pack_propagate(False)
+        
+        icon_label = tk.Label(icon_frame, text="📚", font=('Arial', 64), 
+                             bg='#4a9eff', fg='white')
+        icon_label.pack(expand=True)
+
+    def _animate_progress(self):
+        """Animate progress bar filling up"""
+        # Cancel any existing after callback first
+        if self._after_id:
+            try:
+                self.splash_window.after_cancel(self._after_id)
+            except:
+                pass
+            self._after_id = None
+            
+        if self.splash_window and self.splash_window.winfo_exists():
+            try:
+                # Auto-increment progress for visual effect during startup
+                if self.progress_value < 100:
+                    # Increment at different rates for different phases
+                    if self.progress_value < 30:
+                        self.progress_value += 8  # Fast initial progress
+                    elif self.progress_value < 70:
+                        self.progress_value += 4  # Medium progress
+                    elif self.progress_value < 90:
+                        self.progress_value += 2  # Slow progress
+                    else:
+                        self.progress_value += 1  # Very slow final progress
+                    
+                    # Cap at 99% until explicitly set to 100%
+                    if self.progress_value >= 99:
+                        self.progress_value = 99
+                
+                # Update progress bar fill
+                if self.progress_fill:
+                    self.progress_bg.delete(self.progress_fill)
+                # Also delete old highlight
+                self.progress_bg.delete("highlight")
+                
+                # Calculate fill width (3 to canvas_width-3)
+                fill_width = int((self.progress_value / 100) * (self.canvas_width - 6))  # -6 for borders
+                if fill_width > 0:
+                    # Create gradient effect
+                    self.progress_fill = self.progress_bg.create_rectangle(
+                        3, 3, 3 + fill_width, self.canvas_height - 3, 
+                        fill='#4a9eff', outline=''
+                    )
+                    
+                    # Add a highlight effect (adjusted for new height)
+                    if fill_width > 10:
+                        self.progress_bg.create_rectangle(
+                            3, 3, min(13, 3 + fill_width), 12,
+                            fill='#6bb6ff', outline='', tags="highlight"
+                        )
+                
+                # Update percentage text without changing position
+                percent_text = f"{self.progress_value}%"
+                
+                # Update main text
+                self.progress_bg.itemconfig(self.progress_text, text=percent_text)
+                
+                # Update all outline layers
+                for item in self.progress_bg.find_withtag("outline"):
+                    self.progress_bg.itemconfig(item, text=percent_text)
+                
+                # Ensure text stays on top of progress fill
+                self.progress_bg.tag_raise("outline")
+                self.progress_bg.tag_raise(self.progress_text)
+
+                # Store the after ID so we can cancel it later
+                self._after_id = self.splash_window.after(100, self._animate_progress)
+                
+            except Exception:
+                self._after_id = None
+                pass
+    
+    def update_status(self, message):
+            """Update splash status and progress with enhanced module loading support"""
+            self._status_text = message
+            try:
+                if self.splash_window and hasattr(self, 'status_label'):
+                    self.status_label.config(text=message)
+                    
+                    # Enhanced progress mapping starting module loading at 10%
+                    progress_map = {
+                        "Loading theme framework...": 5,
+                        "Loading UI framework...": 8,
+                        
+                        # Module loading phase - starts at 10% and goes to 85%
+                        "Loading translation modules...": 10,
+                        "Initializing module system...": 15,
+                        "Loading translation engine...": 20,
+                        "Validating translation engine...": 30,
+                        "✅ translation engine loaded": 40,
+                        "Loading glossary extractor...": 45,
+                        "Validating glossary extractor...": 55,
+                        "✅ glossary extractor loaded": 65,
+                        "Loading EPUB converter...": 70,
+                        "✅ EPUB converter loaded": 75,
+                        "Loading QA scanner...": 78,
+                        "✅ QA scanner loaded": 82,
+                        "Finalizing module initialization...": 85,
+                        "✅ All modules loaded successfully": 88,
+                        
+                        "Creating main window...": 92,
+                        "Ready!": 100
+                    }
+                    
+                    # Check for exact matches first
+                    if message in progress_map:
+                        self.set_progress(progress_map[message])
+                    else:
+                        # Check for partial matches
+                        for key, value in progress_map.items():
+                            if key in message:
+                                self.set_progress(value)
+                                break
+                    
+                    self.splash_window.update()
+            except:
+                pass
+    
+    def set_progress(self, value):
+        """Manually set progress value (0-100)"""
+        self.progress_value = max(0, min(100, value))
+    
+    def close_splash(self):
+            """Close the splash screen with proper text visibility"""
+            try:
+                # IMPORTANT: Cancel the animation first
+                if self._after_id and self.splash_window:
+                    try:
+                        self.splash_window.after_cancel(self._after_id)
+                    except:
+                        pass
+                    self._after_id = None
+                
+                if self.splash_window and self.splash_window.winfo_exists():
+                    # Set to 100% and ensure text is visible
+                    self.progress_value = 100
+                    
+                    # Update display one last time without scheduling another callback
+                    if hasattr(self, 'progress_fill') and self.progress_fill:
+                        self.progress_bg.delete(self.progress_fill)
+                    self.progress_bg.delete("highlight")
+                    
+                    # Create the 100% progress bar (but leave space for text)
+                    fill_width = int((self.progress_value / 100) * (self.canvas_width - 6))
+                    if fill_width > 0:
+                        # Create progress fill that doesn't cover the text area
+                        self.progress_fill = self.progress_bg.create_rectangle(
+                            3, 3, 3 + fill_width, self.canvas_height - 3, 
+                            fill='#4a9eff', outline=''
+                        )
+                        
+                        # Add highlight effect
+                        if fill_width > 10:
+                            self.progress_bg.create_rectangle(
+                                3, 3, min(13, 3 + fill_width), 12,
+                                fill='#6bb6ff', outline='', tags="highlight"
+                            )
+                    
+                    # CRITICAL: Make sure text stays on top and is visible
+                    if hasattr(self, 'progress_text'):
+                        self.progress_bg.itemconfig(self.progress_text, text="100%", fill='#ffffff')
+                    
+                    # Update all outline layers for better visibility
+                    for item in self.progress_bg.find_withtag("outline"):
+                        self.progress_bg.itemconfig(item, text="100%", fill='#000000')
+                    
+                    # Ensure text layers are on top of progress fill
+                    self.progress_bg.tag_raise("outline")
+                    if hasattr(self, 'progress_text'):
+                        self.progress_bg.tag_raise(self.progress_text)
+                    
+                    self.splash_window.update()
+                    time.sleep(0.1)
+                    
+                    self.splash_window.destroy()
+                    self.splash_window = None
+            except:
+                # Ensure cleanup even on error
+                self._after_id = None
+                self.splash_window = None

tqdm_safety.py

@@ -0,0 +1,96 @@
+# tqdm_safety.py
+"""
+A defensive patch for tqdm to prevent AttributeError at interpreter shutdown:
+AttributeError: type object 'tqdm' has no attribute '_lock'
+
+Root cause
+- During interpreter shutdown, module globals/class attributes may be cleared before tqdm.__del__ runs.
+- tqdm.close() calls a class method that uses cls._lock; if it's already deleted, AttributeError is raised.
+
+Fix
+- Ensure a class-level _lock exists and is a threading.RLock().
+- Wrap __del__ and close() to guard against shutdown-time attribute loss.
+- No-ops if core attributes are missing, preserving normal behavior during runtime.
+
+This keeps tqdm enabled and visible; it only avoids the noisy traceback on exit.
+"""
+from __future__ import annotations
+
+import threading
+
+
+def apply_tqdm_safety_patch() -> None:
+    try:
+        import tqdm as _tqdm_mod
+        # Prefer the tqdm.tqdm class
+        tqdm_cls = getattr(_tqdm_mod, 'tqdm', None)
+        if tqdm_cls is None:
+            # Some variants might expose TqdmExperimentalWarning only; bail quietly
+            return
+
+        # Ensure a class-level lock exists
+        if not hasattr(tqdm_cls, '_lock') or getattr(tqdm_cls, '_lock') is None:
+            try:
+                tqdm_cls._lock = threading.RLock()
+            except Exception:
+                # As last resort, set a dummy object with context manager protocol
+                class _DummyLock:
+                    def __enter__(self):
+                        return self
+                    def __exit__(self, exc_type, exc, tb):
+                        return False
+                tqdm_cls._lock = _DummyLock()
+
+        # Patch the class method used during close to guard missing attributes
+        _orig_decr = getattr(tqdm_cls, '_decr_instances', None)
+        if callable(_orig_decr):
+            def _safe_decr_instances(*args, **kwargs):
+                try:
+                    # cls._lock might be gone at shutdown
+                    if not hasattr(tqdm_cls, '_lock') or tqdm_cls._lock is None:
+                        return
+                    return _orig_decr(*args, **kwargs)
+                except Exception:
+                    # Swallow shutdown-time errors only
+                    return
+            try:
+                _safe_decr_instances.__name__ = _orig_decr.__name__
+            except Exception:
+                pass
+            setattr(tqdm_cls, '_decr_instances', staticmethod(_safe_decr_instances))
+
+        # Wrap instance .close() to be defensive
+        _orig_close = getattr(tqdm_cls, 'close', None)
+        if callable(_orig_close):
+            def _safe_close(self, *args, **kwargs):
+                try:
+                    return _orig_close(self, *args, **kwargs)
+                except AttributeError:
+                    # Happens if class attrs are missing at shutdown
+                    return
+                except Exception:
+                    # Avoid raising during shutdown
+                    try:
+                        # Best effort: clear display without relying on internals
+                        fp = getattr(self, 'fp', None)
+                        if fp and hasattr(fp, 'flush'):
+                            fp.flush()
+                    except Exception:
+                        pass
+                    return
+            setattr(tqdm_cls, 'close', _safe_close)
+
+        # Wrap destructor to ignore shutdown-time errors
+        _orig_del = getattr(tqdm_cls, '__del__', None)
+        if callable(_orig_del):
+            def _safe_del(self):
+                try:
+                    _orig_del(self)
+                except Exception:
+                    # Ignore any errors during interpreter shutdown
+                    return
+            setattr(tqdm_cls, '__del__', _safe_del)
+
+    except Exception:
+        # Never let the safety patch break startup
+        return

txt_processor.py

@@ -0,0 +1,304 @@
+# txt_processor.py
+import os
+import re
+import json
+from typing import List, Tuple, Dict
+from bs4 import BeautifulSoup
+from chapter_splitter import ChapterSplitter
+from decimal import Decimal
+import hashlib
+
+class TextFileProcessor:
+    """Process plain text files for translation"""
+    
+    def __init__(self, file_path: str, output_dir: str):
+        self.file_path = file_path
+        self.output_dir = output_dir
+        self.file_base = os.path.splitext(os.path.basename(file_path))[0]
+        
+        # Initialize chapter splitter
+        model_name = os.getenv("MODEL", "gpt-3.5-turbo")
+        self.chapter_splitter = ChapterSplitter(model_name=model_name)
+        
+    def extract_chapters(self) -> List[Dict]:
+        """Extract chapters from text file"""
+        with open(self.file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        # First, detect chapters in the content
+        raw_chapters = self._detect_chapters(content)
+        
+        # Then, process each chapter for splitting if needed
+        final_chapters = self._process_chapters_for_splitting(raw_chapters)
+        
+        print(f"📚 Extracted {len(final_chapters)} total chunks from {len(raw_chapters)} detected chapters")
+        return final_chapters
+    
+    def _detect_chapters(self, content: str) -> List[Dict]:
+        """Detect chapter boundaries in the text"""
+        chapters = []
+        
+        # Chapter detection patterns
+        chapter_patterns = [
+            # English patterns
+            (r'^Chapter\s+(\d+).*$', 'chapter'),
+            (r'^CHAPTER\s+(\d+).*$', 'chapter'),
+            (r'^Ch\.\s*(\d+).*$', 'chapter'),
+            # Numbered sections
+            (r'^(\d+)\.\s+(.*)$', 'numbered'),
+            (r'^Part\s+(\d+).*$', 'part'),
+            # Scene breaks (these don't have numbers)
+            (r'^\*\s*\*\s*\*.*$', 'break'),
+            (r'^---+.*$', 'break'),
+            (r'^===+.*$', 'break'),
+        ]
+        
+        # Find all chapter markers and their positions
+        chapter_breaks = []
+        lines = content.split('\n')
+        
+        for line_num, line in enumerate(lines):
+            for pattern, pattern_type in chapter_patterns:
+                match = re.match(pattern, line.strip())
+                if match:
+                    chapter_breaks.append({
+                        'line_num': line_num,
+                        'line': line,
+                        'type': pattern_type,
+                        'match': match
+                    })
+                    break
+        
+        if not chapter_breaks:
+            # No chapter markers found, treat as single chapter
+            print(f"No chapter markers found in {self.file_base}, treating as single document")
+            # FIX: Use "Section 1" instead of filename to avoid number extraction issues
+            chapters = [{
+                'num': 1,
+                'title': 'Section 1',  # Changed from self.file_base
+                'content': content
+            }]
+        else:
+            # Split content by chapter markers
+            print(f"Found {len(chapter_breaks)} chapter markers in {self.file_base}")
+            
+            for i, chapter_break in enumerate(chapter_breaks):
+                # Determine chapter number and title
+                chapter_num, chapter_title = self._extract_chapter_info(chapter_break, i)
+                
+                # Get content for this chapter
+                start_line = chapter_break['line_num'] + 1  # Start after the chapter marker
+                
+                # Find where this chapter ends
+                if i < len(chapter_breaks) - 1:
+                    end_line = chapter_breaks[i + 1]['line_num']
+                else:
+                    end_line = len(lines)
+                
+                # Extract chapter content
+                chapter_lines = lines[start_line:end_line]
+                chapter_content = '\n'.join(chapter_lines).strip()
+                
+                if chapter_content:  # Only add if there's actual content
+                    chapters.append({
+                        'num': chapter_num,
+                        'title': chapter_title,
+                        'content': chapter_content
+                    })
+        
+        return chapters
+    
+    def _extract_chapter_info(self, chapter_break: Dict, index: int) -> Tuple[int, str]:
+        """Extract chapter number and title from a chapter break"""
+        if chapter_break['type'] == 'break':
+            # Scene breaks don't have numbers
+            chapter_num = index + 1
+            chapter_title = f"Section {chapter_num}"
+        else:
+            # Try to extract number from match
+            match_groups = chapter_break['match'].groups()
+            if match_groups and match_groups[0]:  # Check if group exists AND is not empty
+                try:
+                    # Strip whitespace and check if it's a valid number
+                    num_str = match_groups[0].strip()
+                    if num_str:  # Only try to convert if not empty
+                        chapter_num = int(num_str)
+                        chapter_title = chapter_break['line'].strip()
+                    else:
+                        # Empty match group, use index
+                        chapter_num = index + 1
+                        chapter_title = chapter_break['line'].strip()
+                except (ValueError, IndexError):
+                    # Failed to convert to int, use index
+                    chapter_num = index + 1
+                    chapter_title = chapter_break['line'].strip()
+            else:
+                # No match groups or empty match
+                chapter_num = index + 1
+                chapter_title = chapter_break['line'].strip()
+        
+        return chapter_num, chapter_title
+    
+    def _process_chapters_for_splitting(self, raw_chapters: List[Dict]) -> List[Dict]:
+        """Process chapters and split them if they exceed token limits"""
+        final_chapters = []
+        
+        # Calculate based on OUTPUT token limits
+        max_output_tokens = int(os.getenv("MAX_OUTPUT_TOKENS", "8192"))
+        compression_factor = float(os.getenv("COMPRESSION_FACTOR", "0.8"))
+        safety_margin_output = 500
+        
+        # Calculate chunk size based on output limit
+        available_tokens = int((max_output_tokens - safety_margin_output) / compression_factor)
+        available_tokens = max(available_tokens, 1000)
+        
+        print(f"📊 Text file chunk size: {available_tokens:,} tokens (based on {max_output_tokens:,} output limit, compression: {compression_factor})")
+        
+        for chapter_data in raw_chapters:
+            # Convert chapter content to HTML format
+            chapter_html = self._text_to_html(chapter_data['content'])
+            chapter_tokens = self.chapter_splitter.count_tokens(chapter_html)
+            
+            if chapter_tokens > available_tokens:
+                # Chapter needs splitting
+                print(f"Chapter {chapter_data['num']} ({chapter_data['title']}) has {chapter_tokens} tokens, splitting...")
+                
+                chunks = self.chapter_splitter.split_chapter(chapter_html, available_tokens)
+                
+                # Add each chunk as a separate chapter
+                for chunk_html, chunk_idx, total_chunks in chunks:
+                    chunk_title = chapter_data['title']
+                    if total_chunks > 1:
+                        chunk_title = f"{chapter_data['title']} (Part {chunk_idx}/{total_chunks})"
+                    
+                    # Create float chapter numbers for chunks: 1.0, 1.1, 1.2, etc.
+                    chunk_num = round(chapter_data['num'] + (chunk_idx - 1) * 0.1, 1)
+                    
+                    final_chapters.append({
+                        'num': chunk_num,
+                        'title': chunk_title,
+                        'body': chunk_html,
+                        'filename': f"section_{int(chapter_data['num'])}_part{chunk_idx}.txt",  # Changed to avoid using file_base
+                        'content_hash': self._generate_hash(chunk_html),
+                        'file_size': len(chunk_html),
+                        'has_images': False,
+                        'is_chunk': True,
+                        'chunk_info': {
+                            'chunk_idx': chunk_idx,
+                            'total_chunks': total_chunks,
+                            'original_chapter': chapter_data['num']
+                        }
+                    })
+            else:
+                # Chapter is small enough, add as-is
+                final_chapters.append({
+                    'num': chapter_data['num'],  # Keep as integer for non-split chapters
+                    'title': chapter_data['title'],
+                    'body': chapter_html,
+                    'filename': f"section_{chapter_data['num']}.txt",  # Changed to avoid using file_base
+                    'content_hash': self._generate_hash(chapter_html),
+                    'file_size': len(chapter_html),
+                    'has_images': False,
+                    'is_chunk': False
+                })
+        
+        # Ensure we have at least one chapter
+        if not final_chapters:
+            # Fallback: create a single chapter with all content
+            all_content = '\n\n'.join(ch['content'] for ch in raw_chapters if ch.get('content'))
+            if not all_content and raw_chapters:
+                all_content = raw_chapters[0].get('content', '')
+                
+            final_chapters.append({
+                'num': 1,
+                'title': 'Section 1',  # Changed from self.file_base
+                'body': self._text_to_html(all_content or 'Empty file'),
+                'filename': 'section_1.txt',  # Changed to avoid using file_base
+                'content_hash': self._generate_hash(all_content or ''),
+                'file_size': len(all_content or ''),
+                'has_images': False,
+                'is_chunk': False
+            })
+        
+        return final_chapters
+    
+    def _text_to_html(self, text: str) -> str:
+        """Convert plain text to HTML format"""
+        # Escape HTML characters
+        text = text.replace('&', '&amp;')
+        text = text.replace('<', '&lt;')
+        text = text.replace('>', '&gt;')
+        
+        # Split into paragraphs
+        paragraphs = text.split('\n\n')
+        
+        # Wrap each paragraph in <p> tags
+        html_parts = []
+        for para in paragraphs:
+            para = para.strip()
+            if para:
+                # Check if it's a chapter heading
+                if re.match(r'^(Chapter|CHAPTER|Ch\.|Part)\s+\d+', para):
+                    html_parts.append(f'<h1>{para}</h1>')
+                else:
+                    # Replace single newlines with <br> within paragraphs
+                    para = para.replace('\n', '<br>\n')
+                    html_parts.append(f'<p>{para}</p>')
+        
+        # Create a simple HTML structure
+        html = f"""<html>
+<head>
+    <title>{self.file_base}</title>
+    <meta charset="utf-8"/>
+</head>
+<body>
+    {''.join(html_parts)}
+</body>
+</html>"""
+        
+        return html
+    
+    def _generate_hash(self, content: str) -> str:
+        """Generate hash for content"""
+        return hashlib.md5(content.encode('utf-8')).hexdigest()
+    
+    def save_original_structure(self):
+        """Save original text file structure info"""
+        metadata = {
+            'source_file': os.path.basename(self.file_path),
+            'type': 'text',
+            'encoding': 'utf-8'
+        }
+        
+        metadata_path = os.path.join(self.output_dir, 'metadata.json')
+        with open(metadata_path, 'w', encoding='utf-8') as f:
+            json.dump(metadata, f, ensure_ascii=False, indent=2)
+    
+    def create_output_structure(self, translated_chapters: List[Tuple[str, str]]) -> str:
+        """Create output text file from translated chapters"""
+        # Sort chapters by filename to ensure correct order
+        sorted_chapters = sorted(translated_chapters, key=lambda x: x[0])
+        
+        # Combine all content
+        all_content = []
+        for filename, content in sorted_chapters:
+            # Extract text from HTML
+            soup = BeautifulSoup(content, 'html.parser')
+            text_content = soup.get_text()
+            
+            # Add chapter separator if needed
+            if len(all_content) > 0:
+                all_content.append('\n\n' + '='*50 + '\n\n')
+            
+            all_content.append(text_content)
+        
+        # Create output filename
+        output_filename = f"{self.file_base}_translated.txt"
+        output_path = os.path.join(self.output_dir, output_filename)
+        
+        # Write the translated text
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write(''.join(all_content))
+        
+        print(f"✅ Created translated text file: {output_filename}")
+        return output_path

update_manager.py

@@ -0,0 +1,826 @@
+# update_manager.py - Auto-update functionality for Glossarion
+import os
+import sys
+import json
+import requests
+import threading
+import concurrent.futures
+import time
+import re
+from typing import Optional, Dict, Tuple, List
+from packaging import version
+import tkinter as tk
+from tkinter import ttk, messagebox, font
+import ttkbootstrap as tb
+from datetime import datetime
+
+class UpdateManager:
+    """Handles automatic update checking and installation for Glossarion"""
+    
+    GITHUB_API_URL = "https://api.github.com/repos/Shirochi-stack/Glossarion/releases"
+    GITHUB_LATEST_URL = "https://api.github.com/repos/Shirochi-stack/Glossarion/releases/latest"
+    
+    def __init__(self, main_gui, base_dir):
+        self.main_gui = main_gui
+        self.base_dir = base_dir
+        self.update_available = False
+        # Use shared executor from main GUI if available
+        try:
+            if hasattr(self.main_gui, '_ensure_executor'):
+                self.main_gui._ensure_executor()
+            self.executor = getattr(self.main_gui, 'executor', None)
+        except Exception:
+            self.executor = None
+        self.latest_release = None
+        self.all_releases = []  # Store all fetched releases
+        self.download_progress = 0
+        self.is_downloading = False
+        # Load persistent check time from config
+        self._last_check_time = self.main_gui.config.get('last_update_check_time', 0)
+        self._check_cache_duration = 1800  # Cache for 30 minutes
+        self.selected_asset = None  # Store selected asset for download
+        
+        # Get version from the main GUI's __version__ variable
+        if hasattr(main_gui, '__version__'):
+            self.CURRENT_VERSION = main_gui.__version__
+        else:
+            # Extract from window title as fallback
+            title = self.main_gui.master.title()
+            if 'v' in title:
+                self.CURRENT_VERSION = title.split('v')[-1].strip()
+            else:
+                self.CURRENT_VERSION = "0.0.0"
+    
+    def fetch_multiple_releases(self, count=10) -> List[Dict]:
+        """Fetch multiple releases from GitHub
+        
+        Args:
+            count: Number of releases to fetch
+            
+        Returns:
+            List of release data dictionaries
+        """
+        try:
+            headers = {
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'Glossarion-Updater'
+            }
+            
+            # Fetch multiple releases with retry logic
+            max_retries = 2
+            timeout = 10  # Reduced timeout
+            
+            for attempt in range(max_retries + 1):
+                try:
+                    response = requests.get(
+                        f"{self.GITHUB_API_URL}?per_page={count}", 
+                        headers=headers, 
+                        timeout=timeout
+                    )
+                    response.raise_for_status()
+                    break  # Success
+                except (requests.Timeout, requests.ConnectionError) as e:
+                    if attempt == max_retries:
+                        raise  # Re-raise after final attempt
+                    time.sleep(1)
+            
+            releases = response.json()
+            
+            # Process each release's notes
+            for release in releases:
+                if 'body' in release and release['body']:
+                    # Clean up but don't truncate for history viewing
+                    body = release['body']
+                    # Just clean up excessive newlines
+                    body = re.sub(r'\n{3,}', '\n\n', body)
+                    release['body'] = body
+            
+            return releases
+            
+        except Exception as e:
+            print(f"Error fetching releases: {e}")
+            return []
+    
+    def check_for_updates_async(self, silent=True, force_show=False):
+        """Run check_for_updates in the background using the shared executor.
+        Returns a Future if an executor is available, else runs in a thread.
+        """
+        try:
+            # Ensure shared executor
+            if hasattr(self.main_gui, '_ensure_executor'):
+                self.main_gui._ensure_executor()
+            execu = getattr(self, 'executor', None) or getattr(self.main_gui, 'executor', None)
+            if execu:
+                future = execu.submit(self.check_for_updates, silent, force_show)
+                return future
+        except Exception:
+            pass
+        
+        # Fallback to thread if executor not available
+        def _worker():
+            try:
+                self.check_for_updates(silent=silent, force_show=force_show)
+            except Exception:
+                pass
+        t = threading.Thread(target=_worker, daemon=True)
+        t.start()
+        return None
+
+    def check_for_updates(self, silent=True, force_show=False) -> Tuple[bool, Optional[Dict]]:
+        """Check GitHub for newer releases
+        
+        Args:
+            silent: If True, don't show error messages
+            force_show: If True, show the dialog even when up to date
+            
+        Returns:
+            Tuple of (update_available, release_info)
+        """
+        try:
+            # Check if we need to skip the check due to cache
+            current_time = time.time()
+            if not force_show and (current_time - self._last_check_time) < self._check_cache_duration:
+                print(f"[DEBUG] Skipping update check - cache still valid for {int(self._check_cache_duration - (current_time - self._last_check_time))} seconds")
+                return False, None
+            
+            # Check if this version was previously skipped
+            skipped_versions = self.main_gui.config.get('skipped_versions', [])
+            
+            headers = {
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'Glossarion-Updater'
+            }
+            
+            # Try with shorter timeout and retry logic
+            max_retries = 2
+            timeout = 10  # Reduced from 30 seconds
+            
+            for attempt in range(max_retries + 1):
+                try:
+                    print(f"[DEBUG] Update check attempt {attempt + 1}/{max_retries + 1}")
+                    response = requests.get(self.GITHUB_LATEST_URL, headers=headers, timeout=timeout)
+                    response.raise_for_status()
+                    break  # Success, exit retry loop
+                except (requests.Timeout, requests.ConnectionError) as e:
+                    if attempt == max_retries:
+                        # Last attempt failed, save check time and re-raise
+                        self._save_last_check_time()
+                        raise
+                    print(f"[DEBUG] Network error on attempt {attempt + 1}: {e}")
+                    time.sleep(1)  # Short delay before retry
+            
+            release_data = response.json()
+            latest_version = release_data['tag_name'].lstrip('v')
+            
+            # Save successful check time
+            self._save_last_check_time()
+            
+            # Fetch all releases for history regardless
+            self.all_releases = self.fetch_multiple_releases(count=10)
+            self.latest_release = release_data
+            
+            # Check if this version was skipped by user
+            if release_data['tag_name'] in skipped_versions and not force_show:
+                return False, None
+            
+            # Compare versions
+            if version.parse(latest_version) > version.parse(self.CURRENT_VERSION):
+                self.update_available = True
+                
+                # Show update dialog when update is available
+                print(f"[DEBUG] Showing update dialog for version {latest_version}")
+                self.main_gui.master.after(100, self.show_update_dialog)
+                    
+                return True, release_data
+            else:
+                # We're up to date
+                self.update_available = False
+                
+                # Show dialog if explicitly requested (from menu)
+                if force_show or not silent:
+                    self.main_gui.master.after(100, self.show_update_dialog)
+                
+                return False, None
+                
+        except requests.Timeout:
+            if not silent:
+                messagebox.showerror("Update Check Failed", 
+                                   "Connection timed out while checking for updates.\n\n"
+                                   "This is usually due to network connectivity issues.\n"
+                                   "The next update check will be in 1 hour.")
+            return False, None
+            
+        except requests.ConnectionError as e:
+            if not silent:
+                if 'api.github.com' in str(e):
+                    messagebox.showerror("Update Check Failed", 
+                                       "Cannot reach GitHub servers for update check.\n\n"
+                                       "This may be due to:\n"
+                                       "• Internet connectivity issues\n"
+                                       "• Firewall blocking GitHub API\n"
+                                       "• GitHub API temporarily unavailable\n\n"
+                                       "The next update check will be in 1 hour.")
+                else:
+                    messagebox.showerror("Update Check Failed", 
+                                       f"Network error: {str(e)}\n\n"
+                                       "The next update check will be in 1 hour.")
+            return False, None
+            
+        except requests.HTTPError as e:
+            if not silent:
+                if e.response.status_code == 403:
+                    messagebox.showerror("Update Check Failed", 
+                                       "GitHub API rate limit exceeded. Please try again later.")
+                else:
+                    messagebox.showerror("Update Check Failed", 
+                                       f"GitHub returned error: {e.response.status_code}")
+            return False, None
+            
+        except ValueError as e:
+            if not silent:
+                messagebox.showerror("Update Check Failed", 
+                                   "Invalid response from GitHub. The update service may be temporarily unavailable.")
+            return False, None
+            
+        except Exception as e:
+            if not silent:
+                messagebox.showerror("Update Check Failed", 
+                                   f"An unexpected error occurred:\n{str(e)}")
+            return False, None
+    
+    def check_for_updates_manual(self):
+        """Manual update check from menu - always shows dialog (async)"""
+        return self.check_for_updates_async(silent=False, force_show=True)
+    
+    def _save_last_check_time(self):
+        """Save the last update check time to config"""
+        try:
+            current_time = time.time()
+            self._last_check_time = current_time
+            self.main_gui.config['last_update_check_time'] = current_time
+            # Save config without showing message
+            self.main_gui.save_config(show_message=False)
+        except Exception as e:
+            print(f"[DEBUG] Failed to save last check time: {e}")
+    
+    def format_markdown_to_tkinter(self, text_widget, markdown_text):
+        """Convert GitHub markdown to formatted tkinter text - simplified version
+        
+        Args:
+            text_widget: The Text widget to insert formatted text into
+            markdown_text: The markdown source text
+        """
+        # Configure minimal tags
+        text_widget.tag_config("heading", font=('TkDefaultFont', 12, 'bold'))
+        text_widget.tag_config("bold", font=('TkDefaultFont', 10, 'bold'))
+        
+        # Process text line by line with minimal formatting
+        lines = markdown_text.split('\n')
+        
+        for line in lines:
+            # Strip any weird unicode characters that might cause display issues
+            line = ''.join(char for char in line if ord(char) < 65536)
+            
+            # Handle headings
+            if line.startswith('#'):
+                # Remove all # symbols and get the heading text
+                heading_text = line.lstrip('#').strip()
+                if heading_text:
+                    text_widget.insert('end', heading_text + '\n', 'heading')
+            
+            # Handle bullet points
+            elif line.strip().startswith(('- ', '* ')):
+                # Get the text after the bullet
+                bullet_text = line.strip()[2:].strip()
+                # Clean the text of markdown formatting
+                bullet_text = self._clean_markdown_text(bullet_text)
+                text_widget.insert('end', '    • ' + bullet_text + '\n')
+            
+            # Handle numbered lists  
+            elif re.match(r'^\s*\d+\.\s', line):
+                # Extract number and text
+                match = re.match(r'^(\s*)(\d+)\.\s(.+)', line)
+                if match:
+                    indent, num, text = match.groups()
+                    clean_text = self._clean_markdown_text(text.strip())
+                    text_widget.insert('end', f'    {num}. {clean_text}\n')
+            
+            # Handle separator lines
+            elif line.strip() in ['---', '***', '___']:
+                text_widget.insert('end', '─' * 40 + '\n')
+            
+            # Handle code blocks - just skip the markers
+            elif line.strip().startswith('```'):
+                continue  # Skip code fence markers
+            
+            # Regular text
+            elif line.strip():
+                # Clean and insert the line
+                clean_text = self._clean_markdown_text(line)
+                # Check if this looks like it should be bold (common pattern)
+                if clean_text.endswith(':') and len(clean_text) < 50:
+                    text_widget.insert('end', clean_text + '\n', 'bold')
+                else:
+                    text_widget.insert('end', clean_text + '\n')
+            
+            # Empty lines
+            else:
+                text_widget.insert('end', '\n')
+    
+    def _clean_markdown_text(self, text):
+        """Remove markdown formatting from text
+        
+        Args:
+            text: Text with markdown formatting
+            
+        Returns:
+            Clean text without markdown symbols
+        """
+        # Remove inline code backticks
+        text = re.sub(r'`([^`]+)`', r'\1', text)
+        
+        # Remove bold markers
+        text = re.sub(r'\*\*([^*]+)\*\*', r'\1', text)
+        text = re.sub(r'__([^_]+)__', r'\1', text)
+        
+        # Remove italic markers
+        text = re.sub(r'\*([^*]+)\*', r'\1', text)
+        text = re.sub(r'_([^_]+)_', r'\1', text)
+        
+        # Remove links but keep link text
+        text = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', text)
+        
+        # Remove any remaining special characters that might cause issues
+        text = text.replace('\u200b', '')  # Remove zero-width spaces
+        text = text.replace('\ufeff', '')  # Remove BOM
+        
+        return text.strip()
+    
+    def show_update_dialog(self):
+        """Show update dialog (for updates or version history)"""
+        if not self.latest_release and not self.all_releases:
+            # Try to fetch releases if we don't have them
+            self.all_releases = self.fetch_multiple_releases(count=10)
+            if self.all_releases:
+                self.latest_release = self.all_releases[0]
+            else:
+                messagebox.showerror("Error", "Unable to fetch version information from GitHub.")
+                return
+        
+        # Set appropriate title
+        if self.update_available:
+            title = "Update Available"
+        else:
+            title = "Version History"
+        
+        # Create dialog first without content
+        dialog, scrollable_frame, canvas = self.main_gui.wm.setup_scrollable(
+            self.main_gui.master,
+            title,
+            width=None,
+            height=None,
+            max_width_ratio=0.5,
+            max_height_ratio=0.8
+        )
+        
+        # Show dialog immediately
+        dialog.update_idletasks()
+        
+        # Then populate content
+        self.main_gui.master.after(10, lambda: self._populate_update_dialog(dialog, scrollable_frame, canvas))
+
+    def _populate_update_dialog(self, dialog, scrollable_frame, canvas):
+        """Populate the update dialog content"""
+        # Main container
+        main_frame = ttk.Frame(scrollable_frame)
+        main_frame.pack(fill='both', expand=True, padx=20, pady=20)
+        
+        # Initialize selected_asset to None
+        self.selected_asset = None
+        
+        # Version info
+        version_frame = ttk.LabelFrame(main_frame, text="Version Information", padding=10)
+        version_frame.pack(fill='x', pady=(0, 10))
+        
+        ttk.Label(version_frame, 
+                 text=f"Current Version: {self.CURRENT_VERSION}").pack(anchor='w')
+        
+        if self.latest_release:
+            latest_version = self.latest_release['tag_name']
+            if self.update_available:
+                ttk.Label(version_frame, 
+                         text=f"Latest Version: {latest_version}",
+                         font=('TkDefaultFont', 10, 'bold')).pack(anchor='w')
+            else:
+                ttk.Label(version_frame, 
+                         text=f"Latest Version: {latest_version} ✓ You are up to date!",
+                         foreground='green',
+                         font=('TkDefaultFont', 10, 'bold')).pack(anchor='w')
+        
+        # ALWAYS show asset selection when we have the first release data (current or latest)
+        release_to_check = self.all_releases[0] if self.all_releases else self.latest_release
+        
+        if release_to_check:
+            # Get exe files from the first/latest release
+            exe_assets = [a for a in release_to_check.get('assets', []) 
+                         if a['name'].lower().endswith('.exe')]
+            
+            print(f"[DEBUG] Found {len(exe_assets)} exe files in release {release_to_check.get('tag_name')}")
+            
+            # Show selection UI if there are exe files
+            if exe_assets:
+                # Determine the title based on whether there are multiple variants
+                if len(exe_assets) > 1:
+                    frame_title = "Select Version to Download"
+                else:
+                    frame_title = "Available Download"
+                
+                asset_frame = ttk.LabelFrame(main_frame, text=frame_title, padding=10)
+                asset_frame.pack(fill='x', pady=(0, 10))
+                
+                if len(exe_assets) > 1:
+                    # Multiple exe files - show radio buttons to choose
+                    self.asset_var = tk.StringVar()
+                    for i, asset in enumerate(exe_assets):
+                        filename = asset['name']
+                        size_mb = asset['size'] / (1024 * 1024)
+                        
+                        # Try to identify variant type from filename
+                        if 'full' in filename.lower():
+                            variant_label = f"Full Version - {filename} ({size_mb:.1f} MB)"
+                        else:
+                            variant_label = f"Standard Version - {filename} ({size_mb:.1f} MB)"
+                        
+                        rb = ttk.Radiobutton(asset_frame, text=variant_label, 
+                                            variable=self.asset_var, 
+                                            value=str(i))
+                        rb.pack(anchor='w', pady=2)
+                        
+                        # Select first option by default
+                        if i == 0:
+                            self.asset_var.set(str(i))
+                            self.selected_asset = asset
+                    
+                    # Add listener for selection changes
+                    def on_asset_change(*args):
+                        idx = int(self.asset_var.get())
+                        self.selected_asset = exe_assets[idx]
+                    
+                    self.asset_var.trace_add('write', on_asset_change)
+                else:
+                    # Only one exe file - just show it and set it as selected
+                    self.selected_asset = exe_assets[0]
+                    filename = exe_assets[0]['name']
+                    size_mb = exe_assets[0]['size'] / (1024 * 1024)
+                    ttk.Label(asset_frame, 
+                             text=f"{filename} ({size_mb:.1f} MB)").pack(anchor='w')
+        
+        # Create notebook for version history
+        notebook = ttk.Notebook(main_frame)
+        notebook.pack(fill='both', expand=True, pady=(0, 10))
+        
+        # Add tabs for different versions
+        if self.all_releases:
+            for i, release in enumerate(self.all_releases[:5]):  # Show up to 5 versions
+                version_tag = release['tag_name']
+                version_num = version_tag.lstrip('v')
+                is_current = version_num == self.CURRENT_VERSION
+                is_latest = i == 0
+                
+                # Create tab label
+                tab_label = version_tag
+                if is_current and is_latest:
+                    tab_label += " (Current)"
+                elif is_current:
+                    tab_label += " (Current)"
+                elif is_latest:
+                    tab_label += " (Latest)"
+                
+                # Create frame for this version
+                tab_frame = ttk.Frame(notebook)
+                notebook.add(tab_frame, text=tab_label)
+                
+                # Add release date
+                if 'published_at' in release:
+                    date_str = release['published_at'][:10]  # Get YYYY-MM-DD
+                    date_label = ttk.Label(tab_frame, text=f"Released: {date_str}", 
+                                         font=('TkDefaultFont', 9, 'italic'))
+                    date_label.pack(anchor='w', padx=10, pady=(10, 5))
+                
+                # Create text widget for release notes
+                text_frame = ttk.Frame(tab_frame)
+                text_frame.pack(fill='both', expand=True, padx=10, pady=(0, 10))
+                
+                notes_text = tk.Text(text_frame, height=12, wrap='word', width=60)
+                notes_scroll = ttk.Scrollbar(text_frame, command=notes_text.yview)
+                notes_text.config(yscrollcommand=notes_scroll.set)
+                
+                notes_text.pack(side='left', fill='both', expand=True)
+                notes_scroll.pack(side='right', fill='y')
+                
+                # Format and insert release notes with markdown support
+                release_notes = release.get('body', 'No release notes available')
+                self.format_markdown_to_tkinter(notes_text, release_notes)
+                
+                notes_text.config(state='disabled')  # Make read-only
+                
+                # Don't set background color as it causes rendering artifacts
+        else:
+            # Fallback to simple display if no releases fetched
+            notes_frame = ttk.LabelFrame(main_frame, text="Release Notes", padding=10)
+            notes_frame.pack(fill='both', expand=True, pady=(0, 10))
+            
+            notes_text = tk.Text(notes_frame, height=10, wrap='word')
+            notes_scroll = ttk.Scrollbar(notes_frame, command=notes_text.yview)
+            notes_text.config(yscrollcommand=notes_scroll.set)
+            
+            notes_text.pack(side='left', fill='both', expand=True)
+            notes_scroll.pack(side='right', fill='y')
+            
+            if self.latest_release:
+                release_notes = self.latest_release.get('body', 'No release notes available')
+                self.format_markdown_to_tkinter(notes_text, release_notes)
+            else:
+                notes_text.insert('1.0', 'Unable to fetch release notes.')
+            
+            notes_text.config(state='disabled')
+        
+        # Download progress (initially hidden)
+        self.progress_frame = ttk.Frame(main_frame)
+        self.progress_label = ttk.Label(self.progress_frame, text="Downloading update...")
+        self.progress_label.pack(anchor='w')
+        self.progress_bar = ttk.Progressbar(self.progress_frame, mode='determinate', length=400)
+        self.progress_bar.pack(fill='x', pady=5)
+        
+        # Add status label for download details
+        self.status_label = ttk.Label(self.progress_frame, text="", font=('TkDefaultFont', 8))
+        self.status_label.pack(anchor='w')
+        
+        # Buttons
+        button_frame = ttk.Frame(main_frame)
+        button_frame.pack(fill='x', pady=(10, 0))
+        
+        def start_download():
+            if not self.selected_asset:
+                messagebox.showerror("No File Selected", 
+                                   "Please select a version to download.")
+                return
+                
+            self.progress_frame.pack(fill='x', pady=(0, 10), before=button_frame)
+            download_btn.config(state='disabled')
+            if 'remind_btn' in locals():
+                remind_btn.config(state='disabled')
+            if 'skip_btn' in locals():
+                skip_btn.config(state='disabled')
+            if 'close_btn' in locals():
+                close_btn.config(state='disabled')
+            
+            # Reset progress
+            self.progress_bar['value'] = 0
+            self.download_progress = 0
+            
+            # Start download using shared executor if available
+            try:
+                if hasattr(self.main_gui, '_ensure_executor'):
+                    self.main_gui._ensure_executor()
+                execu = getattr(self, 'executor', None) or getattr(self.main_gui, 'executor', None)
+                if execu:
+                    execu.submit(self.download_update, dialog)
+                else:
+                    thread = threading.Thread(target=self.download_update, args=(dialog,), daemon=True)
+                    thread.start()
+            except Exception:
+                thread = threading.Thread(target=self.download_update, args=(dialog,), daemon=True)
+                thread.start()
+        
+        # Always show download button if we have exe files
+        has_exe_files = self.selected_asset is not None
+        
+        if self.update_available:
+            # Show update-specific buttons
+            download_btn = tb.Button(button_frame, text="Download Update", 
+                                   command=start_download, bootstyle="success")
+            download_btn.pack(side='left', padx=(0, 5))
+            
+            remind_btn = tb.Button(button_frame, text="Remind Me Later", 
+                                 command=dialog.destroy, bootstyle="secondary")
+            remind_btn.pack(side='left', padx=5)
+            
+            skip_btn = tb.Button(button_frame, text="Skip This Version", 
+                               command=lambda: self.skip_version(dialog), 
+                               bootstyle="link")
+            skip_btn.pack(side='left', padx=5)
+        elif has_exe_files:
+            # We're up to date but have downloadable files
+            # Check if there are multiple exe files
+            release_to_check = self.all_releases[0] if self.all_releases else self.latest_release
+            exe_count = 0
+            if release_to_check:
+                exe_count = len([a for a in release_to_check.get('assets', []) 
+                               if a['name'].lower().endswith('.exe')])
+            
+            if exe_count > 1:
+                # Multiple versions available
+                download_btn = tb.Button(button_frame, text="Download Different Path", 
+                                       command=start_download, bootstyle="info")
+            else:
+                # Single version available
+                download_btn = tb.Button(button_frame, text="Re-download", 
+                                       command=start_download, bootstyle="secondary")
+            download_btn.pack(side='left', padx=(0, 5))
+            
+            close_btn = tb.Button(button_frame, text="Close", 
+                                command=dialog.destroy, 
+                                bootstyle="secondary")
+            close_btn.pack(side='left', padx=(0, 5))
+        else:
+            # No downloadable files
+            close_btn = tb.Button(button_frame, text="Close", 
+                                command=dialog.destroy, 
+                                bootstyle="primary")
+            close_btn.pack(side='left', padx=(0, 5))
+        
+        # Add "View All Releases" link button
+        def open_releases_page():
+            import webbrowser
+            webbrowser.open("https://github.com/Shirochi-stack/Glossarion/releases")
+        
+        tb.Button(button_frame, text="View All Releases", 
+                 command=open_releases_page, 
+                 bootstyle="link").pack(side='right', padx=5)
+        
+        # Auto-resize at the end
+        dialog.after(100, lambda: self.main_gui.wm.auto_resize_dialog(dialog, canvas, max_width_ratio=0.5, max_height_ratio=0.8))
+    
+        # Handle window close
+        dialog.protocol("WM_DELETE_WINDOW", lambda: [dialog._cleanup_scrolling(), dialog.destroy()])
+    
+    def skip_version(self, dialog):
+        """Mark this version as skipped and close dialog"""
+        if not self.latest_release:
+            dialog.destroy()
+            return
+        
+        # Get current skipped versions list
+        if 'skipped_versions' not in self.main_gui.config:
+            self.main_gui.config['skipped_versions'] = []
+        
+        # Add this version to skipped list
+        version_tag = self.latest_release['tag_name']
+        if version_tag not in self.main_gui.config['skipped_versions']:
+            self.main_gui.config['skipped_versions'].append(version_tag)
+        
+        # Save config
+        self.main_gui.save_config(show_message=False)
+        
+        # Close dialog
+        dialog.destroy()
+        
+        # Show confirmation
+        messagebox.showinfo("Version Skipped", 
+                          f"Version {version_tag} will be skipped in future update checks.\n"
+                          "You can manually check for updates from the Help menu.")
+    
+    def download_update(self, dialog):
+        """Download the update file"""
+        try:
+            # Use the selected asset
+            asset = self.selected_asset
+                    
+            if not asset:
+                dialog.after(0, lambda: messagebox.showerror("Download Error", 
+                                                           "No file selected for download."))
+                return
+            
+            # Get the current executable path
+            if getattr(sys, 'frozen', False):
+                # Running as compiled executable
+                current_exe = sys.executable
+                download_dir = os.path.dirname(current_exe)
+            else:
+                # Running as script
+                current_exe = None
+                download_dir = self.base_dir
+            
+            # Use the exact filename from GitHub
+            original_filename = asset['name']  # e.g., "Glossarion v3.1.3.exe"
+            new_exe_path = os.path.join(download_dir, original_filename)
+            
+            # If new file would overwrite current executable, download to temp name first
+            if current_exe and os.path.normpath(new_exe_path) == os.path.normpath(current_exe):
+                temp_path = new_exe_path + ".new"
+                download_path = temp_path
+            else:
+                download_path = new_exe_path
+            
+            # Download with progress tracking and shorter timeout
+            response = requests.get(asset['browser_download_url'], stream=True, timeout=15)
+            total_size = int(response.headers.get('content-length', 0))
+            
+            downloaded = 0
+            chunk_size = 8192
+            
+            with open(download_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=chunk_size):
+                    if chunk:
+                        f.write(chunk)
+                        downloaded += len(chunk)
+                        
+                        # Update progress bar
+                        if total_size > 0:
+                            progress = int((downloaded / total_size) * 100)
+                            size_mb = downloaded / (1024 * 1024)
+                            total_mb = total_size / (1024 * 1024)
+                            
+                            # Use after_idle for smoother updates
+                            def update_progress(p=progress, d=size_mb, t=total_mb):
+                                try:
+                                    self.progress_bar['value'] = p
+                                    self.progress_label.config(text=f"Downloading update... {p}%")
+                                    self.status_label.config(text=f"{d:.1f} MB / {t:.1f} MB")
+                                except:
+                                    pass  # Dialog might have been closed
+                            
+                            dialog.after_idle(update_progress)
+            
+            # Download complete
+            dialog.after(0, lambda: self.download_complete(dialog, download_path))
+            
+        except Exception as e:
+            # Capture the error message immediately
+            error_msg = str(e)
+            dialog.after(0, lambda: messagebox.showerror("Download Failed", error_msg))
+    
+    def download_complete(self, dialog, file_path):
+        """Handle completed download"""
+        dialog.destroy()
+        
+        result = messagebox.askyesno(
+            "Download Complete",
+            "Update downloaded successfully.\n\n"
+            "Would you like to install it now?\n"
+            "(The application will need to restart)"
+        )
+        
+        if result:
+            self.install_update(file_path)
+    
+    def install_update(self, update_file):
+        """Launch the update installer and exit current app"""
+        try:
+            # Save current state/config if needed
+            self.main_gui.save_config(show_message=False)
+            
+            # Get current executable path
+            if getattr(sys, 'frozen', False):
+                current_exe = sys.executable
+                current_dir = os.path.dirname(current_exe)
+                
+                # Create a batch file to handle the update
+                batch_content = f"""@echo off
+echo Updating Glossarion...
+echo Waiting for current version to close...
+timeout /t 3 /nobreak > nul
+
+:: Delete the old executable
+echo Deleting old version...
+if exist "{current_exe}" (
+    del /f /q "{current_exe}"
+    if exist "{current_exe}" (
+        echo Failed to delete old version, retrying...
+        timeout /t 2 /nobreak > nul
+        del /f /q "{current_exe}"
+    )
+)
+
+:: Start the new version
+echo Starting new version...
+start "" "{update_file}"
+
+:: Clean up this batch file
+del "%~f0"
+"""
+                batch_path = os.path.join(current_dir, "update_glossarion.bat")
+                with open(batch_path, 'w') as f:
+                    f.write(batch_content)
+                
+                # Run the batch file
+                import subprocess
+                subprocess.Popen([batch_path], shell=True, creationflags=subprocess.CREATE_NO_WINDOW)
+                
+                print(f"[DEBUG] Update batch file created: {batch_path}")
+                print(f"[DEBUG] Will delete: {current_exe}")
+                print(f"[DEBUG] Will start: {update_file}")
+            else:
+                # Running as script, just start the new exe
+                import subprocess
+                subprocess.Popen([update_file], shell=True)
+            
+            # Exit current application
+            print("[DEBUG] Closing application for update...")
+            self.main_gui.master.quit()
+            sys.exit(0)
+            
+        except Exception as e:
+            messagebox.showerror("Installation Error", 
+                               f"Could not start update process:\n{str(e)}")

wait_and_open.ps1

@@ -0,0 +1,31 @@
+# Wait for Gradio server to be ready and then open browser
+param(
+    [string]$url = "http://127.0.0.1:7860",
+    [int]$maxWaitSeconds = 60
+)
+
+Write-Host "Waiting for server to be ready at $url..." -ForegroundColor Cyan
+
+$startTime = Get-Date
+$ready = $false
+
+while (-not $ready -and ((Get-Date) - $startTime).TotalSeconds -lt $maxWaitSeconds) {
+    try {
+        $response = Invoke-WebRequest -Uri $url -Method Head -TimeoutSec 2 -UseBasicParsing -ErrorAction SilentlyContinue
+        if ($response.StatusCode -eq 200) {
+            $ready = $true
+            Write-Host "Server is ready!" -ForegroundColor Green
+        }
+    }
+    catch {
+        # Server not ready yet, wait a bit
+        Start-Sleep -Milliseconds 500
+    }
+}
+
+if ($ready) {
+    Write-Host "Opening browser..." -ForegroundColor Green
+    Start-Process $url
+} else {
+    Write-Host "Timeout waiting for server. Please open $url manually." -ForegroundColor Yellow
+}