UniversalCompiler.py

#!/usr/bin/env python3
"""
Universal Compiler - Python Edition
A powerful, all-in-one script-to-EXE compiler with a modern dark-themed GUI

Compiles PowerShell, Python, Batch, Node.js, C#, Go, Ruby, VBScript, 
and AutoHotkey scripts into standalone Windows executables.
"""

import os
import sys
import json
import shutil
import threading
import queue
import ctypes
import re
from pathlib import Path
from datetime import datetime
from typing import Optional, Dict, List, Any, Callable
from compiler_core import (
    APP_VERSION as CORE_APP_VERSION,
    BACKEND_NAMES,
    BuildValidationError,
    BuildRequest,
    BuildResult,
    CompilerEngine,
    ExecutionPolicy,
    EXTENSION_BACKENDS,
    backend_status,
    estimate_output_size as core_estimate_output_size,
    extract_icon,
    get_message_catalog,
    load_profiles,
    load_json as core_load_json,
    load_project_manifest,
    project_manifest_path,
    run_command as core_run_command,
    save_json as core_save_json,
    save_profiles,
    update_project_manifest,
)

# Keep automation side-effect free: CLI invocations must not import the GUI or
# install optional desktop packages.  The legacy GUI remains the default when
# the script is launched without a command.
_CLI_COMMANDS = {
    "build", "batch", "inspect", "verify", "release", "list-toolchains", "compatibility", "target-policy", "diagnostics",
    "init-profiles", "manifest", "bytecode", "extract-icon", "wrap-msix", "obfuscate",
    "analytics", "init-actions",
}


def _is_cli_invocation(arguments: List[str]) -> bool:
    """Identify a CLI command without mistaking option values for commands."""

    index = 0
    while index < len(arguments):
        argument = arguments[index].lower()
        if argument in {"--help", "-h"}:
            return True
        if argument == "--locale":
            index += 2
            continue
        return argument in _CLI_COMMANDS
    return False


if __name__ == "__main__" and _is_cli_invocation(sys.argv[1:]):
    from compiler_core import cli_main

    raise SystemExit(cli_main(sys.argv[1:]))

import tkinter as tk  # noqa: E402
from tkinter import filedialog, messagebox  # noqa: E402

# Optional drag & drop support
try:
    from tkinterdnd2 import DND_FILES, TkinterDnD  # type: ignore[import-untyped]
    HAS_DND = True
except ImportError:
    HAS_DND = False
    print("Note: tkinterdnd2 not installed. Drag & drop disabled.")
    print("Install with: pip install tkinterdnd2")

try:
    import customtkinter as ctk  # type: ignore[import-untyped]
except ImportError:
    raise RuntimeError(
        "customtkinter is not installed. Install it explicitly before launching "
        "the GUI; Universal Compiler will not install dependencies implicitly."
    )

# ============================================================================
# CONSTANTS & CONFIGURATION
# ============================================================================

APP_NAME = "Universal Compiler"
APP_VERSION = CORE_APP_VERSION
CONFIG_DIR = Path(os.environ.get("APPDATA", Path.home())) / "UniversalCompiler"
CONFIG_FILE = CONFIG_DIR / "config.json"
PROFILES_FILE = CONFIG_DIR / "profiles.yaml"
MANIFEST_FILE = project_manifest_path("user")
HISTORY_FILE = CONFIG_DIR / "history.json"
RECENT_FILE = CONFIG_DIR / "recent.json"
SETTINGS_FILE = CONFIG_DIR / "settings.json"
TEMPLATES_DIR = CONFIG_DIR / "Templates"
LOG_FILE = CONFIG_DIR / "install.log"

# Ensure config directory exists
CONFIG_DIR.mkdir(parents=True, exist_ok=True)

# ============================================================================
# THEME DEFINITIONS
# ============================================================================

THEMES = {
    "Dark": {
        "bg": "#080d18",
        "sidebar": "#0a111f",
        "surface": "#0f1829",
        "surface_alt": "#121d30",
        "card": "#0f1829",
        "card_hover": "#17243a",
        "border": "#263651",
        "border_strong": "#3a5277",
        "divider": "#22314a",
        "input": "#0c1525",
        "dropzone": "#0b1424",
        "accent": "#2f8cff",
        "accent_hover": "#1f73da",
        "accent_soft": "#142a4a",
        "green": "#34d399",
        "green_hover": "#20b77f",
        "blue": "#38bdf8",
        "red": "#fb6b5b",
        "yellow": "#fbbf24",
        "text1": "#f8fafc",
        "text2": "#a7b4c8",
        "text3": "#71819a",
        "log_bg": "#08101d",
    },
    "Light": {
        "bg": "#f4f7fb",
        "sidebar": "#ffffff",
        "surface": "#ffffff",
        "surface_alt": "#f7f9fc",
        "card": "#ffffff",
        "card_hover": "#edf3fb",
        "border": "#d3deed",
        "border_strong": "#9db2cf",
        "divider": "#dbe4f0",
        "input": "#ffffff",
        "dropzone": "#f8fbff",
        "accent": "#176fd1",
        "accent_hover": "#125cab",
        "accent_soft": "#e4f0ff",
        "green": "#12805c",
        "green_hover": "#0f6c4e",
        "blue": "#176fd1",
        "red": "#c63f33",
        "yellow": "#9a6700",
        "text1": "#102039",
        "text2": "#52627a",
        "text3": "#7b8aa0",
        "log_bg": "#f4f7fb",
    }
}

HIGH_CONTRAST_THEME = {
    "bg": "#000000",
    "sidebar": "#000000",
    "surface": "#000000",
    "surface_alt": "#000000",
    "card": "#000000",
    "card_hover": "#333333",
    "border": "#ffffff",
    "border_strong": "#ffffff",
    "divider": "#ffffff",
    "input": "#000000",
    "dropzone": "#000000",
    "accent": "#00ffff",
    "accent_hover": "#00cccc",
    "accent_soft": "#003333",
    "green": "#00ff00",
    "green_hover": "#00cc00",
    "blue": "#00ffff",
    "red": "#ff6666",
    "yellow": "#ffff00",
    "text1": "#ffffff",
    "text2": "#ffffff",
    "text3": "#cccccc",
    "log_bg": "#000000",
}


def high_contrast_enabled() -> bool:
    """Read the Windows high-contrast preference without opening a window."""

    if os.name != "nt":
        return False
    try:
        class HighContrast(ctypes.Structure):
            _fields_ = [
                ("cb_size", ctypes.c_uint),
                ("flags", ctypes.c_uint),
                ("scheme", ctypes.c_void_p),
            ]

        value = HighContrast()
        value.cb_size = ctypes.sizeof(HighContrast)
        loaded = bool(
            ctypes.windll.user32.SystemParametersInfoW(
                0x0042, value.cb_size, ctypes.byref(value), 0
            )
        )
        return loaded and bool(value.flags & 0x00000001)
    except (AttributeError, OSError, TypeError):
        return False

# ============================================================================
# DEFAULT SETTINGS & PROFILES
# ============================================================================

DEFAULT_SETTINGS = {
    "theme": "Dark",
    "locale": "",
    "post_build_action": "None",
    "post_build_copy_path": "",
    "show_notifications": True,
    "auto_check_updates": True,
    "max_recent_files": 10,
    "max_history_items": 50,
    "default_profile": "Default",
}

DEFAULT_PROFILES = {
    "Default": {
        "console": False,
        "admin": False,
        "single_file": True,
        "backend": "auto",
        "architecture": "native",
        "prefetch": False,
        "verify": True,
        "cache": True,
        "toolchain_versions": {},
        "upx": False,
        "version": "1.0.0.0",
        "company": "",
        "copyright": "",
        "description": "",
        "product": "",
    },
    "Console App": {
        "console": True,
        "admin": False,
        "single_file": True,
        "backend": "auto",
        "architecture": "native",
        "prefetch": False,
        "verify": True,
        "cache": True,
        "toolchain_versions": {},
        "upx": False,
        "version": "1.0.0.0",
        "company": "",
        "copyright": "",
        "description": "",
        "product": "",
    },
    "Admin Tool": {
        "console": True,
        "admin": True,
        "single_file": True,
        "backend": "auto",
        "architecture": "native",
        "prefetch": False,
        "verify": True,
        "cache": True,
        "toolchain_versions": {},
        "upx": False,
        "version": "1.0.0.0",
        "company": "",
        "copyright": "",
        "description": "",
        "product": "",
    },
    "GUI Application": {
        "console": False,
        "admin": False,
        "single_file": True,
        "backend": "auto",
        "architecture": "native",
        "prefetch": False,
        "verify": True,
        "cache": True,
        "toolchain_versions": {},
        "upx": False,
        "version": "1.0.0.0",
        "company": "",
        "copyright": "",
        "description": "",
        "product": "",
    },
}

# ============================================================================
# COMPILER DEFINITIONS
# ============================================================================

COMPILERS = {
    "ps1": {"name": "PowerShell", "compiler": "PS2EXE", "desc": "PowerShell Script"},
    "py": {"name": "Python", "compiler": "PyInstaller / Nuitka", "desc": "Python Script"},
    "bat": {"name": "Batch", "compiler": "IExpress", "desc": "Batch Script"},
    "cmd": {"name": "Command", "compiler": "IExpress", "desc": "Command Script"},
    "js": {"name": "Node.js", "compiler": "pkg", "desc": "JavaScript"},
    "ts": {"name": "TypeScript", "compiler": "Bun compile", "desc": "TypeScript Source"},
    "vbs": {"name": "VBScript", "compiler": "IExpress", "desc": "VBScript"},
    "ahk": {"name": "AutoHotkey", "compiler": "Ahk2Exe", "desc": "AutoHotkey"},
    "cs": {"name": "C#", "compiler": "CSC", "desc": "C# Source"},
    "go": {"name": "Go", "compiler": "go build", "desc": "Go Source"},
    "rb": {"name": "Ruby", "compiler": "Ocra", "desc": "Ruby Script"},
    "rs": {"name": "Rust", "compiler": "Cargo / rustc", "desc": "Rust Source"},
    "lua": {"name": "Lua", "compiler": "srlua / luastatic", "desc": "Lua Script"},
    "pl": {"name": "Perl", "compiler": "PAR::Packer", "desc": "Perl Script"},
    "pm": {"name": "Perl Module", "compiler": "PAR::Packer", "desc": "Perl Module"},
    "kt": {"name": "Kotlin", "compiler": "Kotlin/Native", "desc": "Kotlin Source"},
    "kts": {"name": "Kotlin Script", "compiler": "Kotlin/Native", "desc": "Kotlin Script"},
    "wat": {"name": "WebAssembly", "compiler": "wat2wasm", "desc": "WebAssembly Text"},
}

# ============================================================================
# UTILITY FUNCTIONS
# ============================================================================

def load_json(filepath: Path, default: Any = None) -> Any:
    """Load user-private JSON, recovering a valid adjacent backup if needed."""
    return core_load_json(filepath, default, recoverable=True)


def save_json(filepath: Path, data: Any) -> None:
    """Save user-private JSON atomically with a recoverable backup."""
    try:
        core_save_json(filepath, data, recoverable=True)
    except Exception as e:
        print(f"Error saving {filepath}: {e}")


def format_size(size: int) -> str:
    """Format file size in human-readable format."""
    if size >= 1_073_741_824:
        return f"{size / 1_073_741_824:.1f} GB"
    elif size >= 1_048_576:
        return f"{size / 1_048_576:.1f} MB"
    elif size >= 1024:
        return f"{size / 1024:.1f} KB"
    return f"{size} bytes"


def estimate_output_size(source_file: str, file_type: str) -> str:
    """Estimate the output EXE size based on file type."""
    if not os.path.exists(source_file):
        return "Unknown"
    
    source_size = os.path.getsize(source_file)
    estimates = {
        "ps1": (5 * 1024 * 1024, 1.5),   # ~5MB base + 1.5x
        "py": (15 * 1024 * 1024, 2),      # ~15MB base + 2x
        "bat": (50 * 1024, 1.2),          # ~50KB base
        "cmd": (50 * 1024, 1.2),
        "js": (40 * 1024 * 1024, 1.5),    # ~40MB base (Node.js)
        "vbs": (50 * 1024, 1.2),
        "ahk": (1 * 1024 * 1024, 1.3),    # ~1MB base
        "cs": (10 * 1024, 1.1),           # Small .NET overhead
        "go": (2 * 1024 * 1024, 1.2),     # ~2MB base
        "rb": (20 * 1024 * 1024, 2),      # ~20MB base (Ruby)
    }
    
    if file_type in estimates:
        base, multiplier = estimates[file_type]
        return format_size(int(base + source_size * multiplier))
    return "Unknown"


def log_message(message: str) -> None:
    """Write message to log file."""
    try:
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        with open(LOG_FILE, "a", encoding="utf-8") as f:
            f.write(f"[{timestamp}] {message}\n")
    except Exception:
        pass


