Update code_processing.py

code_processing.py

@@ -1,907 +1,696 @@
-"""
-Advanced UI components and interface management for the AnyCoder application.
-"""
-
-import os
-import gradio as gr
-import uuid
-import webbrowser
-import urllib.parse
-from typing import Dict, List, Optional, Tuple, Any, Union
+import re
+import base64
+import json
+from typing import Dict, List, Optional, Tuple, Union
 from pathlib import Path
 
-from config import (
-    THEME_CONFIGS, DEMO_LIST, AVAILABLE_MODELS, DEFAULT_MODEL, DEFAULT_MODEL_NAME,
-    get_saved_theme, save_theme_preference, get_gradio_language
-)
-from utils import extract_text_from_file, process_image_for_model
-from web_utils import check_hf_space_url, parse_repo_or_model_url
-from code_processing import (
-    parse_transformers_js_output, format_transformers_js_output,
-    parse_svelte_output, format_svelte_output,
-    parse_multipage_html_output, format_multipage_output, validate_and_autofix_files,
-    inline_multipage_into_single_preview
-)
+from utils import apply_search_replace_changes, validate_video_html
+from media_generation import generate_image_with_qwen, generate_image_to_image, generate_video_from_image, generate_video_from_text, generate_music_from_text
+from config import SEARCH_START, DIVIDER, REPLACE_END
 
-class AdvancedUIManager:
-    """Manages advanced UI components and interactions"""
-    
-    def __init__(self):
-        self.current_theme = get_saved_theme()
-        self.demo_categories = self._organize_demos_by_category()
-        self.model_categories = self._organize_models_by_category()
-    
-    def _organize_demos_by_category(self) -> Dict[str, List[Dict]]:
-        """Organize demo examples by category for better UI"""
-        categories = {}
-        for demo in DEMO_LIST:
-            category = demo.get('category', 'General')
-            if category not in categories:
-                categories[category] = []
-            categories[category].append(demo)
-        return categories
+class CodeProcessor:
+    """Handles processing and transformation of various code formats"""
     
-    def _organize_models_by_category(self) -> Dict[str, List[Dict]]:
-        """Organize models by category for advanced selection UI"""
-        categories = {}
-        for model in AVAILABLE_MODELS:
-            category = model.get('category', 'General')
-            if category not in categories:
-                categories[category] = []
-            categories[category].append(model)
-        return categories
+    @staticmethod
+    def is_streamlit_code(code: str) -> bool:
+        """Check if Python code is a Streamlit app"""
+        if not code:
+            return False
+        lowered = code.lower()
+        return ("import streamlit" in lowered) or ("from streamlit" in lowered) or ("st." in code and "streamlit" in lowered)
     
-    def create_advanced_model_selector(self) -> gr.Group:
-        """Create an advanced model selector with categories and features"""
-        with gr.Group() as model_group:
-            gr.Markdown("### 🤖 AI Model Selection", elem_classes=["model-header"])
-            
-            with gr.Accordion("Model Categories", open=False, elem_classes=["model-accordion"]):
-                model_tabs = gr.Tabs()
-                
-                with model_tabs:
-                    for category, models in self.model_categories.items():
-                        with gr.Tab(category, elem_classes=["model-tab"]):
-                            for model in models:
-                                vision_icon = "👁️" if model.get('supports_vision', False) else ""
-                                model_btn = gr.Button(
-                                    f"{vision_icon} {model['name']}",
-                                    variant="secondary",
-                                    elem_classes=["model-button"],
-                                    size="sm"
-                                )
-                                gr.Markdown(
-                                    f"*{model['description']}*",
-                                    elem_classes=["model-description"]
-                                )
-            
-            model_dropdown = gr.Dropdown(
-                choices=[model['name'] for model in AVAILABLE_MODELS],
-                value=DEFAULT_MODEL_NAME,
-                label="Selected Model",
-                elem_classes=["model-dropdown"],
-                container=True,
-                scale=2
-            )
-            
-            with gr.Row():
-                model_info_btn = gr.Button("ℹ️", size="sm", elem_classes=["info-button"])
-                model_refresh_btn = gr.Button("🔄", size="sm", elem_classes=["refresh-button"])
-        
-        return model_group, model_dropdown, model_info_btn, model_refresh_btn
+    @staticmethod
+    def is_gradio_code(code: str) -> bool:
+        """Check if Python code is a Gradio app"""
+        if not code:
+            return False
+        lowered = code.lower()
+        return (
+            "import gradio" in lowered or
+            "from gradio" in lowered or
+            "gr.Interface(" in code or
+            "gr.Blocks(" in code
+        )
     
-    def create_advanced_demo_gallery(self) -> gr.Group:
-        """Create an advanced demo gallery with categories and search"""
-        with gr.Group() as demo_group:
-            gr.Markdown("### 🎯 Project Templates", elem_classes=["demo-header"])
-            
-            demo_search = gr.Textbox(
-                placeholder="Search templates...",
-                label="",
-                elem_classes=["demo-search"],
-                container=False
-            )
-            
-            demo_filter = gr.Dropdown(
-                choices=["All Categories"] + list(self.demo_categories.keys()),
-                value="All Categories",
-                label="Category Filter",
-                elem_classes=["demo-filter"]
-            )
-            
-            with gr.Group(elem_classes=["demo-gallery"]):
-                demo_cards = []
-                for category, demos in self.demo_categories.items():
-                    with gr.Group(visible=True, elem_classes=[f"demo-category-{category.lower().replace(' ', '-')}"]):
-                        gr.Markdown(f"#### {category}", elem_classes=["category-header"])
-                        
-                        with gr.Row():
-                            for demo in demos:
-                                complexity_color = {
-                                    "Beginner": "success",
-                                    "Intermediate": "secondary", 
-                                    "Advanced": "stop"
-                                }.get(demo.get('complexity', 'Intermediate'), 'secondary')
-                                
-                                demo_card = gr.Button(
-                                    f"**{demo['title']}**\n{demo['description'][:100]}...",
-                                    variant=complexity_color,
-                                    elem_classes=["demo-card"],
-                                    size="lg"
-                                )
-                                demo_cards.append((demo_card, demo))
-        
-        return demo_group, demo_cards, demo_search, demo_filter
+    @staticmethod
+    def extract_html_document(text: str) -> str:
+        """Extract HTML document from text, ignoring planning notes"""
+        if not text:
+            return text
+        lower = text.lower()
+        idx = lower.find("<!doctype html")
+        if idx == -1:
+            idx = lower.find("<html")
+        return text[idx:] if idx != -1 else text
+
+class TransformersJSProcessor:
+    """Handles Transformers.js specific code processing"""
     