def run_command(
    cmd: List[str],
    cwd: Optional[str] = None,
    *,
    allow_network: bool = False,
    allow_dependency_install: bool = False,
) -> tuple:
    """Run a command through the shared bounded policy and return its tuple."""
    try:
        result = core_run_command(
            cmd,
            cwd=cwd,
            policy=ExecutionPolicy(
                allow_network=allow_network,
                allow_dependency_install=allow_dependency_install,
            ),
        )
        return result.success, result.output
    except Exception as e:
        return False, str(e)


def which(program: str) -> Optional[str]:
    """Find program in PATH."""
    return shutil.which(program)


def show_notification(title: str, message: str) -> None:
    """Show Windows toast notification."""
    try:
        from win10toast import ToastNotifier  # type: ignore[import-not-found]
        toaster = ToastNotifier()
        toaster.show_toast(title, message, duration=5, threaded=True)
    except ImportError:
        try:
            # Fallback to Windows balloon notification
            ctypes.windll.user32.MessageBoxW(0, message, title, 0x40)
        except Exception:
            pass
    except Exception:
        pass


# ============================================================================
# SETTINGS MANAGEMENT
# ============================================================================

class Settings:
    """Application settings manager."""
    
    def __init__(self):
        self._settings = DEFAULT_SETTINGS.copy()
        self.load()
    
    def load(self) -> None:
        """Load settings from file."""
        try:
            saved = load_project_manifest(
                MANIFEST_FILE, expected_scope="user"
            ).manifest["settings"]
        except (BuildValidationError, OSError, ValueError):
            saved = load_json(SETTINGS_FILE, {})
        for key, value in saved.items():
            if key in self._settings:
                self._settings[key] = value
    
    def save(self) -> None:
        """Save settings to file."""
        try:
            update_project_manifest(
                MANIFEST_FILE,
                lambda manifest: manifest.update(settings=dict(self._settings)) or manifest,
                expected_scope="user",
            )
        except (BuildValidationError, OSError, ValueError):
            save_json(SETTINGS_FILE, self._settings)
    
    def get(self, key: str, default: Any = None) -> Any:
        """Get setting value."""
        return self._settings.get(key, default)
    
    def set(self, key: str, value: Any) -> None:
        """Set setting value."""
        self._settings[key] = value
        self.save()
    
    @property
    def theme(self) -> str:
        return self._settings["theme"]
    
    @theme.setter
    def theme(self, value: str):
        self._settings["theme"] = value
        self.save()


# ============================================================================
# RECENT FILES MANAGEMENT
# ============================================================================

class RecentFiles:
    """Recent files manager."""
    
    def __init__(self, max_items: int = 10):
        self.max_items = max_items
        self._files: List[str] = []
        self.load()
    
    def load(self) -> None:
        """Load recent files from disk."""
        saved = load_json(RECENT_FILE, [])
        self._files = [f for f in saved if os.path.exists(f)][:self.max_items]
    
    def save(self) -> None:
        """Save recent files to disk."""
        save_json(RECENT_FILE, self._files)
    
    def add(self, filepath: str) -> None:
        """Add file to recent list."""
        if filepath in self._files:
            self._files.remove(filepath)
        self._files.insert(0, filepath)
        self._files = self._files[:self.max_items]
        self.save()

    def set_limit(self, max_items: int) -> None:
        """Apply a new bounded retention limit to the live list."""
        self.max_items = max(1, int(max_items))
        self._files = self._files[:self.max_items]
        self.save()
    
    def get_all(self) -> List[str]:
        """Get all recent files."""
        return self._files.copy()


# ============================================================================
# BUILD PROFILES MANAGEMENT
# ============================================================================

class BuildProfiles:
    """Build profiles manager."""
    
    def __init__(self):
        self._profiles = DEFAULT_PROFILES.copy()
        self.load()
    
    def load(self) -> None:
        """Load profiles from disk."""
        try:
            saved = load_project_manifest(
                MANIFEST_FILE, expected_scope="user"
            ).manifest["profiles"]
        except (BuildValidationError, OSError, ValueError):
            saved = load_profiles(PROFILES_FILE, self._profiles)
            legacy_file = CONFIG_DIR / "profiles.json"
            if not PROFILES_FILE.exists() and legacy_file.exists():
                saved = load_json(legacy_file, saved)
        for name, profile in saved.items():
            self._profiles[name] = profile
    
    def save(self) -> None:
        """Save profiles to disk."""
        try:
            update_project_manifest(
                MANIFEST_FILE,
                lambda manifest: manifest.update(profiles=dict(self._profiles)) or manifest,
                expected_scope="user",
            )
        except (BuildValidationError, OSError, ValueError):
            save_profiles(PROFILES_FILE, self._profiles)
    
    def get(self, name: str) -> Optional[Dict]:
        """Get profile by name."""
        return self._profiles.get(name)
    
    def set(self, name: str, profile: Dict) -> None:
        """Save or update profile."""
        self._profiles[name] = profile
        self.save()
    
    def names(self) -> List[str]:
        """Get all profile names."""
        return list(self._profiles.keys())


# ============================================================================
# COMPILATION HISTORY
# ============================================================================

class CompilationHistory:
    """Compilation history manager."""
    
    def __init__(self, max_items: int = 50):
        self.max_items = max_items
        self._history: List[Dict] = []
        self.load()
    
    def load(self) -> None:
        """Load history from disk."""
        try:
            self._history = load_project_manifest(
                MANIFEST_FILE, expected_scope="user"
            ).manifest["history"]
        except (BuildValidationError, OSError, ValueError):
            self._history = load_json(HISTORY_FILE, [])
    
    def save(self) -> None:
        """Save history to disk."""
        try:
            update_project_manifest(
                MANIFEST_FILE,
                lambda manifest: manifest.update(history=list(self._history)) or manifest,
                expected_scope="user",
            )
        except (BuildValidationError, OSError, ValueError):
            save_json(HISTORY_FILE, self._history)
    
    def add(self, source: str, output: str, file_type: str, 
            success: bool, profile: str, size: int) -> None:
        """Add compilation to history."""
        entry = {
            "timestamp": datetime.now().isoformat(),
            "source": source,
            "output": output,
            "type": file_type,
            "success": success,
            "profile": profile,
            "size": size,
        }
        self._history.insert(0, entry)
        self._history = self._history[:self.max_items]
        self.save()

    def set_limit(self, max_items: int) -> None:
        """Apply a new bounded retention limit to the live history."""
        self.max_items = max(1, int(max_items))
        self._history = self._history[:self.max_items]
        self.save()
    
    def get_all(self) -> List[Dict]:
        """Get all history entries."""
        return self._history.copy()


# ============================================================================
# TEMPLATE SCRIPTS
# ============================================================================

TEMPLATES = {
    "HelloWorld.ps1": '''# PowerShell Hello World
param([string]$Name = "World")
Add-Type -AssemblyName PresentationFramework
[System.Windows.MessageBox]::Show("Hello, $Name!", "Hello", "OK", "Information")
''',
    "HelloWorld.py": '''# Python Hello World
import tkinter as tk
from tkinter import messagebox

root = tk.Tk()
root.withdraw()
messagebox.showinfo("Hello", "Hello, World!")
root.destroy()
''',
    "HelloWorld.bat": '''@echo off
echo Hello, World!
pause
''',
    "HelloWorld.js": '''// Node.js Hello World
console.log("Hello, World!");
''',
    "HelloWorld.ts": '''// TypeScript Hello World
console.log("Hello, World!");
''',
    "HelloWorld.cs": '''using System;
using System.Windows.Forms;

class Program {
    [STAThread]
    static void Main() {
        MessageBox.Show("Hello, World!", "Hello");
    }
}
''',
    "HelloWorld.go": '''package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}
''',
    "HelloWorld.rb": '''# Ruby Hello World
puts "Hello, World!"
''',
    "HelloWorld.vbs": '''MsgBox "Hello, World!", vbInformation, "Hello"
''',
    "HelloWorld.ahk": '''MsgBox, Hello, World!
''',
    "HelloWorld.rs": '''fn main() {
    println!("Hello, World!");
}
''',
    "HelloWorld.lua": '''print("Hello, World!")
''',
    "HelloWorld.pl": '''print "Hello, World!\\n";
''',
    "HelloWorld.kt": '''fun main() {
    println("Hello, World!")
}
''',
    "HelloWorld.wat": '''(module
  (func (export "hello"))
)
''',
}


def initialize_templates() -> None:
    """Create template files if they don't exist."""
    TEMPLATES_DIR.mkdir(parents=True, exist_ok=True)
    for filename, content in TEMPLATES.items():
        filepath = TEMPLATES_DIR / filename
        if not filepath.exists():
            filepath.write_text(content, encoding="utf-8")


# ============================================================================
# DEPENDENCY CHECKER
# ============================================================================

class DependencyChecker:
    """Check and install compiler dependencies."""
    
    @staticmethod
    def check_ps2exe() -> bool:
        """Check if PS2EXE is available."""
        try:
            result = core_run_command(
                ["powershell", "-Command", "Get-Module -ListAvailable ps2exe"],
            )
            return result.success and "ps2exe" in result.output.lower()
        except Exception:
            return False
    
    @staticmethod
    def check_pyinstaller() -> bool:
        """Check if PyInstaller is available."""
        return which("pyinstaller") is not None
    
    @staticmethod
    def check_pkg() -> bool:
        """Check if pkg is available."""
        return which("pkg") is not None
    
    @staticmethod
    def check_go() -> bool:
        """Check if Go is available."""
        if which("go"):
            return True
        go_path = Path(os.environ.get("LOCALAPPDATA", "")) / "Programs/Go/bin/go.exe"
        return go_path.exists()
    
    @staticmethod
    def check_ruby() -> bool:
        """Check if Ruby/Ocra is available."""
        return which("ocra") is not None
    
    @staticmethod
    def check_ahk() -> bool:
        """Check if AutoHotkey compiler is available."""
        paths = [
            Path(os.environ.get("ProgramFiles", "")) / "AutoHotkey/Compiler/Ahk2Exe.exe",
            Path(os.environ.get("ProgramFiles", "")) / "AutoHotkey/v2/Compiler/Ahk2Exe.exe",
            Path(os.environ.get("ProgramFiles(x86)", "")) / "AutoHotkey/Compiler/Ahk2Exe.exe",
        ]
        return any(p.exists() for p in paths)
    
    @staticmethod
    def check_csc() -> bool:
        """Check if CSC is available."""
        windir = os.environ.get("WINDIR", "C:\\Windows")
        paths = [
            Path(windir) / "Microsoft.NET/Framework64/v4.0.30319/csc.exe",
            Path(windir) / "Microsoft.NET/Framework/v4.0.30319/csc.exe",
        ]
        return any(p.exists() for p in paths)
    
    @staticmethod
    def check_iexpress() -> bool:
        """Check if IExpress is available."""
        windir = os.environ.get("WINDIR", "C:\\Windows")
        return (Path(windir) / "System32/iexpress.exe").exists()
    
    @classmethod
    def check_compiler(cls, file_type: str, backend: str = "auto") -> bool:
        """Check if compiler for file type is available."""
        if backend != "auto":
            return bool(backend_status().get(backend, {}).get("available"))
        if file_type in EXTENSION_BACKENDS:
            return any(
                backend_status().get(candidate, {}).get("available")
                for candidate in EXTENSION_BACKENDS[file_type]
            )
        checkers = {
            "ps1": cls.check_ps2exe,
            "py": cls.check_pyinstaller,
            "bat": cls.check_iexpress,
            "cmd": cls.check_iexpress,
            "js": cls.check_pkg,
            "vbs": cls.check_iexpress,
            "ahk": cls.check_ahk,
            "cs": cls.check_csc,
            "go": cls.check_go,
            "rb": cls.check_ruby,
        }
        checker = checkers.get(file_type)
        return checker() if checker else False
    
    @classmethod
    def get_all_status(cls) -> Dict[str, Dict]:
        """Get the shared capability catalog in the GUI's card format."""

        aliases = {
            "ps2exe": "PS2EXE",
            "pyinstaller": "PyInstaller",
            "iexpress": "IExpress",
            "go": "Go",
            "ocra": "Ruby+Ocra",
            "ahk2exe": "AutoHotkey",
            "csc": "CSC",
        }
        built_in = {"csc", "iexpress"}
        status: Dict[str, Dict] = {}
        for backend, info in backend_status().items():
            key = aliases.get(backend, backend)
            extensions = ", ".join(
                f".{extension}" for extension in info["extensions"]
            )
            status[key] = {
                "name": info["name"],
                "desc": extensions or "Optional build utility",
                "installed": bool(info["available"]),
                "size": "Built-in" if backend in built_in else "Toolchain",
                "builtin": backend in built_in,
                "backend": backend,
                "lifecycle": info["lifecycle"],
                "default": info["default"],
                "host_supported": info["host_supported"],
                "target_platforms": info["target_platforms"],
                "architectures": info["architectures"],
                "required_sdks": info["required_sdks"],
                "verified_version": info["verified_version"],
            }
        return status


# ============================================================================
# COMPILERS
# ============================================================================

class Compiler:
    """Handle compilation for various script types."""
    
    @staticmethod
    def compile_ps1(source: str, output: str, icon: Optional[str] = None,
                    admin: bool = False, no_console: bool = True,
                    metadata: Optional[Dict] = None) -> tuple:
        """Compile PowerShell through the shared engine."""
        return Compiler.compile(
            source,
            output,
            "ps1",
            icon=icon,
            admin=admin,
            console=not no_console,
            metadata=metadata,
        )
    
    @staticmethod
    def compile_py(source: str, output: str, icon: Optional[str] = None,
                   one_file: bool = True, console: bool = False) -> tuple:
        """Compile Python through the shared engine."""
        return Compiler.compile(
            source,
            output,
            "py",
            icon=icon,
            console=console,
            single_file=one_file,
        )
    
    @staticmethod
    def compile_batch(source: str, output: str) -> tuple:
        """Compile Batch/VBS through the shared engine."""
        file_type = Path(source).suffix.lower().lstrip(".")
        return Compiler.compile(source, output, file_type if file_type in {"bat", "cmd", "vbs"} else "bat")
    
    @staticmethod
    def compile_js(source: str, output: str) -> tuple:
        """Compile JavaScript through the shared engine."""
        return Compiler.compile(source, output, "js")
    
    @staticmethod
    def compile_cs(source: str, output: str) -> tuple:
        """Compile C# through the shared engine."""
        return Compiler.compile(source, output, "cs")
    
    @staticmethod
    def compile_go(source: str, output: str) -> tuple:
        """Compile Go through the shared engine."""
        return Compiler.compile(source, output, "go")
    
    @staticmethod
    def compile_ahk(source: str, output: str, icon: Optional[str] = None) -> tuple:
        """Compile AutoHotkey through the shared engine."""
        return Compiler.compile(source, output, "ahk", icon=icon)
    
    @staticmethod
    def compile_rb(source: str, output: str) -> tuple:
        """Compile Ruby through the shared engine."""
        return Compiler.compile(source, output, "rb")
    
    @classmethod
    def build_result(
        cls,
        source: str,
        output: str,
        file_type: str,
        icon: Optional[str] = None,
        admin: bool = False,
        console: bool = False,
        single_file: bool = True,
        metadata: Optional[Dict] = None,
        backend: str = "auto",
        target: str = "native",
        architecture: str = "native",
        prefetch: bool = False,
        verify: bool = True,
        force: bool = False,
        cancel_event: Optional[threading.Event] = None,
    ) -> BuildResult:
        """Return the canonical structured result used by every Python shell."""
        request = BuildRequest(
            source=Path(source),
            output=Path(output),
            file_type=file_type,
            backend=backend,
            icon=Path(icon) if icon else None,
            admin=admin,
            console=console,
            single_file=single_file,
            metadata=metadata or {},
            prefetch=prefetch,
            verify=verify,
            force=force,
            target=target,
            architecture=architecture,
            cancel_event=cancel_event,
        )
        return CompilerEngine().build(request)

    @classmethod
    def compile(
        cls,
        source: str,
        output: str,
        file_type: str,
        icon: Optional[str] = None,
        admin: bool = False,
        console: bool = False,
        single_file: bool = True,
        metadata: Optional[Dict] = None,
        backend: str = "auto",
        prefetch: bool = False,
        verify: bool = True,
        force: bool = False,
    ) -> tuple:
        """Keep the legacy tuple API while delegating to the canonical result."""
        result = cls.build_result(
            source,
            output,
            file_type,
            icon=icon,
            admin=admin,
            console=console,
            single_file=single_file,
            metadata=metadata,
            backend=backend,
            prefetch=prefetch,
            verify=verify,
            force=force,
        )
        details = [result.message]
        for command in result.commands:
            if command.output:
                details.append(command.output)
        if result.verification:
            details.append(result.verification.details)
        return result.success, "\n".join(detail for detail in details if detail)


# ============================================================================
# SETUP WINDOW
# ============================================================================

class SetupWindow(ctk.CTkToplevel):
    """Dependency setup window."""
    
    def __init__(self, parent, theme: Dict):
        super().__init__(parent)
        self.theme = theme
        self.title("Universal Compiler - Setup")
        self.geometry("600x550")
        self.resizable(False, False)
        
        # Center window
        self.update_idletasks()
        x = (self.winfo_screenwidth() - 600) // 2
        y = (self.winfo_screenheight() - 550) // 2
        self.geometry(f"600x550+{x}+{y}")
        
        self.configure(fg_color=theme["bg"])
        self.checkboxes: Dict[str, ctk.CTkCheckBox] = {}
        self.completed = False
        
        self._create_ui()
        
        # Make modal
        self.transient(parent)
        self.grab_set()
        self._ui_events: queue.Queue[Callable[[], None]] = queue.Queue(maxsize=64)
        self.after(50, self._drain_ui_events)

    def _post_ui(self, callback: Callable[[], None]) -> None:
        try:
            self._ui_events.put_nowait(callback)
        except queue.Full:
            pass

    def _drain_ui_events(self) -> None:
        while True:
            try:
                callback = self._ui_events.get_nowait()
            except queue.Empty:
                break
            try:
                callback()
            except Exception as error:
                print(f"Setup UI update failed: {error}")
        try:
            self.after(50, self._drain_ui_events)
        except tk.TclError:
            pass
    
    def _create_ui(self):
        # Header
        header = ctk.CTkFrame(self, fg_color=self.theme["card"], corner_radius=0)
        header.pack(fill="x", padx=0, pady=0)
        
        title_frame = ctk.CTkFrame(header, fg_color="transparent")
        title_frame.pack(padx=20, pady=15)
        
        ctk.CTkLabel(
            title_frame, text="⚡ Universal Compiler", 
            font=("Segoe UI", 20, "bold"),
            text_color=self.theme["text1"]
        ).pack(side="left")
        
        ctk.CTkLabel(
            title_frame, text=f"v{APP_VERSION}",
            font=("Segoe UI", 10),
            text_color=self.theme["text3"]
        ).pack(side="left", padx=(10, 0), pady=(8, 0))
        
        ctk.CTkLabel(
            header, text="Select compilers to install",
            font=("Segoe UI", 11),
            text_color=self.theme["text2"]
        ).pack(padx=20, pady=(0, 15))
        
        # Dependency list
        deps_frame = ctk.CTkScrollableFrame(
            self, fg_color=self.theme["bg"],
            height=350
        )
        deps_frame.pack(fill="both", expand=True, padx=15, pady=10)
        
        deps = DependencyChecker.get_all_status()
        for key, dep in deps.items():
            self._create_dep_card(deps_frame, key, dep)
        
        # Progress bar (hidden initially)
        self.progress_frame = ctk.CTkFrame(self, fg_color=self.theme["log_bg"])
        self.progress_label = ctk.CTkLabel(
            self.progress_frame, text="Installing...",
            text_color=self.theme["text2"], font=("Segoe UI", 11)
        )
        self.progress_label.pack(padx=15, pady=(10, 5))
        self.progress_bar = ctk.CTkProgressBar(
            self.progress_frame, fg_color=self.theme["border"],
            progress_color=self.theme["green"]
        )
        self.progress_bar.pack(padx=15, pady=(0, 10), fill="x")
        self.progress_bar.set(0)
        
        # Bottom buttons
        bottom = ctk.CTkFrame(self, fg_color=self.theme["card"])
        bottom.pack(fill="x", side="bottom")
        
        btn_frame = ctk.CTkFrame(bottom, fg_color="transparent")
        btn_frame.pack(pady=15)
        
        self.skip_btn = ctk.CTkButton(
            btn_frame, text="Skip", width=100,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._on_skip
        )
        self.skip_btn.pack(side="left", padx=5)
        
        self.install_btn = ctk.CTkButton(
            btn_frame, text="Install Selected", width=140,
            fg_color=self.theme["green"],
            hover_color=self.theme["green_hover"],
            text_color=self.theme["bg"],
            font=("Segoe UI", 12, "bold"),
            command=self._on_install
        )
        self.install_btn.pack(side="left", padx=5)
    
    def _create_dep_card(self, parent, key: str, dep: Dict):
        card = ctk.CTkFrame(parent, fg_color=self.theme["card"], corner_radius=8)
        card.pack(fill="x", pady=4)
        
        inner = ctk.CTkFrame(card, fg_color="transparent")
        inner.pack(fill="x", padx=12, pady=10)
        
        # Checkbox
        var = ctk.BooleanVar(value=not dep["installed"] and key == "PS2EXE")
        cb = ctk.CTkCheckBox(
            inner, text="", variable=var,
            fg_color=self.theme["green"],
            hover_color=self.theme["green_hover"],
            border_color=self.theme["border"],
            width=24, height=24
        )
        
        if dep["installed"] or dep.get("builtin"):
            cb.configure(state="disabled")
            var.set(False)
        
        cb.pack(side="left")
        self.checkboxes[key] = cb
        
        # Info
        info = ctk.CTkFrame(inner, fg_color="transparent")
        info.pack(side="left", fill="x", expand=True, padx=(10, 0))
        
        name_frame = ctk.CTkFrame(info, fg_color="transparent")
        name_frame.pack(anchor="w")
        
        ctk.CTkLabel(
            name_frame, text=dep["name"],
            font=("Segoe UI", 13, "bold"),
            text_color=self.theme["text1"]
        ).pack(side="left")
        
        if dep["installed"]:
            badge = ctk.CTkLabel(
                name_frame, text="✓ Installed",
                font=("Segoe UI", 9),
                text_color=self.theme["green"],
                fg_color="#166534",
                corner_radius=3
            )
            badge.pack(side="left", padx=(8, 0))
        elif dep.get("builtin"):
            badge = ctk.CTkLabel(
                name_frame, text="Built-in",
                font=("Segoe UI", 9),
                text_color=self.theme["blue"],
                fg_color="#1e3a5f",
                corner_radius=3
            )
            badge.pack(side="left", padx=(8, 0))
        
        ctk.CTkLabel(
            info, text=dep["desc"],
            font=("Segoe UI", 10),
            text_color=self.theme["text2"]
        ).pack(anchor="w")
        
        # Size
        ctk.CTkLabel(
            inner, text=dep["size"],
            font=("Segoe UI", 10),
            text_color=self.theme["text3"]
        ).pack(side="right")
    
    def _on_skip(self):
        self.completed = True
        self.destroy()
    
    def _on_install(self):
        selected = [k for k, cb in self.checkboxes.items() 
                    if cb.cget("state") != "disabled" and cb.get()]
        
        if not selected:
            self.completed = True
            self.destroy()
            return
        
        self.install_btn.configure(state="disabled")
        self.skip_btn.configure(state="disabled")
        self.progress_frame.pack(fill="x", before=self.winfo_children()[-1])
        
        def install_thread():
            for i, dep in enumerate(selected):
                self._post_ui(
                    lambda dep=dep, i=i: (
                        self.progress_label.configure(text=f"Installing {dep}..."),
                        self.progress_bar.set((i + 1) / len(selected)),
                    )
                )
                
                # Install logic here (placeholder)
                if dep == "PS2EXE":
                    run_command(["powershell", "-Command", 
                                "Install-Module ps2exe -Scope CurrentUser -Force"],
                                allow_network=True,
                                allow_dependency_install=True)
                elif dep == "PyInstaller":
                    run_command(
                        [sys.executable, "-m", "pip", "install", "pyinstaller"],
                        allow_network=True,
                        allow_dependency_install=True,
                    )
                
            self._post_ui(lambda: self.progress_label.configure(text="Complete!"))
            self._post_ui(self._finish)
        
        threading.Thread(target=install_thread, daemon=True).start()
    
    def _finish(self):
        self.completed = True
        self.destroy()


# ============================================================================
# MAIN APPLICATION
# ============================================================================