-    def create_advanced_media_controls(self) -> gr.Group:
-        """Create advanced media generation controls with smart layouts"""
-        with gr.Group() as media_group:
-            gr.Markdown("### 🎨 AI Media Generation", elem_classes=["media-header"])
-            
-            with gr.Accordion("Media Options", open=False, elem_classes=["media-accordion"]):
-                with gr.Tabs() as media_tabs:
-                    # Text to Image Tab
-                    with gr.Tab("🖼️ Text → Image", elem_classes=["media-tab"]):
-                        text_to_image_toggle = gr.Checkbox(
-                            label="Generate Images from Text",
-                            value=False,
-                            elem_classes=["media-toggle"]
-                        )
-                        text_to_image_prompt = gr.Textbox(
-                            label="Image Description",
-                            placeholder="A modern, minimalist dashboard with clean lines and soft colors",
-                            lines=2,
-                            visible=False,
-                            elem_classes=["media-prompt"]
-                        )
-                        
-                        with gr.Row(visible=False) as t2i_advanced:
-                            t2i_style = gr.Dropdown(
-                                choices=["Photorealistic", "Illustration", "Digital Art", "Sketch", "Abstract"],
-                                value="Digital Art",
-                                label="Style"
-                            )
-                            t2i_quality = gr.Slider(
-                                minimum=0.5,
-                                maximum=1.0,
-                                value=0.9,
-                                step=0.1,
-                                label="Quality"
-                            )
-                    
-                    # Image to Image Tab
-                    with gr.Tab("🎭 Image → Image", elem_classes=["media-tab"]):
-                        image_to_image_toggle = gr.Checkbox(
-                            label="Transform Uploaded Images",
-                            value=False,
-                            elem_classes=["media-toggle"]
-                        )
-                        generation_image_input = gr.Image(
-                            label="Source Image",
-                            visible=False,
-                            elem_classes=["media-image"]
-                        )
-                        image_to_image_prompt = gr.Textbox(
-                            label="Transformation Description",
-                            placeholder="Transform this into a futuristic version",
-                            lines=2,
-                            visible=False,
-                            elem_classes=["media-prompt"]
-                        )
-                    
-                    # Image to Video Tab  
-                    with gr.Tab("🎬 Image → Video", elem_classes=["media-tab"]):
-                        image_to_video_toggle = gr.Checkbox(
-                            label="Generate Video from Image",
-                            value=False,
-                            elem_classes=["media-toggle"]
-                        )
-                        image_to_video_prompt = gr.Textbox(
-                            label="Motion Description",
-                            placeholder="The person starts walking forward with a confident stride",
-                            lines=2,
-                            visible=False,
-                            elem_classes=["media-prompt"]
-                        )
-                    
-                    # Text to Video Tab
-                    with gr.Tab("📹 Text → Video", elem_classes=["media-tab"]):
-                        text_to_video_toggle = gr.Checkbox(
-                            label="Generate Video from Text",
-                            value=False,
-                            elem_classes=["media-toggle"]
-                        )
-                        text_to_video_prompt = gr.Textbox(
-                            label="Video Description",
-                            placeholder="A time-lapse of a city skyline transitioning from day to night",
-                            lines=2,
-                            visible=False,
-                            elem_classes=["media-prompt"]
-                        )
-                    
-                    # Text to Music Tab
-                    with gr.Tab("🎵 Text → Music", elem_classes=["media-tab"]):
-                        text_to_music_toggle = gr.Checkbox(
-                            label="Generate Background Music",
-                            value=False,
-                            elem_classes=["media-toggle"]
-                        )
-                        text_to_music_prompt = gr.Textbox(
-                            label="Music Description",
-                            placeholder="Upbeat electronic background music for a tech demo",
-                            lines=2,
-                            visible=False,
-                            elem_classes=["media-prompt"]
-                        )
-                        
-                        with gr.Row(visible=False) as music_controls:
-                            music_duration = gr.Slider(
-                                minimum=10,
-                                maximum=120,
-                                value=30,
-                                step=5,
-                                label="Duration (seconds)"
-                            )
-                            music_style = gr.Dropdown(
-                                choices=["Electronic", "Orchestral", "Ambient", "Upbeat", "Cinematic"],
-                                value="Electronic",
-                                label="Style"
-                            )
-        
-        # Create visibility toggle handlers
-        media_components = {
-            'text_to_image_toggle': text_to_image_toggle,
-            'text_to_image_prompt': text_to_image_prompt,
-            't2i_advanced': t2i_advanced,
-            'image_to_image_toggle': image_to_image_toggle,
-            'generation_image_input': generation_image_input,
-            'image_to_image_prompt': image_to_image_prompt,
-            'image_to_video_toggle': image_to_video_toggle,
-            'image_to_video_prompt': image_to_video_prompt,
-            'text_to_video_toggle': text_to_video_toggle,
-            'text_to_video_prompt': text_to_video_prompt,
-            'text_to_music_toggle': text_to_music_toggle,
-            'text_to_music_prompt': text_to_music_prompt,
-            'music_controls': music_controls,
+    @staticmethod
+    def parse_transformers_js_output(text: str) -> Dict[str, str]:
+        """Parse transformers.js output and extract the three files"""
+        files = {
+            'index.html': '',
+            'index.js': '',
+            'style.css': ''
         }
         
-        return media_group, media_components
-    
-    def create_advanced_code_editor(self) -> gr.Group:
-        """Create advanced code editor with multi-file support and intelligent features"""
-        with gr.Group() as editor_group:
-            gr.Markdown("### 💻 Generated Code", elem_classes=["editor-header"])
-            
-            with gr.Row():
-                with gr.Column(scale=3):
-                    # Main code editor
-                    code_output = gr.Code(
-                        language="html",
-                        lines=25,
-                        interactive=True,
-                        label="Generated Code",
-                        elem_classes=["main-editor"]
-                    )
-                    
-                    # Multi-file editors (initially hidden)
-                    with gr.Group(visible=False, elem_classes=["multi-file-group"]) as transformers_group:
-                        gr.Markdown("#### Transformers.js Files")
-                        with gr.Tabs():
-                            with gr.Tab("index.html"):
-                                tjs_html_code = gr.Code(language="html", lines=20, interactive=True)
-                            with gr.Tab("index.js"):
-                                tjs_js_code = gr.Code(language="javascript", lines=20, interactive=True)
-                            with gr.Tab("style.css"):
-                                tjs_css_code = gr.Code(language="css", lines=20, interactive=True)
-                    
-                    with gr.Group(visible=False, elem_classes=["multi-file-group"]) as svelte_group:
-                        gr.Markdown("#### Svelte Files")
-                        with gr.Tabs():
-                            with gr.Tab("App.svelte"):
-                                svelte_app_code = gr.Code(language="javascript", lines=20, interactive=True)
-                            with gr.Tab("app.css"):
-                                svelte_css_code = gr.Code(language="css", lines=20, interactive=True)
-                
-                with gr.Column(scale=1, elem_classes=["editor-sidebar"]):
-                    # Code actions
-                    with gr.Group(elem_classes=["code-actions"]):
-                        gr.Markdown("**Actions**")
-                        
-                        code_format_btn = gr.Button("🎨 Format Code", size="sm")
-                        code_download_btn = gr.Button("💾 Download", size="sm")
-                        code_share_btn = gr.Button("🔗 Share", size="sm")
-                        code_deploy_btn = gr.Button("🚀 Deploy", size="sm", variant="primary")
-                    
-                    # Code statistics
-                    with gr.Group(elem_classes=["code-stats"]):
-                        gr.Markdown("**Statistics**")
-                        code_stats = gr.JSON(
-                            value={"lines": 0, "characters": 0, "files": 1},
-                            label="",
-                            elem_classes=["stats-display"]
-                        )
-        
-        editor_components = {
-            'code_output': code_output,
-            'transformers_group': transformers_group,
-            'tjs_html_code': tjs_html_code,
-            'tjs_js_code': tjs_js_code,
-            'tjs_css_code': tjs_css_code,
-            'svelte_group': svelte_group,
-            'svelte_app_code': svelte_app_code,
-            'svelte_css_code': svelte_css_code,
-            'code_format_btn': code_format_btn,
-            'code_download_btn': code_download_btn,
-            'code_share_btn': code_share_btn,
-            'code_deploy_btn': code_deploy_btn,
-            'code_stats': code_stats
-        }
+        if not text:
+            return files
+        
+        # Multiple patterns for different code block variations
+        html_patterns = [
+            r'```html\s*\n([\s\S]*?)(?:```|\Z)',
+            r'```htm\s*\n([\s\S]*?)(?:```|\Z)',
+            r'```\s*(?:index\.html|html)\s*\n([\s\S]*?)(?:```|\Z)'
+        ]
+        
+        js_patterns = [
+            r'```javascript\s*\n([\s\S]*?)(?:```|\Z)',
+            r'```js\s*\n([\s\S]*?)(?:```|\Z)',
+            r'```\s*(?:index\.js|javascript|js)\s*\n([\s\S]*?)(?:```|\Z)'
+        ]
+        
+        css_patterns = [
+            r'```css\s*\n([\s\S]*?)(?:```|\Z)',
+            r'```\s*(?:style\.css|css)\s*\n([\s\S]*?)(?:```|\Z)'
+        ]
+        
+        # Extract content using patterns
+        for pattern in html_patterns:
+            html_match = re.search(pattern, text, re.IGNORECASE)
+            if html_match:
+                files['index.html'] = html_match.group(1).strip()
+                break
+        
+        for pattern in js_patterns:
+            js_match = re.search(pattern, text, re.IGNORECASE)
+            if js_match:
+                files['index.js'] = js_match.group(1).strip()
+                break
+        
+        for pattern in css_patterns:
+            css_match = re.search(pattern, text, re.IGNORECASE)
+            if css_match:
+                files['style.css'] = css_match.group(1).strip()
+                break
+        
+        # Fallback: support === filename === format
+        if not (files['index.html'] and files['index.js'] and files['style.css']):
+            fallback_files = MultipageProcessor.parse_multipage_html_output(text)
+            for key in files.keys():
+                if key in fallback_files:
+                    files[key] = fallback_files[key]
         
-        return editor_group, editor_components
+        return files
     
-    def create_advanced_preview_panel(self) -> gr.Group:
-        """Create advanced preview panel with multiple view modes"""
-        with gr.Group() as preview_group:
-            gr.Markdown("### 👁️ Live Preview", elem_classes=["preview-header"])
-            
-            with gr.Row():
-                preview_mode = gr.Radio(
-                    choices=["Desktop", "Tablet", "Mobile"],
-                    value="Desktop",
-                    label="View Mode",
-                    elem_classes=["preview-mode"]
-                )
-                
-                preview_refresh_btn = gr.Button("🔄", size="sm", elem_classes=["preview-refresh"])
-                preview_fullscreen_btn = gr.Button("⛶", size="sm", elem_classes=["preview-fullscreen"])
-                preview_qr_btn = gr.Button("📱", size="sm", elem_classes=["preview-qr"])
-            
-            # Main preview area
-            sandbox = gr.HTML(
-                label="Live Preview",
-                elem_classes=["preview-sandbox"]
-            )
-            
-            # Preview status bar
-            with gr.Row(elem_classes=["preview-status"]):
-                preview_status = gr.Markdown("Ready", elem_classes=["status-text"])
-                preview_metrics = gr.JSON(
-                    value={"load_time": "0ms", "size": "0KB", "elements": 0},
-                    label="",
-                    elem_classes=["preview-metrics"]
-                )
-        
-        preview_components = {
-            'sandbox': sandbox,
-            'preview_mode': preview_mode,
-            'preview_refresh_btn': preview_refresh_btn,
-            'preview_fullscreen_btn': preview_fullscreen_btn,
-            'preview_qr_btn': preview_qr_btn,
-            'preview_status': preview_status,
-            'preview_metrics': preview_metrics
-        }
-        
-        return preview_group, preview_components
+    @staticmethod
+    def format_transformers_js_output(files: Dict[str, str]) -> str:
+        """Format the three files into a single display string"""
+        output = []
+        output.append("=== index.html ===")
+        output.append(files.get('index.html', ''))
+        output.append("\n=== index.js ===")
+        output.append(files.get('index.js', ''))
+        output.append("\n=== style.css ===")
+        output.append(files.get('style.css', ''))
+        return '\n'.join(output)
     
-    def create_chat_interface(self) -> gr.Group:
-        """Create advanced chat-based interface for beta mode"""
-        with gr.Group() as chat_group:
-            gr.Markdown("### 💬 AI Assistant Chat", elem_classes=["chat-header"])
-            
-            # Main chat area
-            chatbot = gr.Chatbot(
-                type="messages",
-                show_label=False,
-                height=400,
-                layout="bubble",
-                bubble_full_width=False,
-                group_consecutive_messages=True,
-                elem_classes=["main-chatbot"],
-                avatar_images=("🧑‍💻", "🤖")
+    @staticmethod
+    def build_transformers_inline_html(files: Dict[str, str]) -> str:
+        """Merge transformers.js files into a single HTML document"""
+        html = files.get('index.html') or ''
+        js = files.get('index.js') or ''
+        css = files.get('style.css') or ''
+        
+        # Normalize JS imports to stable CDN
+        cdn_url = "https://cdn.jsdelivr.net/npm/@huggingface/[email protected]"
+        
+        def _normalize_imports(_code: str) -> str:
+            if not _code:
+                return _code or ""
+            _code = re.sub(r"from\s+['\"]@huggingface/transformers['\"]", f"from '{cdn_url}'", _code)
+            _code = re.sub(r"from\s+['\"]@xenova/transformers['\"]", f"from '{cdn_url}'", _code)
+            _code = re.sub(r"from\s+['\"]https://cdn.jsdelivr.net/npm/@huggingface/transformers@[^'\"]+['\"]", f"from '{cdn_url}'", _code)
+            _code = re.sub(r"from\s+['\"]https://cdn.jsdelivr.net/npm/@xenova/transformers@[^'\"]+['\"]", f"from '{cdn_url}'", _code)
+            return _code
+        
+        # Extract and merge inline module scripts
+        inline_modules = []
+        try:
+            for _m in re.finditer(r"<script\b[^>]*type=[\"']module[\"'][^>]*>([\s\S]*?)</script>", html, flags=re.IGNORECASE):
+                inline_modules.append(_m.group(1))
+            if inline_modules:
+                html = re.sub(r"<script\b[^>]*type=[\"']module[\"'][^>]*>[\s\S]*?</script>\s*", "", html, flags=re.IGNORECASE)
+        except Exception:
+            pass
+        
+        # Combine JS code
+        combined_js_parts = []
+        if inline_modules:
+            combined_js_parts.append("\n\n".join(inline_modules))
+        if js:
+            combined_js_parts.append(js)
+        js = "\n\n".join([p for p in combined_js_parts if (p and p.strip())])
+        js = _normalize_imports(js)
+        
+        # Add prelude for better compatibility
+        if js.strip():
+            prelude = (
+                f"import {{ env }} from '{cdn_url}';\n"
+                "try { env.useBrowserCache = false; } catch (e) {}\n"
+                "try { if (env && env.backends && env.backends.onnx && env.backends.onnx.wasm) { env.backends.onnx.wasm.numThreads = 1; env.backends.onnx.wasm.proxy = false; } } catch (e) {}\n"
+                f"(async () => {{ try {{ if (typeof globalThis.transformers === 'undefined') {{ const m = await import('{cdn_url}'); globalThis.transformers = m; }} }} catch (e) {{}} }})();\n"
+            )
+            js = prelude + js
+        
+        # Create minimal shell if needed
+        doc = html.strip()
+        if not doc or ('<html' not in doc.lower()):
+            doc = (
+                "<!DOCTYPE html>\n"
+                "<html>\n<head>\n<meta charset=\"UTF-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n<title>Transformers.js App</title>\n</head>\n"
+                "<body>\n<div id=\"app\"></div>\n</body>\n</html>"
             )
-            
-            # Chat input with advanced features
-            with gr.Row():
-                chat_input = gr.MultimodalTextbox(
-                    placeholder="Describe what you want to build... (supports text, images, and files)",
-                    submit_btn=True,
-                    stop_btn=False,
-                    show_label=False,
-                    sources=["upload", "microphone"],
-                    elem_classes=["chat-input"],
-                    scale=4
-                )
-                
-                chat_voice_btn = gr.Button("🎤", size="sm", elem_classes=["voice-button"])
-            
-            # Chat controls
-            with gr.Row():
-                chat_clear_btn = gr.ClearButton([chat_input, chatbot], size="sm")
-                chat_export_btn = gr.Button("📤 Export Chat", size="sm")
-                chat_settings_btn = gr.Button("⚙️", size="sm")
-            
-            # Quick actions
-            with gr.Row(elem_classes=["chat-quick-actions"]):
-                quick_actions = [
-                    ("🌐 Website", "Create a modern website"),
-                    ("📱 App", "Build a mobile app"),
-                    ("📊 Dashboard", "Design a data dashboard"),
-                    ("🎮 Game", "Create an interactive game")
-                ]
-                
-                quick_buttons = []
-                for icon_text, prompt in quick_actions:
-                    btn = gr.Button(icon_text, size="sm", elem_classes=["quick-action"])
-                    quick_buttons.append((btn, prompt))
-        
-        chat_components = {
-            'chatbot': chatbot,
-            'chat_input': chat_input,
-            'chat_voice_btn': chat_voice_btn,
-            'chat_clear_btn': chat_clear_btn,
-            'chat_export_btn': chat_export_btn,
-            'chat_settings_btn': chat_settings_btn,
-            'quick_buttons': quick_buttons
-        }
         
-        return chat_group, chat_components
-    
-    def create_advanced_sidebar(self) -> gr.Column:
-        """Create advanced sidebar with intelligent organization"""
-        with gr.Column(elem_classes=["advanced-sidebar"]) as sidebar:
-            # Header with user info
-            with gr.Group(elem_classes=["sidebar-header"]):
-                login_button = gr.LoginButton(elem_classes=["login-btn"])
-                
-                with gr.Row():
-                    beta_toggle = gr.Checkbox(
-                        value=False,
-                        label="🧪 Beta Chat Mode",
-                        info="Try our new conversational interface",
-                        elem_classes=["beta-toggle"]
-                    )
-            
-            # Chat interface (hidden by default)
-            chat_group, chat_components = self.create_chat_interface()
-            chat_group.visible = False
+        # Remove local file references
+        doc = re.sub(r"<link[^>]+href=\"[^\"]*style\.css\"[^>]*>\s*", "", doc, flags=re.IGNORECASE)
+        doc = re.sub(r"<script[^>]+src=\"[^\"]*index\.js\"[^>]*>\s*</script>\s*", "", doc, flags=re.IGNORECASE)
+        
+        # Inline CSS
+        if css:
+            style_tag = f"<style>\n{css}\n</style>"
+            if '</head>' in doc.lower():
+                match = re.search(r"</head>", doc, flags=re.IGNORECASE)
+                if match:
+                    idx = match.start()
+                    doc = doc[:idx] + style_tag + doc[idx:]
+            else:
+                match = re.search(r"<body[^>]*>", doc, flags=re.IGNORECASE)
+                if match:
+                    idx = match.end()
+                    doc = doc[:idx] + "\n" + style_tag + doc[idx:]
+                else:
+                    doc = style_tag + doc
+        
+        # Inline JS with debugging and cleanup
+        if js:
+            script_tag = f"<script type=\"module\">\n{js}\n</script>"
+            debug_overlay = TransformersJSProcessor._create_debug_overlay()
+            cleanup_tag = TransformersJSProcessor._create_cleanup_script()
             
-            # Classic controls
-            with gr.Group(elem_classes=["classic-controls"]) as classic_group:
-                # Project input section
-                with gr.Group(elem_classes=["input-section"]):
-                    gr.Markdown("### 🎯 Project Description")
-                    input_textbox = gr.Textbox(
-                        label="What would you like to build?",
-                        placeholder="Describe your application in detail...",
-                        lines=3,
-                        elem_classes=["main-input"]
-                    )
-                
-                # Advanced model selector
-                model_group, model_dropdown, model_info_btn, model_refresh_btn = self.create_advanced_model_selector()
-                
-                # Language and framework selection
-                with gr.Group(elem_classes=["language-section"]):
-                    gr.Markdown("### ⚙️ Technology Stack")
-                    
-                    language_dropdown = gr.Dropdown(
-                        choices=[
-                            "HTML/CSS/JS", "React", "Vue", "Svelte", "Streamlit", 
-                            "Gradio", "Python", "Transformers.js", "Node.js", "FastAPI"
-                        ],
-                        value="HTML/CSS/JS",
-                        label="Framework",
-                        elem_classes=["language-dropdown"]
-                    )
-                    
-                    with gr.Row():
-                        responsive_toggle = gr.Checkbox(
-                            label="📱 Responsive Design", 
-                            value=True,
-                            elem_classes=["feature-toggle"]
-                        )
-                        dark_mode_toggle = gr.Checkbox(
-                            label="🌙 Dark Mode Support",
-                            value=False,
-                            elem_classes=["feature-toggle"] 
-                        )
-                
-                # File inputs section
-                with gr.Group(elem_classes=["file-section"]):
-                    gr.Markdown("### 📂 Input Sources")
-                    
-                    file_input = gr.File(
-                        label="Reference Files",
-                        file_types=[".pdf", ".txt", ".md", ".csv", ".docx", ".jpg", ".png"],
-                        elem_classes=["file-input"]
-                    )
-                    
-                    website_url_input = gr.Textbox(
-                        label="Website to Redesign",
-                        placeholder="https://example.com",
-                        elem_classes=["url-input"]
-                    )
-                    
-                    image_input = gr.Image(
-                        label="UI Design Reference",
-                        visible=False,
-                        elem_classes=["image-input"]
-                    )
-                
-                # Media generation controls
-                media_group, media_components = self.create_advanced_media_controls()
-                
-                # Advanced options
-                with gr.Accordion("🔧 Advanced Options", open=False, elem_classes=["advanced-options"]):
-                    search_toggle = gr.Checkbox(
-                        label="🌐 Enable Web Search",
-                        value=False,
-                        info="Use real-time web search for latest information"
-                    )
-                    
-                    optimization_level = gr.Slider(
-                        minimum=1,
-                        maximum=5,
-                        value=3,
-                        step=1,
-                        label="Code Optimization Level",
-                        info="Higher values produce more optimized code"
-                    )
-                    
-                    accessibility_toggle = gr.Checkbox(
-                        label="♿ Accessibility Focus",
-                        value=True,
-                        info="Prioritize accessibility best practices"
-                    )
-                
-                # Generation controls
-                with gr.Row(elem_classes=["generation-controls"]):
-                    generate_btn = gr.Button(
-                        "✨ Generate Code",
-                        variant="primary",
-                        size="lg",
-                        elem_classes=["generate-button"]
-                    )
-                    
-                    with gr.Column(scale=1):
-                        clear_btn = gr.Button("🗑️", size="sm", elem_classes=["clear-button"])
-                        stop_btn = gr.Button("⏹️", size="sm", elem_classes=["stop-button"])
-                
-                # Demo gallery
-                demo_group, demo_cards, demo_search, demo_filter = self.create_advanced_demo_gallery()
-                
-                # Project import section
-                with gr.Group(elem_classes=["import-section"]):
-                    gr.Markdown("### 📥 Import Project")
-                    
-                    import_url = gr.Textbox(
-                        label="Project URL",
-                        placeholder="GitHub, HuggingFace Space, or Model URL",
-                        elem_classes=["import-input"]
-                    )
-                    
-                    with gr.Row():
-                        import_btn = gr.Button("Import", size="sm")
-                        import_status = gr.Markdown("", visible=False)
-                
-                # Deployment section
-                with gr.Group(elem_classes=["deploy-section"], visible=False) as deploy_group:
-                    gr.Markdown("### 🚀 Deploy Application")
-                    
-                    space_name_input = gr.Textbox(
-                        label="App Name",
-                        placeholder="my-awesome-app",
-                        elem_classes=["space-name-input"]
-                    )
-                    
-                    sdk_dropdown = gr.Dropdown(
-                        choices=["Static HTML", "Gradio", "Streamlit", "Transformers.js", "Svelte"],
-                        value="Static HTML",
-                        label="Deployment Type",
-                        elem_classes=["sdk-dropdown"]
-                    )
-                    
-                    deploy_btn = gr.Button(
-                        "🚀 Deploy to HuggingFace",
-                        variant="primary",
-                        elem_classes=["deploy-button"]
-                    )
-                    
-                    deploy_status = gr.Markdown("", visible=False, elem_classes=["deploy-status"])
-        
-        # Collect all components for return
-        sidebar_components = {
-            'login_button': login_button,
-            'beta_toggle': beta_toggle,
-            'chat_group': chat_group,
-            'chat_components': chat_components,
-            'classic_group': classic_group,
-            'input_textbox': input_textbox,
-            'model_dropdown': model_dropdown,
-            'model_info_btn': model_info_btn,
-            'model_refresh_btn': model_refresh_btn,
-            'language_dropdown': language_dropdown,
-            'responsive_toggle': responsive_toggle,
-            'dark_mode_toggle': dark_mode_toggle,
-            'file_input': file_input,
-            'website_url_input': website_url_input,
-            'image_input': image_input,
-            'media_components': media_components,
-            'search_toggle': search_toggle,
-            'optimization_level': optimization_level,
-            'accessibility_toggle': accessibility_toggle,
-            'generate_btn': generate_btn,
-            'clear_btn': clear_btn,
-            'stop_btn': stop_btn,
-            'demo_cards': demo_cards,
-            'demo_search': demo_search,
-            'demo_filter': demo_filter,
-            'import_url': import_url,
-            'import_btn': import_btn,
-            'import_status': import_status,
-            'deploy_group': deploy_group,
-            'space_name_input': space_name_input,
-            'sdk_dropdown': sdk_dropdown,
-            'deploy_btn': deploy_btn,
-            'deploy_status': deploy_status
-        }
+            match = re.search(r"</body>", doc, flags=re.IGNORECASE)
+            if match:
+                idx = match.start()
+                doc = doc[:idx] + debug_overlay + script_tag + cleanup_tag + doc[idx:]
+            else:
+                doc = doc + debug_overlay + script_tag + cleanup_tag
         
-        return sidebar, sidebar_components
+        return doc
+    
+    @staticmethod
+    def _create_debug_overlay() -> str:
+        """Create debug overlay for transformers.js apps"""
+        return (
+            "<style>\n"
+            "#anycoder-debug{position:fixed;left:0;right:0;bottom:0;max-height:45%;overflow:auto;"
+            "background:rgba(0,0,0,.85);color:#9eff9e;padding:.5em;font:12px/1.4 monospace;z-index:2147483647;display:none}"
+            "#anycoder-debug pre{margin:0;white-space:pre-wrap;word-break:break-word}"
+            "</style>\n"
+            "<div id=\"anycoder-debug\"></div>\n"
+            "<script>\n"
+            "(function(){\n"
+            "  const el = document.getElementById('anycoder-debug');\n"
+            "  function show(){ if(el && el.style.display!=='block'){ el.style.display='block'; } }\n"
+            "  function log(msg){ try{ show(); const pre=document.createElement('pre'); pre.textContent=msg; el.appendChild(pre);}catch(e){} }\n"
+            "  const origError = console.error.bind(console);\n"
+            "  console.error = function(){ origError.apply(console, arguments); try{ log('console.error: ' + Array.from(arguments).map(a=>{try{return (typeof a==='string')?a:JSON.stringify(a);}catch(e){return String(a);}}).join(' ')); }catch(e){} };\n"
+            "  window.addEventListener('error', e => { log('window.onerror: ' + (e && e.message ? e.message : 'Unknown error')); });\n"
+            "  window.addEventListener('unhandledrejection', e => { try{ const r=e && e.reason; log('unhandledrejection: ' + (r && (r.message || JSON.stringify(r)))); }catch(err){ log('unhandledrejection'); } });\n"
+            "})();\n"
+            "</script>"
+        )
+    
+    @staticmethod
+    def _create_cleanup_script() -> str:
+        """Create cleanup script for transformers.js apps"""
+        return (
+            "<script>\n"
+            "(function(){\n"
+            "  function cleanup(){\n"
+            "    try { if (window.caches && caches.keys) { caches.keys().then(keys => keys.forEach(k => caches.delete(k))); } } catch(e){}\n"
+            "    try { if (window.indexedDB && indexedDB.databases) { indexedDB.databases().then(dbs => dbs.forEach(db => db && db.name && indexedDB.deleteDatabase(db.name))); } } catch(e){}\n"
+            "  }\n"
+            "  window.addEventListener('pagehide', cleanup, { once: true });\n"
+            "  window.addEventListener('beforeunload', cleanup, { once: true });\n"
+            "})();\n"
+            "</script>"
+        )
 
-class ThemeManager:
-    """Manages application themes and styling"""
+class SvelteProcessor:
+    """Handles Svelte specific code processing"""
     
     @staticmethod
-    def get_custom_css() -> str:
-        """Get custom CSS for advanced styling"""
-        return """
-        /* Advanced AnyCoder Styling */
-        
-        .advanced-sidebar {
-            background: linear-gradient(145deg, #f8fafc 0%, #f1f5f9 100%);
-            border-radius: 12px;
-            padding: 16px;
-            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+    def parse_svelte_output(text: str) -> Dict[str, str]:
+        """Parse Svelte output to extract individual files"""
+        files = {
+            'src/App.svelte': '',
+            'src/app.css': ''
         }
         
-        .sidebar-header {
-            background: linear-gradient(135deg, #3b82f6 0%, #1d4ed8 100%);
-            color: white;
-            padding: 12px;
-            border-radius: 8px;
-            margin-bottom: 16px;
-        }
-        
-        .main-input {
-            border-radius: 8px;
-            border: 2px solid #e5e7eb;
-            transition: border-color 0.2s ease;
-        }
-        
-        .main-input:focus {
-            border-color: #3b82f6;
-            box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.1);
-        }
+        if not text:
+            return files
         
-        .generate-button {
-            background: linear-gradient(135deg, #10b981 0%, #059669 100%);
-            border: none;
-            border-radius: 8px;
-            font-weight: 600;
-            text-transform: uppercase;
-            letter-spacing: 0.5px;
-            transition: all 0.2s ease;
-        }
+        # Extract using code block patterns
+        svelte_pattern = r'```svelte\s*\n([\s\S]+?)\n```'
+        css_pattern = r'```css\s*\n([\s\S]+?)\n```'
         
-        .generate-button:hover {
-            transform: translateY(-1px);
-            box-shadow: 0 4px 12px rgba(16, 185, 129, 0.3);
-        }
+        svelte_match = re.search(svelte_pattern, text, re.IGNORECASE)
+        css_match = re.search(css_pattern, text, re.IGNORECASE)
         
-        .demo-card {
-            background: white;
-            border: 1px solid #e5e7eb;
-            border-radius: 8px;
-            padding: 12px;
-            transition: all 0.2s ease;
-            text-align: left;
-            min-height: 100px;
-        }
+        if svelte_match:
+            files['src/App.svelte'] = svelte_match.group(1).strip()
+        if css_match:
+            files['src/app.css'] = css_match.group(1).strip()
         
-        .demo-card:hover {
-            transform: translateY(-2px);
-            box-shadow: 0 8px 16px rgba(0, 0, 0, 0.1);
-            border-color: #3b82f6;
-        }
+        # Fallback: support === filename === format
+        if not (files['src/App.svelte'] and files['src/app.css']):
+            fallback_files = MultipageProcessor.parse_multipage_html_output(text)
+            for key in files.keys():
+                if key in fallback_files:
+                    files[key] = fallback_files[key]
         
-        .model-button {
-            background: white;
-            border: 1px solid #d1d5db;
-            border-radius: 6px;
-            margin: 4px 0;
-            transition: all 0.2s ease;
-        }
+        return files
+    
+    @staticmethod
+    def format_svelte_output(files: Dict[str, str]) -> str:
+        """Format Svelte files into a single display string"""
+        output = []
+        output.append("=== src/App.svelte ===")
+        output.append(files.get('src/App.svelte', ''))
+        output.append("\n=== src/app.css ===")
+        output.append(files.get('src/app.css', ''))
+        return '\n'.join(output)
+
+class MultipageProcessor:
+    """Handles multi-page HTML projects"""
+    
+    @staticmethod
+    def parse_multipage_html_output(text: str) -> Dict[str, str]:
+        """Parse multi-page HTML output formatted as === filename === sections"""
+        if not text:
+            return {}
         
-        .model-button:hover {
-            background: #f9fafb;
-            border-color: #3b82f6;
-        }
+        from utils import remove_code_block
+        cleaned = remove_code_block(text)
+        files: Dict[str, str] = {}
         
-        .code-actions {
-            background: #f8fafc;
-            border-radius: 8px;
-            padding: 12px;
-            border: 1px solid #e5e7eb;
-        }
+        pattern = re.compile(r"^===\s*([^=\n]+?)\s*===\s*\n([\s\S]*?)(?=\n===\s*[^=\n]+?\s*===|\Z)", re.MULTILINE)
         
-        .preview-sandbox {
-            border: 2px solid #e5e7eb;
-            border-radius: 8px;
-            overflow: hidden;
-        }
+        for m in pattern.finditer(cleaned):
+            name = m.group(1).strip()
+            content = m.group(2).strip()
+            # Remove accidental trailing fences
+            content = re.sub(r"^```\w*\s*\n|\n```\s*$", "", content)
+            files[name] = content
         
-        .chat-input {
-            border-radius: 20px;
-            border: 2px solid #e5e7eb;
-        }
+        return files
+    
+    @staticmethod
+    def format_multipage_output(files: Dict[str, str]) -> str:
+        """Format files back into === filename === sections"""
+        if not isinstance(files, dict) or not files:
+            return ""
+        
+        # Order with index.html first
+        ordered_paths = []
+        if 'index.html' in files:
+            ordered_paths.append('index.html')
+        for path in sorted(files.keys()):
+            if path == 'index.html':
+                continue
+            ordered_paths.append(path)
+        
+        parts: List[str] = []
+        for path in ordered_paths:
+            parts.append(f"=== {path} ===")
+            parts.append((files.get(path) or '').rstrip())
+        
+        return "\n".join(parts)
+    
+    @staticmethod
+    def validate_and_autofix_files(files: Dict[str, str]) -> Dict[str, str]:
+        """Ensure minimal contract for multi-file sites"""
+        if not isinstance(files, dict) or not files:
+            return files or {}
+        
+        normalized: Dict[str, str] = {}
+        for k, v in files.items():
+            safe_key = k.strip().lstrip('/')
+            normalized[safe_key] = v
+        
+        html_files = [p for p in normalized.keys() if p.lower().endswith('.html')]
+        has_index = 'index.html' in normalized
+        
+        # Create index.html if missing but other HTML files exist
+        if not has_index and html_files:
+            links = '\n'.join([f"<li><a href=\"{p}\">{p}</a></li>" for p in html_files])
+            normalized['index.html'] = (
+                "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\"/>\n"
+                "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"/>\n"
+                "<title>Site Index</title>\n</head>\n<body>\n<h1>Site</h1>\n<ul>\n"
+                + links + "\n</ul>\n</body>\n</html>"
+            )
         
-        .main-chatbot {
-            border: 1px solid #e5e7eb;
-            border-radius: 12px;
-            background: #fafafa;
-        }
+        # Collect asset references
+        asset_refs: set[str] = set()
+        patterns = [
+            re.compile(r"<link[^>]+href=\"([^\"]+)\""),
+            re.compile(r"<script[^>]+src=\"([^\"]+)\""),
+            re.compile(r"<img[^>]+src=\"([^\"]+)\""),
+            re.compile(r"<a[^>]+href=\"([^\"]+)\"")
+        ]
+        
+        for path, content in list(normalized.items()):
+            if not path.lower().endswith('.html'):
+                continue
+            for patt in patterns:
+                for m in patt.finditer(content or ""):
+                    ref = (m.group(1) or "").strip()
+                    if not ref or ref.startswith(('http://', 'https://', 'data:', '#')):
+                        continue
+                    asset_refs.add(ref.lstrip('/'))
+        
+        # Add minimal stubs for missing references
+        for ref in list(asset_refs):
+            if ref not in normalized:
+                if ref.lower().endswith('.css'):
+                    normalized[ref] = "/* generated stub */\n"
+                elif ref.lower().endswith('.js'):
+                    normalized[ref] = "// generated stub\n"
+                elif ref.lower().endswith('.html'):
+                    normalized[ref] = (
+                        "<!DOCTYPE html>\n<html lang=\"en\">\n<head><meta charset=\"utf-8\"/><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"/><title>Page</title></head>\n"
+                        "<body><main><h1>Placeholder page</h1><p>This page was auto-created to satisfy an internal link.</p></main></body>\n</html>"
+                    )
         
-        .media-toggle {
-            color: #374151;
-            font-weight: 500;
-        }
+        return normalized
+    
+    @staticmethod
+    def inline_multipage_into_single_preview(files: Dict[str, str]) -> str:
+        """Inline local CSS/JS for iframe preview"""
+        html = files.get('index.html', '')
+        if not html:
+            return ""
         
-        .media-prompt {
-            border-radius: 6px;
-            border: 1px solid #d1d5db;
-        }
+        doc = html
         
-        .quick-action {
-            background: linear-gradient(135deg, #f3f4f6 0%, #e5e7eb 100%);
-            border: 1px solid #d1d5db;
-            border-radius: 6px;
-            font-size: 12px;
-            transition: all 0.2s ease;
-        }
+        # Inline CSS links
+        def _inline_css(match):
+            href = match.group(1)
+            if href in files:
+                return f"<style>\n{files[href]}\n</style>"
+            return match.group(0)
         
-        .quick-action:hover {
-            background: linear-gradient(135deg, #e5e7eb 0%, #d1d5db 100%);
-            transform: translateY(-1px);
-        }
+        doc = re.sub(r"<link[^>]+href=\"([^\"]+)\"[^>]*/?>", _inline_css, doc, flags=re.IGNORECASE)
         
-        .feature-toggle {
-            font-size: 13px;
-            color: #6b7280;
-        }
+        # Inline JS scripts
+        def _inline_js(match):
+            src = match.group(1)
+            if src in files:
+                return f"<script>\n{files[src]}\n</script>"
+            return match.group(0)
         
-        .stats-display {
-            font-size: 11px;
-            background: #f9fafb;
-            border-radius: 4px;
-            padding: 8px;
-        }
+        doc = re.sub(r"<script[^>]+src=\"([^\"]+)\"[^>]*>\s*</script>", _inline_js, doc, flags=re.IGNORECASE)
         
-        .preview-metrics {
-            font-size: 10px;
-            color: #6b7280;
-        }
+        # Add client-side navigation for other pages
+        MultipageProcessor._add_client_side_navigation(doc, files)
         
-        .category-header {
-            color: #374151;
-            font-weight: 600;
-            margin: 8px 0;
-            padding-bottom: 4px;
-            border-bottom: 1px solid #e5e7eb;
-        }
-        
-        .deploy-button {
-            background: linear-gradient(135deg, #8b5cf6 0%, #7c3aed 100%);
-            color: white;
-            font-weight: 600;
-        }
-        
-        .beta-toggle {
-            background: linear-gradient(135deg, #fbbf24 0%, #f59e0b 100%);
-            color: white;
-            padding: 4px 8px;
-            border-radius: 6px;
-            font-size: 12px;
-        }
-        """
+        return doc
     
     @staticmethod
-    def apply_theme_updates(theme_name: str) -> Dict[str, Any]:
-        """Apply theme and return UI updates"""
-        if theme_name in THEME_CONFIGS:
-            save_theme_preference(theme_name)
+    def _add_client_side_navigation(doc: str, files: Dict[str, str]) -> str:
+        """Add client-side navigation for multi-page preview"""
+        try:
+            html_pages = {k: v for k, v in files.items() if k.lower().endswith('.html')}
             
-            restart_message = f"""
-            🎨 **Theme Applied:** {theme_name}
+            # Extract body content for each page
+            _index_body = re.search(r"<body[^>]*>([\s\S]*?)</body>", doc, flags=re.IGNORECASE)
+            html_pages['index.html'] = _index_body.group(1) if _index_body else doc
             
-            **{THEME_CONFIGS[theme_name]['description']}**
+            encoded = base64.b64encode(json.dumps(html_pages).encode('utf-8')).decode('ascii')
             
-            Your theme preference has been saved. Some advanced styling may require a restart to fully apply.
-            """
+            nav_script = (
+                "<script>\n"
+                "(function(){\n"
+                f"  const MP_FILES = JSON.parse(atob('{encoded}'));\n"
+                "  function extractBody(html){\n"
+                "    try {\n"
+                "      const doc = new DOMParser().parseFromString(html, 'text/html');\n"
+                "      const title = doc.querySelector('title'); if (title) document.title = title.textContent || document.title;\n"
+                "      return doc.body ? doc.body.innerHTML : html;\n"
+                "    } catch(e){ return html; }\n"
+                "  }\n"
+                "  function loadPage(path){\n"
+                "    if (!MP_FILES[path]) return false;\n"
+                "    const bodyHTML = extractBody(MP_FILES[path]);\n"
+                "    document.body.innerHTML = bodyHTML;\n"
+                "    attach();\n"
+                "    try { history.replaceState({}, '', '#'+path); } catch(e){}\n"
+                "    return true;\n"
+                "  }\n"
+                "  function clickHandler(e){\n"
+                "    const a = e.target && e.target.closest ? e.target.closest('a') : null;\n"
+                "    if (!a) return;\n"
+                "    const href = a.getAttribute('href') || '';\n"
+                "    if (!href || href.startsWith('#') || /^https?:/i.test(href) || href.startsWith('mailto:') || href.startsWith('tel:')) return;\n"
+                "    const clean = href.split('#')[0].split('?')[0];\n"
+                "    if (MP_FILES[clean]) { e.preventDefault(); loadPage(clean); }\n"
+                "  }\n"
+                "  function attach(){ document.removeEventListener('click', clickHandler, true); document.addEventListener('click', clickHandler, true); }\n"
+                "  document.addEventListener('DOMContentLoaded', function(){ attach(); const initial = (location.hash||'').slice(1); if (initial && MP_FILES[initial]) loadPage(initial); }, { once:true });\n"
+                "})();\n"
+                "</script>"
+            )
             
-            return {
-                'theme_status': gr.update(value=restart_message, visible=True),
-                'current_theme': theme_name
-            }
+            m = re.search(r"</body>", doc, flags=re.IGNORECASE)
+            if m:
+                i = m.start()
+                doc = doc[:i] + nav_script + doc[i:]
+            else:
+                doc = doc + nav_script
+                
+        except Exception:
+            pass  # Non-fatal in preview
         
-        return {'theme_status': gr.update(visible=False), 'current_theme': theme_name}
+        return doc
 
-class DeploymentManager:
-    """Manages application deployment to various platforms"""
+class MediaIntegrator:
+    """Handles integration of generated media into code"""
     
     @staticmethod
-    def create_deployment_options() -> Dict[str, Any]:
-        """Create deployment options for different platforms"""
-        platforms = {
-            'huggingface': {
-                'name': 'HuggingFace Spaces',
-                'icon': '🤗',
-                'description': 'Deploy to HuggingFace Spaces with automatic hosting',
-                'sdks': ['Static', 'Gradio', 'Streamlit', 'Docker']
-            },
-            'netlify': {
-                'name': 'Netlify',
-                'icon': '🌐',
-                'description': 'Deploy static sites with continuous deployment',
-                'sdks': ['Static']
-            },
-            'vercel': {
-                'name': 'Vercel',
-                'icon': '▲',
-                'description': 'Deploy with edge functions and optimized performance',
-                'sdks': ['Static', 'Next.js']
-            }
-        }
-        
-        return platforms
+    def apply_generated_media_to_html(html_content: str, user_prompt: str, 
+                                    enable_text_to_image: bool = False,
+                                    enable_image_to_image: bool = False, 
+                                    input_image_data=None,
+                                    image_to_image_prompt: Optional[str] = None,
+                                    text_to_image_prompt: Optional[str] = None,
+                                    enable_image_to_video: bool = False,
+                                    image_to_video_prompt: Optional[str] = None,
+                                    session_id: Optional[str] = None,
+                                    enable_text_to_video: bool = False,
+                                    text_to_video_prompt: Optional[str] = None,
+                                    enable_text_to_music: bool = False,
+                                    text_to_music_prompt: Optional[str] = None,
+                                    token=None) -> str:
+        """Apply media generation to HTML content"""
+        
+        # Detect multi-page structure
+        is_multipage = False
+        multipage_files = {}
+        entry_html_path = None
+        
+        try:
+            multipage_files = MultipageProcessor.parse_multipage_html_output(html_content) or {}
+            if multipage_files:
+                is_multipage = True
+                entry_html_path = 'index.html' if 'index.html' in multipage_files else next((p for p in multipage_files.keys() if p.lower().endswith('.html')), None)
+        except Exception:
+            pass
+        
+        result = multipage_files.get(entry_html_path, html_content) if is_multipage and entry_html_path else html_content
+        
+        try:
+            # Process media generation based on priority
+            if enable_image_to_video and input_image_data is not None:
+                result = MediaIntegrator._apply_image_to_video(result, user_prompt, image_to_video_prompt, input_image_data, session_id, token)
+            elif enable_text_to_video:
+                result = MediaIntegrator._apply_text_to_video(result, user_prompt, text_to_video_prompt, session_id, token)
+            elif enable_text_to_music:
+                result = MediaIntegrator._apply_text_to_music(result, user_prompt, text_to_music_prompt, session_id, token)
+            elif enable_image_to_image and input_image_data is not None:
+                result = MediaIntegrator._apply_image_to_image(result, user_prompt, image_to_image_prompt, input_image_data, token)
+            elif enable_text_to_image:
+                result = MediaIntegrator._apply_text_to_image(result, user_prompt, text_to_image_prompt, token)
+        except Exception as e:
+            print(f"[MediaApply] Error during media generation: {str(e)}")
+        
+        # Return updated content
+        if is_multipage and entry_html_path:
+            multipage_files[entry_html_path] = result
+            return MultipageProcessor.format_multipage_output(multipage_files)
+        
+        return result
     
     @staticmethod
-    def prepare_deployment_files(code: str, language: str, framework: str) -> Dict[str, str]:
-        """Prepare files for deployment based on the framework"""
-        files = {}
-        
-        if language == "transformers.js":
-            # Parse and prepare transformers.js files
-            parsed_files = parse_transformers_js_output(code)
-            files.update(parsed_files)
-        
-        elif language == "svelte":
-            # Parse and prepare Svelte files
-            parsed_files = parse_svelte_output(code)
-            files.update(parsed_files)
-            
-        elif language == "html":
-            # Handle multi-page or single HTML
-            parsed_files = parse_multipage_html_output(code)
-            if parsed_files:
-                files.update(validate_and_autofix_files(parsed_files))
-            else:
-                files['index.html'] = code
-        
-        else:
-            # Single file deployment
-            extension_map = {
-                'python': '.py',
-                'javascript': '.js',
-                'typescript': '.ts',
-                'css': '.css'
-            }
-            
-            filename = f"app{extension_map.get(language, '.txt')}"
-            files[filename] = code
-        
-        return files
+    def _apply_image_to_video(html_content: str, user_prompt: str, prompt: Optional[str], 
+                            input_image_data, session_id: Optional[str], token) -> str:
+        """Apply image-to-video generation"""
+        i2v_prompt = (prompt or user_prompt or "").strip()
+        print(f"[MediaApply] Applying image-to-video with prompt: {i2v_prompt}")
+        
+        try:
+            video_html_tag = generate_video_from_image(input_image_data, i2v_prompt, session_id=session_id, token=token)
+            if not video_html_tag.startswith("Error") and validate_video_html(video_html_tag):
+                return MediaIntegrator._place_media_in_html(html_content, video_html_tag, "video")
+        except Exception as e:
+            print(f"[MediaApply] Image-to-video generation failed: {str(e)}")
+        
+        return html_content
+    
+    @staticmethod
+    def _apply_text_to_video(html_content: str, user_prompt: str, prompt: Optional[str], 
+                           session_id: Optional[str], token) -> str:
+        """Apply text-to-video generation"""
+        t2v_prompt = (prompt or user_prompt or "").strip()
+        print(f"[MediaApply] Applying text-to-video with prompt: {t2v_prompt}")
+        
+        try:
+            video_html_tag = generate_video_from_text(t2v_prompt, session_id=session_id, token=token)
+            if not video_html_tag.startswith("Error") and validate_video_html(video_html_tag):
+                return MediaIntegrator._place_media_in_html(html_content, video_html_tag, "video")
+        except Exception as e:
+            print(f"[MediaApply] Text-to-video generation failed: {str(e)}")
+        
+        return html_content
+    
+    @staticmethod
+    def _apply_text_to_music(html_content: str, user_prompt: str, prompt: Optional[str], 
+                           session_id: Optional[str], token) -> str:
+        """Apply text-to-music generation"""
+        t2m_prompt = (prompt or user_prompt or "").strip()
+        print(f"[MediaApply] Applying text-to-music with prompt: {t2m_prompt}")
+        
+        try:
+            audio_html_tag = generate_music_from_text(t2m_prompt, session_id=session_id, token=token)
+            if not audio_html_tag.startswith("Error"):
+                return MediaIntegrator._place_media_in_html(html_content, audio_html_tag, "audio")
+        except Exception as e:
+            print(f"[MediaApply] Text-to-music generation failed: {str(e)}")
+        
+        return html_content
+    
+    @staticmethod
+    def _apply_image_to_image(html_content: str, user_prompt: str, prompt: Optional[str], 
+                            input_image_data, token) -> str:
+        """Apply image-to-image generation"""
+        i2i_prompt = (prompt or user_prompt or "").strip()
+        print(f"[MediaApply] Applying image-to-image with prompt: {i2i_prompt}")
+        
+        try:
+            image_html_tag = generate_image_to_image(input_image_data, i2i_prompt, token=token)
+            if not image_html_tag.startswith("Error"):
+                return MediaIntegrator._place_media_in_html(html_content, image_html_tag, "image")
+        except Exception as e:
+            print(f"[MediaApply] Image-to-image generation failed: {str(e)}")
+        
+        return html_content
+    
+    @staticmethod
+    def _apply_text_to_image(html_content: str, user_prompt: str, prompt: Optional[str], token) -> str:
+        """Apply text-to-image generation"""
+        t2i_prompt = (prompt or user_prompt or "").strip()
+        print(f"[MediaApply] Applying text-to-image with prompt: {t2i_prompt}")
+        
+        try:
+            image_html_tag = generate_image_with_qwen(t2i_prompt, 0, token=token)
+            if not image_html_tag.startswith("Error"):
+                return MediaIntegrator._place_media_in_html(html_content, image_html_tag, "image")
+        except Exception as e:
+            print(f"[MediaApply] Text-to-image generation failed: {str(e)}")
+        
+        return html_content
+    
+    @staticmethod
+    def _place_media_in_html(html_content: str, media_html: str, media_type: str) -> str:
+        """Place generated media in appropriate location in HTML"""
+        # Find good insertion points
+        insertion_patterns = [
+            r'(<main[^>]*>)',
+            r'(<section[^>]*class="[^"]*hero[^"]*"[^>]*>)',
+            r'(<div[^>]*class="[^"]*container[^"]*"[^>]*>)',
+            r'(<body[^>]*>)'
+        ]
+        
+        for pattern in insertion_patterns:
+            match = re.search(pattern, html_content, re.IGNORECASE)
+            if match:
+                insertion_point = match.end()
+                container_class = "video-container" if media_type == "video" else f"{media_type}-container"
+                media_with_container = f'\n    <div class="{container_class}" style="margin: 20px 0; text-align: center;">\n        {media_html}\n    </div>'
+                return html_content[:insertion_point] + media_with_container + html_content[insertion_point:]
+        
+        # Fallback: append before closing body
+        body_close = html_content.rfind('</body>')
+        if body_close != -1:
+            return html_content[:body_close] + f'\n    {media_html}\n' + html_content[body_close:]
+        
+        # Last resort: append at end
+        return html_content + f'\n{media_html}'
+
+# Export main functions and classes
+code_processor = CodeProcessor()
+transformers_processor = TransformersJSProcessor()
+svelte_processor = SvelteProcessor()
+multipage_processor = MultipageProcessor()
+media_integrator = MediaIntegrator()
+
+# Main exports
+def is_streamlit_code(code: str) -> bool:
+    return code_processor.is_streamlit_code(code)
+
+def is_gradio_code(code: str) -> bool:
+    return code_processor.is_gradio_code(code)
+
+def extract_html_document(text: str) -> str:
+    return code_processor.extract_html_document(text)
+
+def parse_transformers_js_output(text: str) -> Dict[str, str]:
+    return transformers_processor.parse_transformers_js_output(text)
+
+def format_transformers_js_output(files: Dict[str, str]) -> str:
+    return transformers_processor.format_transformers_js_output(files)
+
+def build_transformers_inline_html(files: Dict[str, str]) -> str:
+    return transformers_processor.build_transformers_inline_html(files)
+
+def parse_svelte_output(text: str) -> Dict[str, str]:
+    return svelte_processor.parse_svelte_output(text)
+
+def format_svelte_output(files: Dict[str, str]) -> str:
+    return svelte_processor.format_svelte_output(files)
+
+def parse_multipage_html_output(text: str) -> Dict[str, str]:
+    return multipage_processor.parse_multipage_html_output(text)
+
+def format_multipage_output(files: Dict[str, str]) -> str:
+    return multipage_processor.format_multipage_output(files)
+
+def validate_and_autofix_files(files: Dict[str, str]) -> Dict[str, str]:
+    return multipage_processor.validate_and_autofix_files(files)
+
+def inline_multipage_into_single_preview(files: Dict[str, str]) -> str:
+    return multipage_processor.inline_multipage_into_single_preview(files)
 
-# Global UI manager instance
-ui_manager = AdvancedUIManager()
-theme_manager = ThemeManager()
-deployment_manager = DeploymentManager()
+def apply_generated_media_to_html(html_content: str, user_prompt: str, **kwargs) -> str:
+    return media_integrator.apply_generated_media_to_html(html_content, user_prompt, **kwargs)