class UniversalCompiler:
    """Main application class."""

    # These controls are created through setattr in the legacy UI builders.
    # Declare them here so static analysis can follow their later use.
    version_entry: Any
    company_entry: Any
    copyright_entry: Any
    product_entry: Any
    type_label: Any
    size_label: Any
    compiler_label: Any
    est_label: Any
    architecture_combo: Any
    
    def __init__(self):
        # Initialize managers
        self.settings = Settings()
        self.catalog = get_message_catalog(self.settings.get("locale") or None)
        self.recent_files = RecentFiles(self.settings.get("max_recent_files", 10))
        self.profiles = BuildProfiles()
        self.history = CompilationHistory(self.settings.get("max_history_items", 50))
        
        # State
        self.source_file: Optional[str] = None
        self.file_type: Optional[str] = None
        self.compiling = False
        self.batch_queue: List[str] = []
        self.engine = CompilerEngine()
        self._ui_events: queue.Queue[Callable[[], None]] = queue.Queue(maxsize=128)
        self._cancel_event = threading.Event()
        self._accessibility_registry: Dict[str, Dict[str, str]] = {}
        
        # Initialize templates
        initialize_templates()
        
        # Setup DPI awareness
        self._setup_dpi()
        
        # Create window
        self._create_window()

    def _tr(self, key: str, default: Optional[str] = None, **values: Any) -> str:
        """Translate a GUI message while preserving a stable English fallback."""

        return self.catalog.message(key, default, **values)

    def _register_accessible(self, widget: Any, key: str, role: str) -> Any:
        """Attach semantic metadata and a visible keyboard focus treatment."""

        name = self._tr(key, key)
        self._accessibility_registry[key] = {"name": name, "role": role}
        try:
            widget._uc_accessibility_name = name
            widget._uc_accessibility_role = role
            widget.configure(
                takefocus=True,
                highlightthickness=2,
                highlightcolor=self.theme["blue"],
                highlightbackground=self.theme["border"],
            )
        except (AttributeError, tk.TclError, ValueError):
            try:
                widget.configure(takefocus=True)
            except (AttributeError, tk.TclError, ValueError):
                pass
        return widget

    def _setup_keyboard_navigation(self) -> None:
        """Expose deterministic keyboard-only shortcuts for the golden paths."""

        self.root.bind("<F5>", lambda _event: self._compile())
        self.root.bind("<Escape>", lambda _event: self._cancel_compile())
        self.root.bind("<Alt-b>", lambda _event: self._browse_source())
        self.root.bind("<Control-l>", lambda _event: self.log_text.focus_set())
        self.root.option_add("*takeFocus", True)
    
    def _setup_dpi(self):
        """Enable DPI awareness."""
        try:
            ctypes.windll.shcore.SetProcessDpiAwareness(2)
        except Exception:
            try:
                ctypes.windll.user32.SetProcessDPIAware()
            except Exception:
                pass
    
    def _create_window(self):
        """Create main application window."""
        # Configure CustomTkinter before constructing its DPI-aware root.
        self.high_contrast = high_contrast_enabled()
        self.theme = HIGH_CONTRAST_THEME if self.high_contrast else THEMES[self.settings.theme]
        ctk.set_appearance_mode("dark" if self.settings.theme == "Dark" else "light")
        ctk.set_default_color_theme("blue")

        # Keep a CTk root so CustomTkinter's scaling tracker owns a compatible
        # toplevel. tkinterdnd2 patches BaseWidget; loading its Tcl package on
        # this root preserves native file drops without replacing the root.
        self.root = ctk.CTk(fg_color=self.theme["bg"])
        self._has_dnd = False
        if HAS_DND:
            try:
                self.root.TkdndVersion = TkinterDnD._require(self.root)
                self._has_dnd = True
            except Exception:
                pass
        
        self.root.title(f"{self._tr('app.title', APP_NAME)} v{APP_VERSION}")
        self.root.geometry("1536x960")
        self.root.minsize(1120, 720)
        try:
            self.root.iconbitmap(str(Path(__file__).with_name("icon.ico")))
        except tk.TclError:
            pass
        
        # Maximize normal sessions. Deterministic private-desktop snapshots keep
        # the mockup's 1536x960 viewport instead of inheriting a host display's
        # maximized backing surface before the isolation harness places it.
        if "--ui-snapshot-dir" not in sys.argv:
            self.root.state("zoomed")
        
        self._create_ui()
        self._setup_keyboard_navigation()
        self._setup_drag_drop()
        self.root.after(50, self._drain_ui_events)

    def _post_ui(self, callback: Callable[[], None]) -> None:
        """Queue worker results for execution by Tk's event loop."""

        try:
            self._ui_events.put_nowait(callback)
        except queue.Full:
            pass

    def _drain_ui_events(self) -> None:
        """Apply queued worker results without touching Tk from a worker."""

        while True:
            try:
                callback = self._ui_events.get_nowait()
            except queue.Empty:
                break
            try:
                callback()
            except Exception as error:
                self.log(f"UI update failed: {error}", "error")
        try:
            self.root.after(50, self._drain_ui_events)
        except tk.TclError:
            pass
    
    def _create_ui(self):
        """Create the persistent navigation workspace and its six pages."""

        from workspace_ui import WorkspaceController

        self.workspace = WorkspaceController(
            self,
            version=APP_VERSION,
            templates_dir=TEMPLATES_DIR,
            compiler_catalog=COMPILERS,
        )
        self.workspace.create()
    
    def _create_header(self, parent):
        """Create header section."""
        header = ctk.CTkFrame(parent, fg_color="transparent")
        header.pack(fill="x")
        
        # Title
        title_frame = ctk.CTkFrame(header, fg_color="transparent")
        title_frame.pack(side="left")
        
        ctk.CTkLabel(
            title_frame, text="⚡",
            font=("Segoe UI", 26),
            text_color=self.theme["green"]
        ).pack(side="left")
        
        ctk.CTkLabel(
            title_frame, text=self._tr("app.title", APP_NAME),
            font=("Segoe UI", 24, "bold"),
            text_color=self.theme["text1"]
        ).pack(side="left", padx=(10, 0))
        
        ctk.CTkLabel(
            title_frame, text=f"v{APP_VERSION}",
            font=("Segoe UI", 10),
            text_color=self.theme["text3"]
        ).pack(side="left", padx=(8, 0), pady=(10, 0))
        
        # Subtitle
        ctk.CTkLabel(
            title_frame, text=self._tr("app.subtitle", "Drag files here or browse to compile"),
            font=("Segoe UI", 11),
            text_color=self.theme["text2"]
        ).pack(anchor="w", padx=(36, 0))
        
        # Header buttons
        btn_frame = ctk.CTkFrame(header, fg_color="transparent")
        btn_frame.pack(side="right")
        
        self.theme_btn = self._register_accessible(ctk.CTkButton(
            btn_frame, text="🌙" if self.settings.theme == "Dark" else "☀️",
            width=40, height=40,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._toggle_theme
        ), "actions.theme", "button")
        self.theme_btn.pack(side="left", padx=(0, 8))
        
        self.settings_btn = self._register_accessible(ctk.CTkButton(
            btn_frame, text="⚙",
            width=40, height=40,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._show_settings
        ), "actions.settings", "button")
        self.settings_btn.pack(side="left")
    
    def _create_source_section(self, parent):
        """Create source file section."""
        card = ctk.CTkFrame(parent, fg_color=self.theme["card"], corner_radius=8)
        card.pack(fill="x", pady=(0, 12))
        
        inner = ctk.CTkFrame(card, fg_color="transparent")
        inner.pack(fill="x", padx=20, pady=16)
        
        # Title
        ctk.CTkLabel(
            inner, text=self._tr("source.file", "📁 Source File"),
            font=("Segoe UI", 13, "bold"),
            text_color=self.theme["text1"]
        ).pack(anchor="w", pady=(0, 10))
        
        # File input row
        input_row = ctk.CTkFrame(inner, fg_color="transparent")
        input_row.pack(fill="x")
        
        self.source_entry = self._register_accessible(ctk.CTkEntry(
            input_row, height=38,
            fg_color=self.theme["input"],
            border_color=self.theme["border"],
            text_color=self.theme["text1"],
            state="readonly"
        ), "source.file", "textbox")
        self.source_entry.pack(side="left", fill="x", expand=True)
        
        self.browse_source_btn = self._register_accessible(ctk.CTkButton(
            input_row, text=self._tr("actions.browse", "Browse"), width=80,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._browse_source
        ), "actions.browse", "button")
        self.browse_source_btn.pack(side="left", padx=(8, 0))
        
        self.recent_btn = self._register_accessible(ctk.CTkButton(
            input_row, text="▼", width=40,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._show_recent_menu
        ), "actions.recent", "button")
        self.recent_btn.pack(side="left", padx=(4, 0))
        
        # Info panel (hidden initially)
        self.info_frame = ctk.CTkFrame(inner, fg_color=self.theme["border"], corner_radius=6)
        
        info_inner = ctk.CTkFrame(self.info_frame, fg_color="transparent")
        info_inner.pack(fill="x", padx=12, pady=10)
        
        # Info grid
        info_grid = ctk.CTkFrame(info_inner, fg_color="transparent")
        info_grid.pack(fill="x")
        
        labels = [
            ("Type:", "type_label", self.theme["blue"]),
            ("Size:", "size_label", self.theme["text2"]),
            ("Compiler:", "compiler_label", self.theme["green"]),
            ("Est. Output:", "est_label", self.theme["yellow"]),
            ("Status:", "status_label", self.theme["green"]),
        ]
        
        row = 0
        col = 0
        for label_text, attr_name, color in labels:
            ctk.CTkLabel(
                info_grid, text=label_text,
                font=("Segoe UI", 10),
                text_color=self.theme["text3"]
            ).grid(row=row, column=col * 2, sticky="w", padx=(0, 5))
            
            lbl = ctk.CTkLabel(
                info_grid, text="-",
                font=("Segoe UI", 10, "bold"),
                text_color=color
            )
            lbl.grid(row=row, column=col * 2 + 1, sticky="w", padx=(0, 20))
            setattr(self, attr_name, lbl)
            
            col += 1
            if col > 1:
                col = 0
                row += 1
        
        # Icon preview (hidden initially)
        self.icon_preview_frame = ctk.CTkFrame(inner, fg_color=self.theme["border"], corner_radius=6)
        self.icon_preview_label = ctk.CTkLabel(
            self.icon_preview_frame, text="",
            font=("Segoe UI", 10),
            text_color=self.theme["text2"]
        )
        self.icon_preview_label.pack(padx=10, pady=8)
    
    def _create_output_section(self, parent):
        """Create output section."""
        card = ctk.CTkFrame(parent, fg_color=self.theme["card"], corner_radius=8)
        card.pack(fill="x", pady=(0, 12))
        
        inner = ctk.CTkFrame(card, fg_color="transparent")
        inner.pack(fill="x", padx=20, pady=16)
        
        ctk.CTkLabel(
            inner, text=self._tr("output.title", "📤 Output"),
            font=("Segoe UI", 13, "bold"),
            text_color=self.theme["text1"]
        ).pack(anchor="w", pady=(0, 10))
        
        # Output name and directory
        row1 = ctk.CTkFrame(inner, fg_color="transparent")
        row1.pack(fill="x", pady=(0, 10))
        
        # Output name
        name_frame = ctk.CTkFrame(row1, fg_color="transparent")
        name_frame.pack(side="left", fill="x", expand=True, padx=(0, 8))
        
        ctk.CTkLabel(
            name_frame, text=self._tr("output.name", "Output Name"),
            font=("Segoe UI", 10),
            text_color=self.theme["text2"]
        ).pack(anchor="w", pady=(0, 4))
        
        self.output_name_entry = self._register_accessible(ctk.CTkEntry(
            name_frame, height=38,
            fg_color=self.theme["input"],
            border_color=self.theme["border"],
            text_color=self.theme["text1"]
        ), "output.name", "textbox")
        self.output_name_entry.pack(fill="x")
        
        # Output directory
        dir_frame = ctk.CTkFrame(row1, fg_color="transparent")
        dir_frame.pack(side="left", fill="x", expand=True)
        
        ctk.CTkLabel(
            dir_frame, text=self._tr("output.directory", "Output Directory"),
            font=("Segoe UI", 10),
            text_color=self.theme["text2"]
        ).pack(anchor="w", pady=(0, 4))
        
        dir_input = ctk.CTkFrame(dir_frame, fg_color="transparent")
        dir_input.pack(fill="x")
        
        self.output_dir_entry = self._register_accessible(ctk.CTkEntry(
            dir_input, height=38,
            fg_color=self.theme["input"],
            border_color=self.theme["border"],
            text_color=self.theme["text1"],
            state="readonly"
        ), "output.directory", "textbox")
        self.output_dir_entry.pack(side="left", fill="x", expand=True)
        
        self.output_dir_btn = self._register_accessible(ctk.CTkButton(
            dir_input, text="...", width=40,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._browse_output_dir
        ), "output.directory", "button")
        self.output_dir_btn.pack(side="left", padx=(4, 0))
        
        # Icon
        ctk.CTkLabel(
            inner, text=self._tr("output.custom_icon", "Custom Icon"),
            font=("Segoe UI", 10),
            text_color=self.theme["text2"]
        ).pack(anchor="w", pady=(0, 4))
        
        icon_row = ctk.CTkFrame(inner, fg_color="transparent")
        icon_row.pack(fill="x")
        
        self.icon_entry = self._register_accessible(ctk.CTkEntry(
            icon_row, height=38,
            fg_color=self.theme["input"],
            border_color=self.theme["border"],
            text_color=self.theme["text1"],
            state="readonly"
        ), "output.custom_icon", "textbox")
        self.icon_entry.pack(side="left", fill="x", expand=True)
        
        self.icon_browse_btn = self._register_accessible(ctk.CTkButton(
            icon_row, text=self._tr("actions.browse", "Browse"), width=80,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._browse_icon
        ), "output.custom_icon", "button")
        self.icon_browse_btn.pack(side="left", padx=(4, 0))
        
        self.icon_clear_btn = self._register_accessible(ctk.CTkButton(
            icon_row, text="✕", width=40,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._clear_icon
        ), "actions.clear", "button")
        self.icon_clear_btn.pack(side="left", padx=(4, 0))

        self.icon_extract_btn = self._register_accessible(ctk.CTkButton(
            icon_row, text="From EXE", width=82,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._extract_icon
        ), "actions.from_exe", "button")
        self.icon_extract_btn.pack(side="left", padx=(4, 0))
    
    def _create_options_section(self, parent):
        """Create build options section."""
        card = ctk.CTkFrame(parent, fg_color=self.theme["card"], corner_radius=8)
        card.pack(fill="x", pady=(0, 12))
        
        inner = ctk.CTkFrame(card, fg_color="transparent")
        inner.pack(fill="x", padx=20, pady=16)
        
        # Header with profile selector
        header = ctk.CTkFrame(inner, fg_color="transparent")
        header.pack(fill="x", pady=(0, 10))
        
        ctk.CTkLabel(
            header, text=self._tr("build.options", "🔧 Build Options"),
            font=("Segoe UI", 13, "bold"),
            text_color=self.theme["text1"]
        ).pack(side="left")
        
        ctk.CTkLabel(
            header, text=self._tr("profile", "Profile:"),
            font=("Segoe UI", 10),
            text_color=self.theme["text3"]
        ).pack(side="left", padx=(20, 5))
        
        self.profile_combo = self._register_accessible(ctk.CTkComboBox(
            header, width=140,
            values=self.profiles.names(),
            fg_color=self.theme["input"],
            border_color=self.theme["border"],
            button_color=self.theme["border"],
            button_hover_color=self.theme["card_hover"],
            dropdown_fg_color=self.theme["card"],
            dropdown_hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._on_profile_change
        ), "profile", "combobox")
        self.profile_combo.set(self.settings.get("default_profile", "Default"))
        self.profile_combo.pack(side="left")
        
        self.save_profile_btn = self._register_accessible(ctk.CTkButton(
            header, text="💾", width=32,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._save_profile
        ), "actions.save_profile", "button")
        self.save_profile_btn.pack(side="left", padx=(4, 0))

        ctk.CTkLabel(
            header, text=self._tr("backend", "Backend:"),
            font=("Segoe UI", 10),
            text_color=self.theme["text3"]
        ).pack(side="left", padx=(16, 5))

        self.backend_combo = self._register_accessible(ctk.CTkComboBox(
            header, width=150,
            values=["auto"],
            fg_color=self.theme["input"],
            border_color=self.theme["border"],
            button_color=self.theme["border"],
            button_hover_color=self.theme["card_hover"],
            dropdown_fg_color=self.theme["card"],
            dropdown_hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._on_backend_change
        ), "backend", "combobox")
        self.backend_combo.set("auto")
        self.backend_combo.pack(side="left")
        
        # Checkboxes
        checks = ctk.CTkFrame(inner, fg_color="transparent")
        checks.pack(fill="x")
        
        left_checks = ctk.CTkFrame(checks, fg_color="transparent")
        left_checks.pack(side="left", fill="x", expand=True)
        
        self.console_var = ctk.BooleanVar()
        self.console_check = self._register_accessible(ctk.CTkCheckBox(
            left_checks, text="Console Application",
            variable=self.console_var,
            fg_color=self.theme["green"],
            hover_color=self.theme["green_hover"],
            border_color=self.theme["border"],
            text_color=self.theme["text1"]
        ), "options.console", "checkbox")
        self.console_check.pack(anchor="w", pady=3)
        
        self.admin_var = ctk.BooleanVar()
        self.admin_check = self._register_accessible(ctk.CTkCheckBox(
            left_checks, text="Require Administrator",
            variable=self.admin_var,
            fg_color=self.theme["green"],
            hover_color=self.theme["green_hover"],
            border_color=self.theme["border"],
            text_color=self.theme["text1"]
        ), "options.admin", "checkbox")
        self.admin_check.pack(anchor="w", pady=3)
        
        self.single_var = ctk.BooleanVar(value=True)
        self.single_check = self._register_accessible(ctk.CTkCheckBox(
            left_checks, text="Single File",
            variable=self.single_var,
            fg_color=self.theme["green"],
            hover_color=self.theme["green_hover"],
            border_color=self.theme["border"],
            text_color=self.theme["text1"]
        ), "options.single_file", "checkbox")
        self.single_check.pack(anchor="w", pady=3)
        
        right_checks = ctk.CTkFrame(checks, fg_color="transparent")
        right_checks.pack(side="left", fill="x", expand=True)
        
        self.notify_var = ctk.BooleanVar(value=True)
        self.notify_check = self._register_accessible(ctk.CTkCheckBox(
            right_checks, text="Notify on Complete",
            variable=self.notify_var,
            fg_color=self.theme["green"],
            hover_color=self.theme["green_hover"],
            border_color=self.theme["border"],
            text_color=self.theme["text1"]
        ), "options.notify", "checkbox")
        self.notify_check.pack(anchor="w", pady=3)
    
    def _create_postbuild_section(self, parent):
        """Create post-build action section."""
        card = ctk.CTkFrame(parent, fg_color=self.theme["card"], corner_radius=8)
        card.pack(fill="x", pady=(0, 12))
        
        inner = ctk.CTkFrame(card, fg_color="transparent")
        inner.pack(fill="x", padx=20, pady=16)
        
        ctk.CTkLabel(
            inner, text=self._tr("post_build.action", "⚡ Post-Build Action"),
            font=("Segoe UI", 13, "bold"),
            text_color=self.theme["text1"]
        ).pack(anchor="w", pady=(0, 10))
        
        row = ctk.CTkFrame(inner, fg_color="transparent")
        row.pack(fill="x")
        
        self.postbuild_combo = self._register_accessible(ctk.CTkComboBox(
            row, width=180,
            values=["None", "Open Output Folder", "Copy to Folder..."],
            fg_color=self.theme["input"],
            border_color=self.theme["border"],
            button_color=self.theme["border"],
            button_hover_color=self.theme["card_hover"],
            dropdown_fg_color=self.theme["card"],
            dropdown_hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._on_postbuild_change
        ), "post_build.action", "combobox")
        self.postbuild_combo.set("None")
        self.postbuild_combo.pack(side="left")
        
        self.postbuild_path_entry = self._register_accessible(ctk.CTkEntry(
            row, width=200, height=32,
            fg_color=self.theme["input"],
            border_color=self.theme["border"],
            text_color=self.theme["text1"]
        ), "output.directory", "textbox")
        
        self.postbuild_path_btn = self._register_accessible(ctk.CTkButton(
            row, text="...", width=40,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._browse_postbuild_path
        ), "output.directory", "button")
    
    def _create_metadata_section(self, parent):
        """Create metadata section."""
        card = ctk.CTkFrame(parent, fg_color=self.theme["card"], corner_radius=8)
        card.pack(fill="x", pady=(0, 12))
        
        inner = ctk.CTkFrame(card, fg_color="transparent")
        inner.pack(fill="x", padx=20, pady=16)
        
        ctk.CTkLabel(
            inner, text=self._tr("metadata", "📝 Metadata"),
            font=("Segoe UI", 13, "bold"),
            text_color=self.theme["text1"]
        ).pack(anchor="w", pady=(0, 10))
        
        # Row 1: Product & Version
        row1 = ctk.CTkFrame(inner, fg_color="transparent")
        row1.pack(fill="x", pady=(0, 8))
        
        for label, attr, default, label_key in [
            ("Product Name", "product_entry", "", "metadata.product"),
            ("Version", "version_entry", "1.0.0.0", "metadata.version"),
        ]:
            frame = ctk.CTkFrame(row1, fg_color="transparent")
            frame.pack(side="left", fill="x", expand=True, padx=(0, 8) if attr == "product_entry" else 0)
            
            ctk.CTkLabel(frame, text=self._tr(label_key, label), font=("Segoe UI", 10), text_color=self.theme["text2"]).pack(anchor="w", pady=(0, 4))
            entry = self._register_accessible(ctk.CTkEntry(frame, height=36, fg_color=self.theme["input"], border_color=self.theme["border"], text_color=self.theme["text1"]), label_key, "textbox")
            entry.insert(0, default)
            entry.pack(fill="x")
            setattr(self, attr, entry)
        
        # Row 2: Company & Copyright
        row2 = ctk.CTkFrame(inner, fg_color="transparent")
        row2.pack(fill="x", pady=(0, 8))
        
        for label, attr, label_key in [
            ("Company", "company_entry", "metadata.company"),
            ("Copyright", "copyright_entry", "metadata.copyright"),
        ]:
            frame = ctk.CTkFrame(row2, fg_color="transparent")
            frame.pack(side="left", fill="x", expand=True, padx=(0, 8) if attr == "company_entry" else 0)
            
            ctk.CTkLabel(frame, text=self._tr(label_key, label), font=("Segoe UI", 10), text_color=self.theme["text2"]).pack(anchor="w", pady=(0, 4))
            entry = self._register_accessible(ctk.CTkEntry(frame, height=36, fg_color=self.theme["input"], border_color=self.theme["border"], text_color=self.theme["text1"]), label_key, "textbox")
            entry.pack(fill="x")
            setattr(self, attr, entry)
        
        # Description
        ctk.CTkLabel(inner, text=self._tr("metadata.description", "Description"), font=("Segoe UI", 10), text_color=self.theme["text2"]).pack(anchor="w", pady=(0, 4))
        self.desc_entry = self._register_accessible(ctk.CTkTextbox(
            inner, height=60,
            fg_color=self.theme["input"],
            border_color=self.theme["border"],
            text_color=self.theme["text1"]
        ), "metadata.description", "textbox")
        self.desc_entry.pack(fill="x")
    
    def _create_queue_section(self, parent):
        """Create batch queue section."""
        card = ctk.CTkFrame(parent, fg_color=self.theme["card"], corner_radius=8)
        card.pack(fill="x", pady=(0, 10))
        
        inner = ctk.CTkFrame(card, fg_color="transparent")
        inner.pack(fill="x", padx=12, pady=12)
        
        header = ctk.CTkFrame(inner, fg_color="transparent")
        header.pack(fill="x", pady=(0, 8))
        
        ctk.CTkLabel(
            header, text=self._tr("queue.title", "📋 Batch Queue"),
            font=("Segoe UI", 12, "bold"),
            text_color=self.theme["text1"]
        ).pack(side="left")
        
        self.queue_count_label = ctk.CTkLabel(
            header, text=" (0)",
            font=("Segoe UI", 12),
            text_color=self.theme["text3"]
        )
        self.queue_count_label.pack(side="left")
        
        self.queue_listbox = self._register_accessible(ctk.CTkTextbox(
            inner, height=70,
            fg_color=self.theme["log_bg"],
            text_color=self.theme["text2"],
            font=("Consolas", 10)
        ), "accessibility.queue", "listbox")
        self.queue_listbox.pack(fill="x")
        self.queue_listbox.configure(state="disabled")
        
        btn_row = ctk.CTkFrame(inner, fg_color="transparent")
        btn_row.pack(fill="x", pady=(8, 0))
        
        self.add_queue_btn = self._register_accessible(ctk.CTkButton(
            btn_row, text=self._tr("actions.add", "+ Add"), width=60,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            font=("Segoe UI", 10),
            command=self._add_to_queue
        ), "actions.add", "button")
        self.add_queue_btn.pack(side="left")
        
        self.clear_queue_btn = self._register_accessible(ctk.CTkButton(
            btn_row, text=self._tr("actions.clear", "Clear"), width=60,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            font=("Segoe UI", 10),
            command=self._clear_queue
        ), "actions.clear", "button")
        self.clear_queue_btn.pack(side="left", padx=(4, 0))
    
    def _create_log_section(self, parent):
        """Create build log section."""
        card = ctk.CTkFrame(parent, fg_color=self.theme["card"], corner_radius=8)
        card.pack(fill="both", expand=True, pady=(0, 10))
        
        inner = ctk.CTkFrame(card, fg_color="transparent")
        inner.pack(fill="both", expand=True, padx=12, pady=12)
        
        comparison = ctk.CTkFrame(inner, fg_color="transparent")
        comparison.pack(fill="both", expand=True)
        comparison.grid_columnconfigure(0, weight=1)
        comparison.grid_columnconfigure(1, weight=1)
        comparison.grid_rowconfigure(1, weight=1)

        ctk.CTkLabel(
            comparison, text=self._tr("log.source_preview", "📄 Source Preview"),
            font=("Segoe UI", 11, "bold"),
            text_color=self.theme["text1"]
        ).grid(row=0, column=0, sticky="w", padx=(0, 6), pady=(0, 6))
        self.source_preview = self._register_accessible(ctk.CTkTextbox(
            comparison,
            fg_color=self.theme["log_bg"],
            text_color=self.theme["text2"],
            font=("Consolas", 9)
        ), "log.source_preview", "textbox")
        self.source_preview.grid(row=1, column=0, sticky="nsew", padx=(0, 6))
        self.source_preview.configure(state="disabled")

        log_panel = ctk.CTkFrame(comparison, fg_color="transparent")
        log_panel.grid(row=0, column=1, rowspan=2, sticky="nsew", padx=(6, 0))
        log_panel.grid_rowconfigure(1, weight=1)
        log_panel.grid_columnconfigure(0, weight=1)
        header = ctk.CTkFrame(log_panel, fg_color="transparent")
        header.grid(row=0, column=0, sticky="ew", pady=(0, 6))

        ctk.CTkLabel(
            header, text=self._tr("log.title", "📜 Build Log"),
            font=("Segoe UI", 11, "bold"),
            text_color=self.theme["text1"]
        ).pack(side="left")

        self.jump_error_btn = self._register_accessible(ctk.CTkButton(
            header, text=self._tr("actions.jump_error", "Jump Error"), width=74,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            font=("Segoe UI", 9),
            height=24,
            command=self._jump_to_error,
            state="disabled"
        ), "actions.jump_error", "button")
        self.jump_error_btn.pack(side="left", padx=(8, 0))

        self.clear_log_btn = self._register_accessible(ctk.CTkButton(
            header, text=self._tr("actions.clear", "Clear"), width=50,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            font=("Segoe UI", 9),
            height=24,
            command=self._clear_log
        ), "actions.clear", "button")
        self.clear_log_btn.pack(side="left", padx=(4, 0))

        self.export_log_btn = self._register_accessible(ctk.CTkButton(
            header, text=self._tr("actions.export", "Export"), width=50,
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            font=("Segoe UI", 9),
            height=24,
            command=self._export_log
        ), "actions.export", "button")
        self.export_log_btn.pack(side="left", padx=(4, 0))

        self.log_text = self._register_accessible(ctk.CTkTextbox(
            log_panel,
            fg_color=self.theme["log_bg"],
            text_color=self.theme["text2"],
            font=("Consolas", 10)
        ), "accessibility.log", "log")
        self.log_text.grid(row=1, column=0, sticky="nsew")
        self.error_line: Optional[int] = None
    
    def _create_actions_section(self, parent):
        """Create actions section."""
        actions = ctk.CTkFrame(parent, fg_color="transparent")
        actions.pack(fill="x")
        
        # Progress bar
        self.progress_bar = ctk.CTkProgressBar(
            actions,
            fg_color=self.theme["border"],
            progress_color=self.theme["green"],
            height=6
        )
        self.progress_bar.set(0)
        
        # Status label
        self.status_label = ctk.CTkLabel(
            actions, text=self._tr("status.ready", "Ready"),
            font=("Segoe UI", 10),
            text_color=self.theme["text3"]
        )
        self.status_label.pack(pady=(0, 8))
        
        # Main buttons row
        btn_row1 = ctk.CTkFrame(actions, fg_color="transparent")
        btn_row1.pack(fill="x")
        
        self.manage_deps_btn = self._register_accessible(ctk.CTkButton(
            btn_row1, text=self._tr("actions.manage_dependencies", "Manage Deps"),
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._show_setup
        ), "actions.manage_dependencies", "button")
        self.manage_deps_btn.pack(side="left", fill="x", expand=True, padx=(0, 4))
        
        self.compile_btn = self._register_accessible(ctk.CTkButton(
            btn_row1, text=self._tr("actions.compile", "⚡ Compile"),
            fg_color=self.theme["green"],
            hover_color=self.theme["green_hover"],
            text_color=self.theme["bg"],
            font=("Segoe UI", 12, "bold"),
            command=self._compile,
            state="disabled"
        ), "actions.compile", "button")
        self.compile_btn.pack(side="left", fill="x", expand=True, padx=(4, 4))

        self.cancel_btn = self._register_accessible(ctk.CTkButton(
            btn_row1, text=self._tr("actions.cancel", "Cancel"),
            fg_color=self.theme["red"],
            hover_color=self.theme["red"],
            text_color=self.theme["text1"],
            command=self._cancel_compile,
            state="disabled"
        ), "accessibility.cancel", "button")
        self.cancel_btn.pack(side="left", fill="x", expand=True, padx=(4, 0))
        
        # Compile all button (hidden initially)
        self.compile_all_btn = self._register_accessible(ctk.CTkButton(
            actions, text=self._tr("actions.compile_all", "Compile All in Queue"),
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._compile_all
        ), "actions.compile_all", "button")
        
        # Secondary buttons
        btn_row2 = ctk.CTkFrame(actions, fg_color="transparent")
        btn_row2.pack(fill="x", pady=(8, 0))
        
        self.templates_btn = self._register_accessible(ctk.CTkButton(
            btn_row2, text=self._tr("actions.templates", "📄 Templates"),
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._open_templates
        ), "actions.templates", "button")
        self.templates_btn.pack(side="left", fill="x", expand=True, padx=(0, 4))
        
        self.history_btn = self._register_accessible(ctk.CTkButton(
            btn_row2, text=self._tr("actions.history", "📊 History"),
            fg_color=self.theme["border"],
            hover_color=self.theme["card_hover"],
            text_color=self.theme["text1"],
            command=self._show_history
        ), "actions.history", "button")
        self.history_btn.pack(side="left", fill="x", expand=True, padx=(4, 0))
    
    def _setup_drag_drop(self):
        """Setup drag and drop handling."""
        if not self._has_dnd or not HAS_DND:
            return
        try:
            self.root.drop_target_register(DND_FILES)
            self.root.dnd_bind("<<Drop>>", self._on_drop)
        except Exception as e:
            print(f"Drag & drop setup failed: {e}")
    
    # ========================================================================
    # EVENT HANDLERS
    # ========================================================================
    
    def _on_drop(self, event):
        """Handle file drop."""
        files = self.root.tk.splitlist(event.data)
        if len(files) == 1:
            self._load_file(files[0])
            self.workspace.show_page("build")
        else:
            for f in files:
                self.batch_queue.append(f)
            self._update_queue_display()
            self.workspace.show_page("queue")
            self.log(self.catalog.plural("queue.files", len(files), "{count} files", count=len(files)))
    
    def _browse_source(self):
        """Browse for source file."""
        filetypes = [
            ("All Scripts", "*.ps1 *.py *.bat *.cmd *.js *.ts *.vbs *.ahk *.cs *.go *.rb *.rs *.lua *.pl *.pm *.kt *.kts *.wat"),
            ("All Files", "*.*")
        ]
        filepath = filedialog.askopenfilename(filetypes=filetypes)
        if filepath:
            self._load_file(filepath)
    
    def _show_recent_menu(self):
        """Show recent files menu."""
        recent = self.recent_files.get_all()
        if not recent:
            messagebox.showinfo(
                self._tr("actions.recent", "Recent Files"),
                self._tr("message.no_recent_files", "No recent files"),
            )
            return
        
        menu = tk.Menu(self.root, tearoff=0, bg=self.theme["card"], fg=self.theme["text1"])
        for filepath in recent:
            menu.add_command(
                label=os.path.basename(filepath),
                command=lambda f=filepath: self._load_file(f)
            )
        
        # Position menu below button
        x = self.recent_btn.winfo_rootx()
        y = self.recent_btn.winfo_rooty() + self.recent_btn.winfo_height()
        menu.post(x, y)
    
    def _browse_output_dir(self):
        """Browse for output directory."""
        dirpath = filedialog.askdirectory()
        if dirpath:
            self.output_dir_entry.configure(state="normal")
            self.output_dir_entry.delete(0, "end")
            self.output_dir_entry.insert(0, dirpath)
            self.output_dir_entry.configure(state="readonly")
    
    def _browse_icon(self):
        """Browse for icon file."""
        filepath = filedialog.askopenfilename(filetypes=[("Icons", "*.ico"), ("All Files", "*.*")])
        if filepath:
            self.icon_entry.configure(state="normal")
            self.icon_entry.delete(0, "end")
            self.icon_entry.insert(0, filepath)
            self.icon_entry.configure(state="readonly")
            
            # Show preview
            self.icon_preview_label.configure(text=f"🖼️ {os.path.basename(filepath)}")
            self.icon_preview_frame.pack(fill="x", pady=(10, 0))
    
    def _clear_icon(self):
        """Clear selected icon."""
        self.icon_entry.configure(state="normal")
        self.icon_entry.delete(0, "end")
        self.icon_entry.configure(state="readonly")
        self.icon_preview_frame.pack_forget()

    def _extract_icon(self):
        """Extract an icon from an existing executable for reuse."""
        executable = filedialog.askopenfilename(
            title="Select executable",
            filetypes=[("Executables", "*.exe"), ("All Files", "*.*")],
        )
        if not executable:
            return
        output = filedialog.asksaveasfilename(
            title="Save extracted icon",
            defaultextension=".ico",
            filetypes=[("Icons", "*.ico")],
        )
        if not output:
            return
        try:
            icon_path = extract_icon(executable, output)
        except Exception as error:
            self.log(f"Icon extraction failed: {error}", "error")
            return
        self.icon_entry.configure(state="normal")
        self.icon_entry.delete(0, "end")
        self.icon_entry.insert(0, str(icon_path))
        self.icon_entry.configure(state="readonly")
        self.icon_preview_label.configure(text=f"🖼️ {icon_path.name}")
        self.icon_preview_frame.pack(fill="x", pady=(10, 0))
        self.log(f"Icon extracted: {icon_path}", "success")
    
    def _on_profile_change(self, profile_name: str):
        """Handle profile selection change."""
        profile = self.profiles.get(profile_name)
        if profile:
            self.console_var.set(profile.get("console", False))
            self.admin_var.set(profile.get("admin", False))
            self.single_var.set(profile.get("single_file", True))
            self.version_entry.delete(0, "end")
            self.version_entry.insert(0, profile.get("version", "1.0.0.0"))
            self.company_entry.delete(0, "end")
            self.company_entry.insert(0, profile.get("company", ""))
            self.copyright_entry.delete(0, "end")
            self.copyright_entry.insert(0, profile.get("copyright", ""))
            self.product_entry.delete(0, "end")
            self.product_entry.insert(0, profile.get("product", ""))
            if hasattr(self, "backend_combo"):
                backend = profile.get("backend", "auto")
                values = list(self.backend_combo.cget("values"))
                if backend in values:
                    self.backend_combo.set(backend)
            if hasattr(self, "architecture_combo"):
                architecture = profile.get("architecture", "native")
                if architecture in self.architecture_combo.cget("values"):
                    self.architecture_combo.set(architecture)
            if hasattr(self, "verify_var"):
                self.verify_var.set(bool(profile.get("verify", True)))
            if hasattr(self, "workspace"):
                self.workspace.refresh_build_plan()

    def _on_backend_change(self, backend: str):
        """Refresh the selected source status after a backend switch."""
        if not self.file_type:
            return
        available = DependencyChecker.check_compiler(self.file_type, backend)
        self.compiler_label.configure(
            text=BACKEND_NAMES.get(backend, COMPILERS[self.file_type]["compiler"])
        )
        self.status_label.configure(
            text="Ready" if available else "Compiler not installed",
            text_color=self.theme["green"] if available else self.theme["red"]
        )
        self.compile_btn.configure(state="normal" if available else "disabled")
        if hasattr(self, "workspace"):
            self.workspace.on_backend_changed()
    
    def _save_profile(self):
        """Save current settings as profile."""
        name = self.profile_combo.get()
        if not name:
            name = "Custom"
        
        profile = {
            "console": self.console_var.get(),
            "admin": self.admin_var.get(),
            "single_file": self.single_var.get(),
            "backend": self.backend_combo.get(),
            "architecture": self.architecture_combo.get(),
            "verify": self.verify_var.get(),
            "version": self.version_entry.get(),
            "company": self.company_entry.get(),
            "copyright": self.copyright_entry.get(),
            "product": self.product_entry.get(),
            "description": self.desc_entry.get("1.0", "end-1c"),
        }
        
        self.profiles.set(name, profile)
        
        # Update combo if new profile
        if name not in self.profile_combo.cget("values"):
            values = list(self.profile_combo.cget("values")) + [name]
            self.profile_combo.configure(values=values)
        
        self.log(
            self._tr("message.profile_saved", "Profile '{name}' saved", name=name),
            "success",
        )
    
    def _on_postbuild_change(self, value: str):
        """Handle post-build action change."""
        if value == "Copy to Folder...":
            self.postbuild_path_entry.pack(side="left", padx=(8, 0))
            self.postbuild_path_btn.pack(side="left", padx=(4, 0))
        else:
            self.postbuild_path_entry.pack_forget()
            self.postbuild_path_btn.pack_forget()
    
    def _browse_postbuild_path(self):
        """Browse for post-build copy path."""
        dirpath = filedialog.askdirectory()
        if dirpath:
            self.postbuild_path_entry.delete(0, "end")
            self.postbuild_path_entry.insert(0, dirpath)
    
    def _toggle_theme(self):
        """Open the real settings page at its appearance controls."""
        if hasattr(self, "workspace"):
            self.workspace.show_page("settings")
            self.workspace.scroll_settings_to("appearance")
    
    def _show_settings(self):
        """Navigate to the settings workspace."""
        if hasattr(self, "workspace"):
            self.workspace.show_page("settings")
    
    def _show_setup(self):
        """Show setup window."""
        setup = SetupWindow(self.root, self.theme)
        self.root.wait_window(setup)
        
        # Refresh compiler status
        if self.file_type:
            available = DependencyChecker.check_compiler(
                self.file_type,
                self.backend_combo.get(),
            )
            self.status_label.configure(
                text=self._tr("status.ready", "Ready") if available else self._tr("status.failed", "Compiler not installed"),
                text_color=self.theme["green"] if available else self.theme["red"]
            )
            self.compile_btn.configure(state="normal" if available else "disabled")
        if hasattr(self, "workspace"):
            self.workspace.refresh_toolchains(force=True)
    
    def _add_to_queue(self):
        """Add files to batch queue."""
        filetypes = [
            ("All Scripts", "*.ps1 *.py *.bat *.cmd *.js *.ts *.vbs *.ahk *.cs *.go *.rb *.rs *.lua *.pl *.pm *.kt *.kts *.wat"),
            ("All Files", "*.*")
        ]
        files = filedialog.askopenfilenames(filetypes=filetypes)
        for f in files:
            if f not in self.batch_queue:
                self.batch_queue.append(f)
        self._update_queue_display()
    
    def _clear_queue(self):
        """Clear batch queue."""
        self.batch_queue.clear()
        self._update_queue_display()
    
    def _update_queue_display(self):
        """Refresh the dedicated queue page and navigation badge."""
        if hasattr(self, "workspace"):
            self.workspace.refresh_queue()
    
    def _clear_log(self):
        """Clear build log."""
        self.log_text.delete("1.0", "end")
        self.error_line = None
        self.jump_error_btn.configure(state="disabled")

    def _load_source_preview(self, filepath: str) -> None:
        """Show a bounded, line-numbered source preview beside the log."""
        try:
            lines = Path(filepath).read_text(encoding="utf-8", errors="replace").splitlines()
        except OSError as error:
            lines = [f"Unable to preview source: {error}"]
        preview = "\n".join(
            f"{index:4d} | {line}" for index, line in enumerate(lines[:2000], start=1)
        )
        self.source_preview.configure(state="normal")
        self.source_preview.delete("1.0", "end")
        self.source_preview.insert("1.0", preview)
        self.source_preview.configure(state="disabled")

    def _jump_to_error(self):
        """Scroll the source preview to the first compiler-reported line."""
        if not self.error_line:
            return
        self.source_preview.configure(state="normal")
        self.source_preview.tag_remove("error_line", "1.0", "end")
        self.source_preview.tag_add(
            "error_line",
            f"{self.error_line}.0",
            f"{self.error_line}.end",
        )
        self.source_preview.tag_config("error_line", background=self.theme["border"])
        self.source_preview.see(f"{self.error_line}.0")
        self.source_preview.configure(state="disabled")
    
    def _export_log(self):
        """Export build log."""
        if not self.source_file:
            return
        
        log_content = self.log_text.get("1.0", "end-1c")
        timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
        basename = os.path.splitext(os.path.basename(self.source_file))[0]
        
        desktop = Path.home() / "Desktop"
        log_path = desktop / f"BuildLog_{basename}_{timestamp}.txt"
        
        header = f"""================================================================================
Universal Compiler v{APP_VERSION} - Build Log
================================================================================
Date: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
Source: {self.source_file}
================================================================================

"""
        
        log_path.write_text(header + log_content, encoding="utf-8")
        self.log(f"Log exported to: {log_path}", "success")
        os.startfile(str(desktop))
    
    def _open_templates(self):
        """Navigate to the template browser."""
        if hasattr(self, "workspace"):
            self.workspace.show_page("templates")
    
    def _show_history(self):
        """Navigate to the searchable history workspace."""
        if hasattr(self, "workspace"):
            self.workspace.show_page("history")
    
    # ========================================================================
    # FILE LOADING
    # ========================================================================
    
    def _load_file(self, filepath: str):
        """Load source file."""
        if not os.path.exists(filepath):
            self.log(f"File not found: {filepath}", "error")
            return
        
        self.source_file = filepath
        self.recent_files.add(filepath)
        self._load_source_preview(filepath)
        
        # Update source entry
        self.source_entry.configure(state="normal")
        self.source_entry.delete(0, "end")
        self.source_entry.insert(0, filepath)
        self.source_entry.configure(state="readonly")
        
        # Get file type
        ext = os.path.splitext(filepath)[1].lstrip(".").lower()
        
        if ext in COMPILERS:
            self.file_type = ext
            compiler_info = COMPILERS[ext]
            file_size = os.path.getsize(filepath)
            
            # Update info panel
            self.type_label.configure(text=compiler_info["desc"])
            self.size_label.configure(text=self.catalog.format_size(file_size))
            backend_values = ["auto", *EXTENSION_BACKENDS.get(ext, ())]
            self.backend_combo.configure(values=backend_values)
            if self.backend_combo.get() not in backend_values:
                self.backend_combo.set("auto")
            selected_backend = self.backend_combo.get()
            resolved_backend = self.engine.choose_backend(ext, selected_backend)
            self.compiler_label.configure(
                text=BACKEND_NAMES.get(
                    resolved_backend or selected_backend,
                    compiler_info["compiler"],
                )
            )
            self.est_label.configure(text=core_estimate_output_size(filepath, ext))
            
            # Check compiler availability
            available = DependencyChecker.check_compiler(ext, selected_backend)
            self.status_label.configure(
                text="Ready" if available else "Compiler not installed",
                text_color=self.theme["green"] if available else self.theme["red"]
            )
            
            # Show info panel
            self.info_frame.pack(fill="x", pady=(4, 0))
            
            # Set default output
            self.output_name_entry.delete(0, "end")
            self.output_name_entry.insert(0, os.path.splitext(os.path.basename(filepath))[0] + ".exe")
            
            self.output_dir_entry.configure(state="normal")
            self.output_dir_entry.delete(0, "end")
            self.output_dir_entry.insert(0, os.path.dirname(filepath))
            self.output_dir_entry.configure(state="readonly")
            
            # Enable compile button
            self.compile_btn.configure(state="normal" if available else "disabled")
            
            self.log(f"Loaded: {filepath}", "success")
        else:
            self.file_type = None
            self.info_frame.pack_forget()
            self.compile_btn.configure(state="disabled")
            self.log(f"Unsupported file type: {ext}", "error")
        if hasattr(self, "workspace"):
            self.workspace.on_file_loaded()
    
    # ========================================================================
    # COMPILATION
    # ========================================================================

    def _cancel_compile(self) -> None:
        """Request cancellation without interrupting the UI event loop."""

        if not self.compiling:
            return
        self._cancel_event.set()
        self.cancel_btn.configure(state="disabled")
        self.status_label.configure(text=self._tr("status.cancelling", "Cancelling..."))
        self.log(self._tr("status.cancelling", "Cancelling..."), "warning")
    
    def _compile(self):
        """Compile current file."""
        if self.compiling or not self.source_file or not self.file_type:
            return
        
        self.compiling = True
        self._cancel_event.clear()
        self.compile_btn.configure(state="disabled")
        self.cancel_btn.configure(state="normal")
        
        # Get output path
        output_name = self.output_name_entry.get().strip()
        if not output_name.endswith(".exe"):
            output_name += ".exe"
        output_dir = self.output_dir_entry.get().strip()
        output_path = os.path.join(output_dir, output_name)
        
        # Get options
        icon = self.icon_entry.get().strip() or None
        backend = self.backend_combo.get()
        architecture = self.architecture_combo.get()
        admin = self.admin_var.get()
        console = self.console_var.get()
        single_file = self.single_var.get()
        verify = self.verify_var.get()
        metadata = {
            "product": self.product_entry.get(),
            "version": self.version_entry.get(),
            "company": self.company_entry.get(),
            "copyright": self.copyright_entry.get(),
            "description": self.desc_entry.get("1.0", "end-1c"),
        }
        source_file = self.source_file
        file_type = self.file_type
        profile_name = self.profile_combo.get()
        postbuild = self.postbuild_combo.get()
        copy_path = self.postbuild_path_entry.get()
        notify = self.notify_var.get()

        self.log("=" * 40)
        self.log(f"Source: {source_file}")
        self.log(f"Output: {output_path}")
        self.status_label.configure(text=self._tr("status.compiling", "Compiling..."))
        self.progress_bar.pack(fill="x", pady=(0, 8))
        self.progress_bar.set(0.3)

        def compile_thread():
            try:
                result = Compiler.build_result(
                    source_file,
                    output_path,
                    file_type,
                    icon,
                    admin,
                    console,
                    single_file,
                    metadata,
                    backend=backend,
                    architecture=architecture,
                    verify=verify,
                    cancel_event=self._cancel_event,
                )
                error_text = None
            except Exception as error:
                result = None
                error_text = str(error)
            self._post_ui(
                lambda result=result, error_text=error_text: self._finish_compile(
                    result,
                    error_text,
                    source_file,
                    file_type,
                    output_path,
                    output_name,
                    output_dir,
                    profile_name,
                    postbuild,
                    copy_path,
                    notify,
                )
            )

        threading.Thread(target=compile_thread, daemon=True).start()

    def _finish_compile(
        self,
        result: Optional[BuildResult],
        error_text: Optional[str],
        source_file: str,
        file_type: str,
        output_path: str,
        output_name: str,
        output_dir: str,
        profile_name: str,
        postbuild: str,
        copy_path: str,
        notify: bool,
    ) -> None:
        """Apply a worker result on Tk's event-loop thread."""

        try:
            self.progress_bar.set(0.9)
            if result:
                self.log(f"Correlation: {result.correlation_id}", "info")
            success = bool(result and result.success and os.path.isfile(output_path))
            if success:
                file_size = os.path.getsize(output_path)
                self.log("=" * 40, "success")
                self.log("BUILD SUCCESSFUL", "success")
                self.log(f"Size: {self.catalog.format_size(file_size)}", "success")
                if result and result.message:
                    self.log(result.message)
                self.history.add(
                    source_file,
                    output_path,
                    file_type,
                    True,
                    profile_name,
                    file_size,
                )
                if postbuild == "Open Output Folder":
                    os.startfile(output_dir)
                elif postbuild == "Copy to Folder..." and copy_path:
                    shutil.copy(output_path, copy_path)
                    self.log(f"Copied to {copy_path}")
                if notify:
                    show_notification(
                        self._tr("message.build_success", "{name} compiled successfully", name=output_name),
                        self._tr("status.complete", "Complete!"),
                    )
            else:
                self.log(self._tr("status.failed", "Failed"), "error")
                details = error_text or (result.message if result else "Unknown build error")
                if result:
                    for command in result.commands:
                        if command.output:
                            details += f"\n{command.output}"
                self.log(details, "error")
                self.history.add(
                    source_file,
                    output_path,
                    file_type,
                    False,
                    profile_name,
                    0,
                )
                if notify:
                    show_notification(
                        self._tr("status.failed", "Failed"),
                        self._tr("message.build_failed", "Compilation failed"),
                    )
        finally:
            self.progress_bar.set(1.0)
            self.root.after(500, lambda: self.progress_bar.pack_forget())
            self.status_label.configure(text=self._tr("status.ready", "Ready"))
            self.compiling = False
            self.compile_btn.configure(state="normal")
            self.cancel_btn.configure(state="disabled")
            self._cancel_event.clear()
            if hasattr(self, "workspace"):
                self.workspace.on_history_changed()
    
    def _compile_all(self):
        """Compile all files in queue."""
        if not self.batch_queue:
            return
        
        self.compile_all_btn.configure(state="disabled")
        total = len(self.batch_queue)
        done = 0
        
        for filepath in self.batch_queue.copy():
            self._load_file(filepath)
            if self.file_type and DependencyChecker.check_compiler(self.file_type):
                self._compile()
                # Wait for compilation to complete
                while self.compiling:
                    self.root.update()
                done += 1
        
        self.batch_queue.clear()
        self._update_queue_display()
        self.log(
            self._tr(
                "message.batch_complete",
                "{count} of {total} files compiled",
                count=done,
                total=total,
            ),
            "success",
        )
        
        if self.notify_var.get():
            show_notification(
                self._tr("status.complete", "Batch Complete"),
                self._tr(
                    "message.batch_complete",
                    "{count} of {total} files compiled",
                    count=done,
                    total=total,
                ),
            )
    
    # ========================================================================
    # LOGGING
    # ========================================================================
    
    def log(self, message: str, level: str = "info"):
        """Add message to build log."""
        timestamp = self.catalog.format_datetime(datetime.now()).split(" ", 1)[-1]
        prefix = {"info": "[*]", "success": "[OK]", "warning": "[!]", "error": "[X]"}.get(level, "[*]")

        if level == "error":
            match = re.search(r"(?:line\s+|:)(\d+)\b", message, re.IGNORECASE)
            if match:
                self.error_line = int(match.group(1))
                self.jump_error_btn.configure(state="normal")
        
        self.log_text.insert("end", f"{timestamp} {prefix} {message}\n")
        self.log_text.see("end")

    def _gui_option_value(self, name: str) -> Optional[str]:
        """Return a value for a private GUI verification option."""

        try:
            index = sys.argv.index(name)
        except ValueError:
            return None
        if index + 1 >= len(sys.argv):
            raise ValueError(f"{name} requires a value")
        return sys.argv[index + 1]

    def _prepare_ui_snapshot_fixture(self) -> None:
        """Populate deterministic, privacy-safe display data for visual QA."""

        self._ui_snapshot_mode = True
        self.source_file = r"C:\Projects\tools\release-tool.py"
        self.file_type = "py"
        self.source_entry.configure(state="normal")
        self.source_entry.delete(0, "end")
        self.source_entry.insert(0, self.source_file)
        self.source_entry.configure(state="readonly")
        self.type_label.configure(text="Python Application")
        self.size_label.configure(text="18.4 KB")
        self.compiler_label.configure(text="PyInstaller")
        self.est_label.configure(text="24.7 MB")
        self.info_frame.pack(fill="x", pady=(4, 0))
        self.backend_combo.configure(values=["auto", "pyinstaller", "nuitka", "python-zipapp", "pex"])
        self.backend_combo.set("pyinstaller")
        self.architecture_combo.set("x64")
        self.output_name_entry.delete(0, "end")
        self.output_name_entry.insert(0, "release-tool.exe")
        self.output_dir_entry.configure(state="normal")
        self.output_dir_entry.delete(0, "end")
        self.output_dir_entry.insert(0, r"C:\Artifacts\dist")
        self.output_dir_entry.configure(state="readonly")
        self.compile_btn.configure(state="normal")
        self.status_label.configure(text="Ready", text_color=self.theme["green"])
        self.log_text.delete("1.0", "end")
        self.log_text.insert(
            "1.0",
            "12:45:10 [*] Source loaded: release-tool.py (18.4 KB)\n"
            "12:45:11 [*] Analyzing dependencies in offline mode\n"
            "12:45:12 [*] Packaging with PyInstaller for Windows x64\n"
            "12:45:15 [OK] Build plan validated. Ready to build.\n",
        )
        self.source_preview.configure(state="normal")
        self.source_preview.delete("1.0", "end")
        self.source_preview.insert(
            "1.0",
            "   1 | from pathlib import Path\n"
            "   2 |\n"
            "   3 | def main() -> None:\n"
            "   4 |     print('Release tool ready')\n"
            "   5 |\n"
            "   6 | if __name__ == '__main__':\n"
            "   7 |     main()\n",
        )
        self.source_preview.configure(state="disabled")
        self.workspace.refresh_build_plan()

        self.batch_queue = [
            r"C:\Projects\tools\release-tool.py",
            r"C:\Projects\scripts\inventory.ps1",
            r"C:\Projects\services\worker.go",
            r"C:\Projects\web\bundle.js",
        ]
        self.workspace.queue_selected_index = 0
        self.workspace.snapshot_history = [
            {"timestamp": "2026-08-08T12:45:15", "source": r"C:\Projects\tools\release-tool.py", "output": r"C:\Artifacts\release-tool.exe", "type": "pyinstaller", "success": True, "profile": "Default", "size": 25_899_008},
            {"timestamp": "2026-08-08T11:09:00", "source": r"C:\Projects\scripts\inventory.ps1", "output": r"C:\Artifacts\inventory.exe", "type": "ps2exe", "success": True, "profile": "Default", "size": 5_242_880},
            {"timestamp": "2026-08-07T17:20:00", "source": r"C:\Projects\services\worker.go", "output": r"C:\Artifacts\worker.exe", "type": "go", "success": False, "profile": "Default", "size": 0},
            {"timestamp": "2026-08-07T14:06:00", "source": r"C:\Projects\web\bundle.js", "output": r"C:\Artifacts\bundle.exe", "type": "bun", "success": True, "profile": "Default", "size": 47_185_920},
            {"timestamp": "2026-08-06T09:42:00", "source": r"C:\Projects\tasks\cleanup.bat", "output": r"C:\Artifacts\cleanup.exe", "type": "iexpress", "success": True, "profile": "Default", "size": 1_048_576},
        ]
        self.workspace.history_selected_index = 0
        self.workspace.toolchain_data = {
            "pyinstaller": {"name": "Python PyInstaller", "lifecycle": "stable", "available": True, "verified_version": "6.21.0", "target_platforms": ["native", "windows"], "extensions": ["py", "pyw"], "architectures": ["native", "x64"], "required_sdks": ["Python 3.10+"], "default": True},
            "ps2exe": {"name": "PowerShell PS2EXE", "lifecycle": "stable", "available": True, "verified_version": "1.12.0", "target_platforms": ["windows"], "extensions": ["ps1"], "architectures": ["native", "x64"], "required_sdks": ["PowerShell"], "default": True},
            "bun": {"name": "Bun", "lifecycle": "stable", "available": False, "verified_version": None, "target_platforms": ["windows", "linux", "darwin"], "extensions": ["js", "ts"], "architectures": ["native", "x64"], "required_sdks": ["Bun"], "default": True},
            "go": {"name": "Go", "lifecycle": "stable", "available": True, "verified_version": "1.22.5", "target_platforms": ["windows", "linux", "darwin"], "extensions": ["go"], "architectures": ["native", "x64", "arm64"], "required_sdks": ["Go SDK"], "default": True},
            "node-sea": {"name": "Node SEA", "lifecycle": "experimental", "available": False, "verified_version": None, "target_platforms": ["windows"], "extensions": ["js"], "architectures": ["native", "x64"], "required_sdks": ["Node.js", "postject"], "default": False},
            "pex": {"name": "PEX", "lifecycle": "experimental", "available": False, "verified_version": None, "target_platforms": ["native", "windows", "linux"], "extensions": ["py", "pyw"], "architectures": ["native"], "required_sdks": ["Python", "PEX"], "default": False},
            "pkg": {"name": "Node pkg", "lifecycle": "deprecated", "available": True, "verified_version": "5.8.1", "target_platforms": ["windows"], "extensions": ["js"], "architectures": ["native", "x64"], "required_sdks": ["Node.js"], "default": False},
            "wat2wasm": {"name": "wat2wasm", "lifecycle": "stable", "available": True, "verified_version": "1.0.35", "target_platforms": ["wasm", "wasi"], "extensions": ["wat"], "architectures": ["wasm32"], "required_sdks": ["WABT"], "default": True},
        }
        self.workspace.toolchain_selected = "pyinstaller"
        python_template = TEMPLATES_DIR / "HelloWorld.py"
        if python_template.is_file():
            self.workspace.template_selected = python_template

    def _finish_ui_snapshot(self) -> None:
        """Stop a private-desktop snapshot run without leaving DPI callbacks."""

        # CustomTkinter keeps a process-global DPI poller registered against
        # every CTk root.  Remove this root before leaving the main loop so a
        # pending callback cannot run against a partially torn-down Tcl app.
        ctk.ScalingTracker.remove_window(None, self.root)
        self.root.quit()
        # This path exists only in the short-lived private verification process.
        # A hard process exit avoids Tcl/customtkinter interpreter finalizers
        # running after the private desktop and HWND have been released.
        os._exit(1 if self._ui_snapshot_error is not None else 0)

    def _capture_ui_pages(
        self,
        destination: Path,
        pages: tuple[str, ...] | None = None,
    ) -> None:
        """Capture each page from its own private-desktop window handle."""

        from PIL import ImageGrab

        pages = pages or (
            "build",
            "queue",
            "history",
            "toolchains",
            "templates",
            "settings",
        )
        destination.mkdir(parents=True, exist_ok=True)

        def capture_window():
            client_handle = self.root.winfo_id()
            capture_handle = client_handle
            if os.name == "nt":
                user32 = ctypes.windll.user32
                top_level_handle = user32.GetAncestor(client_handle, 2)
                if top_level_handle:
                    capture_handle = top_level_handle
                user32.RedrawWindow(
                    capture_handle,
                    None,
                    None,
                    0x0001 | 0x0080 | 0x0100 | 0x0400,
                )
            return ImageGrab.grab(
                window=capture_handle,
                include_layered_windows=True,
            )

        def stage(index: int) -> None:
            if index >= len(pages):
                # Leave the verified HWND alive long enough for the isolation
                # harness to finish its independent placement proof.
                self.root.after(5000, self._finish_ui_snapshot)
                return
            page = pages[index]
            try:
                self.workspace.show_page(page)
                if page == "toolchains":
                    self.workspace._populate_toolchains(self.workspace.toolchain_data)
            except Exception as error:
                (destination / "capture-error.json").write_text(
                    json.dumps({"page": page, "error": repr(error)}, indent=2),
                    encoding="utf-8",
                )
                self._ui_snapshot_error = error
                self._finish_ui_snapshot()
                return
            current = self.workspace.pages[page]
            try:
                current._parent_canvas.yview_moveto(0.0)
            except (AttributeError, tk.TclError):
                pass
            self.root.update_idletasks()

            def draw_widget_tree(widget: Any) -> None:
                draw = getattr(widget, "_draw", None)
                if callable(draw):
                    try:
                        draw()
                    except (tk.TclError, TypeError, ValueError):
                        pass
                try:
                    children = widget.winfo_children()
                except (AttributeError, tk.TclError):
                    return
                for child in children:
                    draw_widget_tree(child)

            def redraw() -> None:
                draw_widget_tree(self.root)
                self.root.update()

            def capture() -> None:
                try:
                    redraw()
                    image = capture_window()
                    image.save(destination / f"{page}.png")
                    image.close()
                except Exception as error:
                    (destination / "capture-error.json").write_text(
                        json.dumps(
                            {"page": page, "error": repr(error)},
                            indent=2,
                        ),
                        encoding="utf-8",
                    )
                    self._ui_snapshot_error = error
                    self._finish_ui_snapshot()
                    return
                # Give CustomTkinter a full paint cycle after changing the
                # scrollable page. Rapid page swaps can otherwise leave the
                # next capture with stale title pixels on private desktops.
                self.root.after(400, lambda: stage(index + 1))

            def prime() -> None:
                try:
                    redraw()
                    preview = capture_window()
                    preview.close()
                except Exception as error:
                    (destination / "capture-error.json").write_text(
                        json.dumps({"page": page, "error": repr(error)}, indent=2),
                        encoding="utf-8",
                    )
                    self._ui_snapshot_error = error
                    self._finish_ui_snapshot()
                    return
                self.root.after(300, capture)

            self.root.after(350, prime)

        stage(0)
    
    # ========================================================================
    # RUN
    # ========================================================================
    
    def run(self):
        """Start the application."""
        # Initial log messages
        self.log(
            f"{self._tr('app.title', APP_NAME)} v{APP_VERSION} "
            f"{self._tr('status.ready', 'Ready')}",
            "success",
        )
        self.log(self._tr("message.drag_hint", "Drag files here or click Browse"))
        
        if DependencyChecker.check_ps2exe():
            self.log("PS2EXE: Ready", "success")
        else:
            self.log("PS2EXE: Not installed", "warning")

        snapshot_dir = self._gui_option_value("--ui-snapshot-dir")
        if snapshot_dir:
            self._ui_snapshot_error: Optional[Exception] = None
            self._prepare_ui_snapshot_fixture()
            snapshot_page = self._gui_option_value("--ui-snapshot-page")
            available_pages = tuple(self.workspace.pages)
            if snapshot_page and snapshot_page not in available_pages:
                raise ValueError(
                    "--ui-snapshot-page must be one of: "
                    + ", ".join(available_pages)
                )
            capture_pages = (snapshot_page,) if snapshot_page else available_pages
            # Selecting before the first mapped frame avoids stale child-canvas
            # pixels when PrintWindow captures a page on a private desktop.
            self.workspace.show_page(capture_pages[0])
            self.root.after(
                1400,
                lambda: self._capture_ui_pages(Path(snapshot_dir), capture_pages),
            )
        self.root.mainloop()
        if snapshot_dir:
            snapshot_error = self._ui_snapshot_error
            self.root.destroy()
            if snapshot_error is not None:
                raise RuntimeError("Private-desktop UI capture failed") from snapshot_error


# ============================================================================
# ENTRY POINT
# ============================================================================

if __name__ == "__main__":
    app = UniversalCompiler()
    app.run()