Update app.py

app.py

@@ -1,6 +1,7 @@
-# app.py (Full Code - Fixes Applied, Single Statements per Line)
+# app.py (Re-integrated WebSockets for 3D Sync)
 import streamlit as st
 import asyncio
+import websockets # Re-added
 import uuid
 from datetime import datetime
 import os
@@ -21,28 +22,19 @@ import threading
 import json
 import zipfile
 from dotenv import load_dotenv
-# from streamlit_marquee import streamlit_marquee # Import if needed
+# from streamlit_marquee import streamlit_marquee
 from collections import defaultdict, Counter, deque
-from streamlit_js_eval import streamlit_js_eval # Correct import
+from streamlit_js_eval import streamlit_js_eval # Keep for UI interaction if needed
 from PIL import Image
 
 # ==============================================================================
 # Configuration & Constants
 # ==============================================================================
-
-# 🛠️ Patch asyncio for nesting
+st.set_page_config(page_title="🏗️ Live World Builder ⚡", page_icon="🏗️", layout="wide", initial_sidebar_state="expanded")
 nest_asyncio.apply()
 
-# 🎨 Page Config
-st.set_page_config(
-    page_title="🏗️ World Action Builder 🏆",
-    page_icon="🏗️",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
 # General Constants
-Site_Name = '🏗️ World Action Builder'
+Site_Name = '🏗️ Live World Builder ⚡'
 MEDIA_DIR = "."
 STATE_FILE = "user_state.txt"
 DEFAULT_TTS_VOICE = "en-US-AriaNeural"
@@ -56,7 +48,7 @@ SAVED_WORLDS_DIR = "saved_worlds"
 # World Builder Constants
 PLOT_WIDTH = 50.0
 PLOT_DEPTH = 50.0
-WORLD_STATE_FILE_MD_PREFIX = "🌍_"
+WORLD_STATE_FILE_MD_PREFIX = "🌌_" # Keep prefix for saved files
 MAX_ACTION_LOG_SIZE = 30
 
 # User/Chat Constants
@@ -64,13 +56,11 @@ FUN_USERNAMES = {
     "BuilderBot 🤖": "en-US-AriaNeural", "WorldWeaver 🕸️": "en-US-JennyNeural",
     "Terraformer 🌱": "en-GB-SoniaNeural", "SkyArchitect ☁️": "en-AU-NatashaNeural",
     "PixelPainter 🎨": "en-CA-ClaraNeural", "VoxelVortex 🌪️": "en-US-GuyNeural",
-    "CosmicCrafter ✨": "en-GB-RyanNeural", "GeoGuru 🗺️": "en-AU-WilliamNeural",
-    "BlockBard 🧱": "en-CA-LiamNeural", "SoundSculptor 🔊": "en-US-AnaNeural",
-}
+} # Simplified list
 EDGE_TTS_VOICES = list(set(FUN_USERNAMES.values()))
 
 # File Emojis
-FILE_EMOJIS = {"md": "📝", "mp3": "🎵", "png": "🖼️", "mp4": "🎥", "zip": "📦", "json": "📄"}
+FILE_EMOJIS = {"md": "📜", "mp3": "🎵", "png": "🖼️", "mp4": "🎥", "zip": "📦", "json": "📄"}
 
 # Primitives Map
 PRIMITIVE_MAP = {
@@ -82,110 +72,130 @@ PRIMITIVE_MAP = {
 TOOLS_MAP = {"None": "🚫"}
 TOOLS_MAP.update({name: emoji for emoji, name in PRIMITIVE_MAP.items()})
 
-# --- Ensure Directories Exist ---
 for d in [CHAT_DIR, AUDIO_DIR, AUDIO_CACHE_DIR, SAVED_WORLDS_DIR]:
     os.makedirs(d, exist_ok=True)
-
-# --- API Keys (Placeholder) ---
 load_dotenv()
 
-# --- Lock for Action Log (Session State is generally per-session, but use if needed) ---
-# action_log_lock = threading.Lock() # Usually not needed for session_state modifications
+# --- Global State (WebSocket Client Tracking Only) ---
+clients_lock = threading.Lock()
+connected_clients = set() # Holds client_id strings (websocket.id)
 
 # ==============================================================================
-# Utility Functions
+# Utility Functions (Keep relevant ones)
 # ==============================================================================
-
 def get_current_time_str(tz='UTC'):
-    """Gets formatted timestamp string in specified timezone (default UTC)."""
-    try:
-        timezone = pytz.timezone(tz)
-        now_aware = datetime.now(timezone)
-    except pytz.UnknownTimeZoneError:
-        now_aware = datetime.now(pytz.utc)
-    except Exception as e:
-        print(f"Timezone error ({tz}), using UTC. Error: {e}")
-        now_aware = datetime.now(pytz.utc)
+    try: timezone = pytz.timezone(tz); now_aware = datetime.now(timezone)
+    except Exception: now_aware = datetime.now(pytz.utc)
     return now_aware.strftime('%Y%m%d_%H%M%S')
 
 def clean_filename_part(text, max_len=25):
-    """Cleans a string part for use in a filename."""
     if not isinstance(text, str): text = "invalid_name"
-    text = re.sub(r'\s+', '_', text)
-    text = re.sub(r'[^\w\-.]', '', text)
+    text = re.sub(r'\s+', '_', text); text = re.sub(r'[^\w\-.]', '', text)
     return text[:max_len]
 
 def run_async(async_func, *args, **kwargs):
     """Runs an async function safely from a sync context using create_task or asyncio.run."""
-    # This helper attempts to schedule the async function as a background task.
-    # Note: Background tasks in Streamlit might have limitations accessing session state later.
-    try:
-        loop = asyncio.get_running_loop()
-        # Create task to run concurrently
-        return loop.create_task(async_func(*args, **kwargs))
-    except RuntimeError: # No running loop in this thread
-        # Fallback: Run in a new loop (blocks until completion)
-        # print(f"Warning: Running async func {async_func.__name__} in new event loop.")
-        try:
-            return asyncio.run(async_func(*args, **kwargs))
-        except Exception as e:
-            print(f"Error running async func {async_func.__name__} in new loop: {e}")
-            return None
-    except Exception as e:
-        print(f"Error scheduling async task {async_func.__name__}: {e}")
-        return None
-
-def ensure_dir(dir_path):
-    """Creates directory if it doesn't exist."""
-    os.makedirs(dir_path, exist_ok=True)
+    try: loop = asyncio.get_running_loop(); return loop.create_task(async_func(*args, **kwargs))
+    except RuntimeError:
+        try: return asyncio.run(async_func(*args, **kwargs))
+        except Exception as e: print(f"❌ Error run_async new loop: {e}"); return None
+    except Exception as e: print(f"❌ Error run_async schedule task: {e}"); return None
+
+def ensure_dir(dir_path): os.makedirs(dir_path, exist_ok=True)
 
 # ==============================================================================
-# World State File Handling (Markdown + JSON)
+# World State Manager (Using st.cache_resource)
 # ==============================================================================
 
+# Function to load initial state from the most recent file
+# Separated from the cache resource function itself
+def load_initial_world_from_file():
+    """Loads the state from the most recent MD file found."""
+    print(f"[{time.time():.1f}] Attempting to load initial world state from files...")
+    loaded_state = defaultdict(dict)
+    saved_worlds = get_saved_worlds() # Assumes get_saved_worlds is defined below
+    if saved_worlds:
+        latest_world_file_basename = os.path.basename(saved_worlds[0]['filename'])
+        print(f"Found most recent file: {latest_world_file_basename}")
+        load_path = os.path.join(SAVED_WORLDS_DIR, latest_world_file_basename)
+        if os.path.exists(load_path):
+            try:
+                with open(load_path, 'r', encoding='utf-8') as f: content = f.read()
+                json_match = re.search(r"```json\s*(\{[\s\S]*?\})\s*```", content, re.IGNORECASE)
+                if json_match:
+                    world_data_dict = json.loads(json_match.group(1))
+                    for k, v in world_data_dict.items(): loaded_state[str(k)] = v
+                    print(f"Successfully loaded {len(loaded_state)} objects for initial state.")
+                else: print("No JSON block found in initial file.")
+            except Exception as e: print(f"Error parsing initial world file {latest_world_file_basename}: {e}")
+        else: print(f"Most recent file {latest_world_file_basename} not found at path {load_path}.")
+    else: print("No saved world files found to load initial state.")
+    return loaded_state
+
+@st.cache_resource(ttl=3600) # Cache resource for 1 hour
+def get_world_state_manager():
+    """
+    Initializes and returns the shared world state dictionary and its lock.
+    Loads initial state from the most recent file on first creation.
+    """
+    print(f"[{time.time():.1f}] --- Initializing/Retrieving Shared World State Resource ---")
+    manager = {
+        "lock": threading.Lock(),
+        "state": load_initial_world_from_file() # Load initial state here
+    }
+    # Set initial current_world_file if state was loaded successfully
+    if manager["state"]:
+         saved_worlds = get_saved_worlds()
+         if saved_worlds:
+              latest_world_file_basename = os.path.basename(saved_worlds[0]['filename'])
+              if 'current_world_file' not in st.session_state: # Initialize only if not set
+                   st.session_state.current_world_file = latest_world_file_basename
+                   print(f"Set initial current_world_file state to: {latest_world_file_basename}")
+
+    return manager
+
+def get_current_world_state_copy():
+    """Safely gets a copy of the current world state dictionary."""
+    manager = get_world_state_manager()
+    with manager["lock"]:
+        return dict(manager["state"]) # Return a copy
+
+# ==============================================================================
+# World State File Handling (Refactored for Cached State)
+# ==============================================================================
 def generate_world_save_filename(username="User", world_name="World"):
-    """Generates a filename for saving world state MD files."""
-    timestamp = get_current_time_str()
-    clean_user = clean_filename_part(username, 15)
-    clean_world = clean_filename_part(world_name, 20)
-    rand_hash = hashlib.md5(str(time.time()).encode() + username.encode() + world_name.encode()).hexdigest()[:4]
+    timestamp = get_current_time_str(); clean_user = clean_filename_part(username, 15);
+    clean_world = clean_filename_part(world_name, 20);
+    rand_hash = hashlib.md5(str(time.time()).encode()+username.encode()+world_name.encode()).hexdigest()[:4]
     return f"{WORLD_STATE_FILE_MD_PREFIX}{clean_world}_by_{clean_user}_{timestamp}_{rand_hash}.md"
 
 def parse_world_filename(filename):
-    """Extracts info from filename if possible, otherwise returns defaults."""
     basename = os.path.basename(filename)
     if basename.startswith(WORLD_STATE_FILE_MD_PREFIX) and basename.endswith(".md"):
-        core = basename[len(WORLD_STATE_FILE_MD_PREFIX):-3]
-        parts = core.split('_')
+        core = basename[len(WORLD_STATE_FILE_MD_PREFIX):-3]; parts = core.split('_')
         if len(parts) >= 5 and parts[-3] == "by":
-            timestamp_str = parts[-2]
-            username = parts[-4]
-            world_name = " ".join(parts[:-4])
-            dt_obj = None
-            try:
-                dt_obj = pytz.utc.localize(datetime.strptime(timestamp_str, '%Y%m%d_%H%M%S'))
-            except Exception:
-                dt_obj = None
+            timestamp_str = parts[-2]; username = parts[-4]; world_name = " ".join(parts[:-4]); dt_obj = None
+            try: dt_obj = pytz.utc.localize(datetime.strptime(timestamp_str, '%Y%m%d_%H%M%S'))
+            except Exception: dt_obj = None
             return {"name": world_name or "Untitled", "user": username, "timestamp": timestamp_str, "dt": dt_obj, "filename": filename}
-
     # Fallback
-    dt_fallback = None
-    try:
-        mtime = os.path.getmtime(filename)
-        dt_fallback = datetime.fromtimestamp(mtime, tz=pytz.utc)
-    except Exception:
-        pass
+    dt_fallback = None; try: mtime = os.path.getmtime(filename); dt_fallback = datetime.fromtimestamp(mtime, tz=pytz.utc)
+    except Exception: pass
     return {"name": basename.replace('.md','').replace(WORLD_STATE_FILE_MD_PREFIX, ''), "user": "Unknown", "timestamp": "Unknown", "dt": dt_fallback, "filename": filename}
 
 
-def save_world_to_md(target_filename_base, world_data_dict):
-    """Saves the provided world state dictionary to a specific MD file."""
+def save_world_state_to_md(target_filename_base):
+    """Saves the current cached world state to a specific MD file."""
+    manager = get_world_state_manager() # Get resource
     save_path = os.path.join(SAVED_WORLDS_DIR, target_filename_base)
-    print(f"Saving {len(world_data_dict)} objects to MD file: {save_path}...")
+    print(f"💾 Acquiring lock to save world state to: {save_path}...")
     success = False
-    parsed_info = parse_world_filename(save_path)
-    timestamp_save = get_current_time_str()
-    md_content = f"""# World State: {parsed_info['name']} by {parsed_info['user']}
+    with manager["lock"]: # Use resource's lock
+        world_data_dict = dict(manager["state"]) # Get copy from resource state
+        print(f"💾 Saving {len(world_data_dict)} objects...")
+        parsed_info = parse_world_filename(save_path)
+        timestamp_save = get_current_time_str()
+        md_content = f"""# World State: {parsed_info['name']} by {parsed_info['user']}
 * **File Saved:** {timestamp_save} (UTC)
 * **Source Timestamp:** {parsed_info['timestamp']}
 * **Objects:** {len(world_data_dict)}
@@ -193,42 +203,39 @@ def save_world_to_md(target_filename_base, world_data_dict):
 ```json
 {json.dumps(world_data_dict, indent=2)}
 ```"""
-    try:
-        ensure_dir(SAVED_WORLDS_DIR);
-        with open(save_path, 'w', encoding='utf-8') as f:
-            f.write(md_content)
-        print(f"World state saved successfully to {target_filename_base}")
-        success = True
-    except Exception as e:
-        print(f"Error saving world state to {save_path}: {e}")
+        try:
+            ensure_dir(SAVED_WORLDS_DIR);
+            with open(save_path, 'w', encoding='utf-8') as f: f.write(md_content)
+            print(f"✅ World state saved successfully to {target_filename_base}")
+            success = True
+        except Exception as e: print(f"❌ Error saving world state to {save_path}: {e}")
     return success
 
-
-def load_world_from_md(filename_base):
-    """Loads world state dict from an MD file (basename), returns dict or None."""
+def load_world_state_from_md(filename_base):
+    """Loads world state from MD, updates cached state, returns success bool."""
+    manager = get_world_state_manager() # Get resource
     load_path = os.path.join(SAVED_WORLDS_DIR, filename_base)
-    print(f"Loading world state dictionary from MD file: {load_path}...")
-    if not os.path.exists(load_path):
-        st.error(f"World file not found: {filename_base}")
-        return None
+    print(f"📜 Loading world state from MD file: {load_path}...")
+    if not os.path.exists(load_path): st.error(f"World file not found: {filename_base}"); return False
     try:
-        with open(load_path, 'r', encoding='utf-8') as f:
-            content = f.read()
-        # Find JSON block more robustly
+        with open(load_path, 'r', encoding='utf-8') as f: content = f.read()
         json_match = re.search(r"```json\s*(\{[\s\S]*?\})\s*```", content, re.IGNORECASE)
-        if not json_match:
-            st.error(f"Could not find valid JSON block in {filename_base}")
-            return None
+        if not json_match: st.error(f"Could not find JSON block in {filename_base}"); return False
         world_data_dict = json.loads(json_match.group(1))
-        print(f"Parsed {len(world_data_dict)} objects from {filename_base}.")
-        return world_data_dict # Return the dictionary
-    except json.JSONDecodeError as e:
-        st.error(f"Invalid JSON found in {filename_base}: {e}")
-        return None
-    except Exception as e:
-        st.error(f"Error loading world state from {filename_base}: {e}")
-        st.exception(e)
-        return None
+
+        print(f"⚙️ Acquiring lock to update cached world state from {filename_base}...")
+        with manager["lock"]: # Use resource's lock
+             manager["state"].clear() # Clear the existing cached state dict
+             for k, v in world_data_dict.items(): manager["state"][str(k)] = v # Update with loaded data
+             loaded_count = len(manager["state"])
+        print(f"✅ Loaded {loaded_count} objects into cached state. Lock released.")
+        st.session_state.current_world_file = filename_base # Track loaded file
+        # Consider clearing the cache resource if behavior is unexpected after loading?
+        # get_world_state_manager.clear() # <-- Use this if needed to force re-init on next access
+        return True
+
+    except json.JSONDecodeError as e: st.error(f"Invalid JSON in {filename_base}: {e}"); return False
+    except Exception as e: st.error(f"Error loading world state from {filename_base}: {e}"); st.exception(e); return False
 
 def get_saved_worlds():
     """Scans the saved worlds directory for world MD files and parses them."""
@@ -236,13 +243,9 @@ def get_saved_worlds():
         ensure_dir(SAVED_WORLDS_DIR);
         world_files = glob.glob(os.path.join(SAVED_WORLDS_DIR, f"{WORLD_STATE_FILE_MD_PREFIX}*.md"))
         parsed_worlds = [parse_world_filename(f) for f in world_files]
-        # Sort by datetime object (newest first), handle None dt values
         parsed_worlds.sort(key=lambda x: x['dt'] if x['dt'] else datetime.min.replace(tzinfo=pytz.utc), reverse=True)
         return parsed_worlds
-    except Exception as e:
-        print(f"Error scanning saved worlds: {e}")
-        st.error(f"Could not scan saved worlds: {e}")
-        return []
+    except Exception as e: print(f"❌ Error scanning saved worlds: {e}"); st.error(f"Could not scan saved worlds: {e}"); return []
 
 # ==============================================================================
 # User State & Session Init
@@ -250,39 +253,37 @@ def get_saved_worlds():
 def save_username(username):
     try:
         with open(STATE_FILE, 'w') as f: f.write(username)
-    except Exception as e: print(f"Failed save username: {e}")
+    except Exception as e: print(f"❌ Failed save username: {e}")
 
 def load_username():
     if os.path.exists(STATE_FILE):
         try:
             with open(STATE_FILE, 'r') as f: return f.read().strip()
-        except Exception as e: print(f"Failed load username: {e}")
+        except Exception as e: print(f"❌ Failed load username: {e}")
     return None
 
 def init_session_state():
     """Initializes Streamlit session state variables."""
     defaults = {
+        'server_running_flag': False, 'server_instance': None, 'server_task': None,
+        'active_connections': defaultdict(dict), # Stores websocket objects by client_id
         'last_chat_update': 0, 'message_input': "", 'audio_cache': {},
         'tts_voice': DEFAULT_TTS_VOICE, 'chat_history': [], 'enable_audio': True,
         'download_link_cache': {}, 'username': None, 'autosend': False,
         'last_message': "",
         'selected_object': 'None',
+        # Removed 'initial_world_state_loaded' flag, cache resource handles init
         'current_world_file': None, # Track loaded world filename (basename)
-        'new_world_name': "MyWorld",
+        'new_world_name': "MyDreamscape",
         'action_log': deque(maxlen=MAX_ACTION_LOG_SIZE),
-        'world_to_load_data': None, # Temp storage for state loaded from file
-        'js_object_placed_data': None # Temp storage for data coming from JS place event
+        # Removed 'world_to_load_data' and 'js_object_placed_data' - WS handles live updates
     }
     for k, v in defaults.items():
         if k not in st.session_state:
-            # Use copy for mutable defaults like deque to avoid shared reference issue
-            if isinstance(v, deque):
-                 st.session_state[k] = v.copy()
-            elif isinstance(v, (dict, list)): # Also copy dicts/lists if needed
-                 st.session_state[k] = v.copy()
-            else:
-                 st.session_state[k] = v
-    # Ensure complex types are correctly initialized if session reloads partially
+            if isinstance(v, (deque, dict, list)): st.session_state[k] = v.copy()
+            else: st.session_state[k] = v
+    # Ensure complex types are correctly initialized
+    if not isinstance(st.session_state.active_connections, defaultdict): st.session_state.active_connections = defaultdict(dict)
     if not isinstance(st.session_state.chat_history, list): st.session_state.chat_history = []
     if not isinstance(st.session_state.audio_cache, dict): st.session_state.audio_cache = {}
     if not isinstance(st.session_state.download_link_cache, dict): st.session_state.download_link_cache = {}
@@ -291,37 +292,12 @@ def init_session_state():
 # ==============================================================================
 # Action Log Helper
 # ==============================================================================
-def add_action_log(message):
-    """Adds a message to the session's action log."""
-    if 'action_log' not in st.session_state:
+def add_action_log(message, emoji="➡️"):
+    """Adds a timestamped message with emoji to the session's action log."""
+    if 'action_log' not in st.session_state or not isinstance(st.session_state.action_log, deque):
         st.session_state.action_log = deque(maxlen=MAX_ACTION_LOG_SIZE)
     timestamp = datetime.now().strftime("%H:%M:%S")
-    # Prepend so newest is at top
-    st.session_state.action_log.appendleft(f"[{timestamp}] {message}")
-
-# ==============================================================================
-# JS Communication Handler Function
-# ==============================================================================
-# This function needs to be defined globally for streamlit_js_eval to find it by name
-def handle_js_object_placed(data):
-    """Callback triggered by JS when an object is placed. Stores data in state."""
-    print(f"Python received object placed event data: {type(data)}")
-    processed_data = None
-    # Logic assumes streamlit_js_eval passes the JS object directly as Python dict/list
-    if isinstance(data, dict):
-         processed_data = data
-    elif isinstance(data, str): # Fallback if it comes as JSON string
-        try: processed_data = json.loads(data)
-        except json.JSONDecodeError: print("Failed decode JSON from JS object place event."); return False
-    else: print(f"Received unexpected data type from JS place event: {type(data)}"); return False
-
-    if processed_data and 'obj_id' in processed_data and 'type' in processed_data:
-        st.session_state.js_object_placed_data = processed_data # Store for main loop processing
-        add_action_log(f"Placed {processed_data.get('type', 'object')} ({processed_data.get('obj_id', 'N/A')[:6]}...)")
-        # Return value isn't used by the JS call, but good practice
-        return True
-    else: print("Received invalid object placement data structure from JS."); return False
-
+    st.session_state.action_log.appendleft(f"{emoji} [{timestamp}] {message}")
 
 # ==============================================================================
 # Audio / TTS / Chat / File Handling Helpers (Keep implementations)
@@ -331,14 +307,12 @@ def clean_text_for_tts(text):
     if not isinstance(text, str): return "No text"
     text = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', text); text = re.sub(r'[#*_`!]', '', text)
     text = ' '.join(text.split()); return text[:250] or "No text"
-
 def create_file(content, username, file_type="md", save_path=None):
     if not save_path: filename = generate_filename(content, username, file_type); save_path = os.path.join(MEDIA_DIR, filename)
     ensure_dir(os.path.dirname(save_path))
     try:
         with open(save_path, 'w', encoding='utf-8') as f: f.write(content); return save_path
-    except Exception as e: print(f"Error creating file {save_path}: {e}"); return None
-
+    except Exception as e: print(f"❌ Error creating file {save_path}: {e}"); return None
 def get_download_link(file_path, file_type="md"):
     if not file_path or not os.path.exists(file_path): basename = os.path.basename(file_path) if file_path else "N/A"; return f"<small>Not found: {basename}</small>"
     try: mtime = os.path.getmtime(file_path)
@@ -352,9 +326,8 @@ def get_download_link(file_path, file_type="md"):
             basename = os.path.basename(file_path)
             link_html = f'<a href="data:{mime_types.get(file_type, "application/octet-stream")};base64,{b64}" download="{basename}" title="Download {basename}">{FILE_EMOJIS.get(file_type, "📄")}</a>'
             st.session_state.download_link_cache[cache_key] = link_html
-        except Exception as e: print(f"Error generating DL link for {file_path}: {e}"); return f"<small>Err</small>"
+        except Exception as e: print(f"❌ Error generating DL link for {file_path}: {e}"); return f"<small>Err</small>"
     return st.session_state.download_link_cache.get(cache_key, "<small>CacheErr</small>")
-
 # --- Audio / TTS ---
 async def async_edge_tts_generate(text, voice, username):
     if not text: return None
@@ -369,17 +342,15 @@ async def async_edge_tts_generate(text, voice, username):
     try:
         communicate = edge_tts.Communicate(text_cleaned, voice); await communicate.save(save_path);
         if os.path.exists(save_path) and os.path.getsize(save_path) > 0: st.session_state.audio_cache[cache_key] = save_path; return save_path
-        else: print(f"Audio file {save_path} failed generation."); return None
-    except Exception as e: print(f"Edge TTS Error: {e}"); return None
-
+        else: print(f"❌ Audio file {save_path} failed generation."); return None
+    except Exception as e: print(f"❌ Edge TTS Error: {e}"); return None
 def play_and_download_audio(file_path):
     if file_path and os.path.exists(file_path):
         try:
              st.audio(file_path)
              file_type = file_path.split('.')[-1]
              st.markdown(get_download_link(file_path, file_type), unsafe_allow_html=True)
-        except Exception as e: st.error(f"Audio display error for {os.path.basename(file_path)}: {e}")
-
+        except Exception as e: st.error(f"❌ Audio display error for {os.path.basename(file_path)}: {e}")
 # --- Chat ---
 async def save_chat_entry(username, message, voice, is_markdown=False):
     if not message.strip(): return None, None
@@ -394,95 +365,87 @@ async def save_chat_entry(username, message, voice, is_markdown=False):
          tts_message = message
          audio_file = await async_edge_tts_generate(tts_message, voice, username)
     return md_file, audio_file
-
 async def load_chat_history():
      if 'chat_history' not in st.session_state: st.session_state.chat_history = []
      if not st.session_state.chat_history:
-          ensure_dir(CHAT_DIR); print("Loading chat history from files...")
+          ensure_dir(CHAT_DIR); print("📜 Loading chat history from files...")
           chat_files = sorted(glob.glob(os.path.join(CHAT_DIR, "*.md")), key=os.path.getmtime); loaded_count = 0
           temp_history = []
           for f_path in chat_files:
                try:
                     with open(f_path, 'r', encoding='utf-8') as file: temp_history.append(file.read().strip()); loaded_count += 1
-               except Exception as e: print(f"Err read chat {f_path}: {e}")
+               except Exception as e: print(f"❌ Err read chat {f_path}: {e}")
           st.session_state.chat_history = temp_history
-          print(f"Loaded {loaded_count} chat entries from files.")
+          print(f"✅ Loaded {loaded_count} chat entries from files.")
      return st.session_state.chat_history
-
 # --- File Management ---
 def create_zip_of_files(files_to_zip, prefix="Archive"):
-    if not files_to_zip: st.warning("No files provided to zip."); return None
+    if not files_to_zip: st.warning("💨 Nothing to gather into an archive."); return None
     timestamp = format_timestamp_prefix(f"Zip_{prefix}"); zip_name = f"{prefix}_{timestamp}.zip"
     try:
-        print(f"Creating zip: {zip_name}...");
+        print(f"📦 Creating zip archive: {zip_name}...");
         with zipfile.ZipFile(zip_name, 'w', zipfile.ZIP_DEFLATED) as z:
             for f in files_to_zip:
                  if os.path.exists(f): z.write(f, os.path.basename(f))
-                 else: print(f"Skip zip missing: {f}")
-        print("Zip success."); st.success(f"Created {zip_name}"); return zip_name
-    except Exception as e: print(f"Zip failed: {e}"); st.error(f"Zip failed: {e}"); return None
-
+                 else: print(f"💨 Skip zip missing file: {f}")
+        print("✅ Zip archive created successfully."); st.success(f"Created {zip_name}"); return zip_name
+    except Exception as e: print(f"❌ Zip creation failed: {e}"); st.error(f"Zip creation failed: {e}"); return None
 def delete_files(file_patterns, exclude_files=None):
     protected = [STATE_FILE, "app.py", "index.html", "requirements.txt", "README.md"]
     current_world_base = st.session_state.get('current_world_file')
-    if current_world_base: protected.append(current_world_base)
+    if current_world_base: protected.append(current_world_base) # Protect loaded world
     if exclude_files: protected.extend(exclude_files)
     deleted_count = 0; errors = 0
     for pattern in file_patterns:
          pattern_path = pattern
-         print(f"Attempting to delete files matching: {pattern_path}")
+         print(f"🗑️ Attempting to delete files matching: {pattern_path}")
          try:
               files_to_delete = glob.glob(pattern_path)
-              if not files_to_delete: print(f"No files found for pattern: {pattern}"); continue
+              if not files_to_delete: print(f"💨 No files found for pattern: {pattern}"); continue
               for f_path in files_to_delete:
                    basename = os.path.basename(f_path)
                    if os.path.isfile(f_path) and basename not in protected:
-                        try: os.remove(f_path); print(f"Deleted: {f_path}"); deleted_count += 1
-                        except Exception as e: print(f"Failed delete {f_path}: {e}"); errors += 1
-                   elif os.path.isdir(f_path): print(f"Skipping directory: {f_path}")
-         except Exception as glob_e: print(f"Error matching pattern {pattern}: {glob_e}"); errors += 1
-    msg = f"Deleted {deleted_count} files.";
+                        try: os.remove(f_path); print(f"🗑️ Deleted: {f_path}"); deleted_count += 1
+                        except Exception as e: print(f"❌ Failed delete {f_path}: {e}"); errors += 1
+                   # else: print(f"🚫 Skipping protected/directory: {f_path}") # Debugging
+         except Exception as glob_e: print(f"❌ Error matching pattern {pattern}: {glob_e}"); errors += 1
+    msg = f"✅ Successfully deleted {deleted_count} files." if errors == 0 and deleted_count > 0 else f"Deleted {deleted_count} files."
     if errors > 0: msg += f" Encountered {errors} errors."; st.warning(msg)
     elif deleted_count > 0: st.success(msg)
-    else: st.info("No matching files found to delete.")
+    else: st.info("💨 No matching unprotected files found to delete.")
     st.session_state['download_link_cache'] = {}; st.session_state['audio_cache'] = {}
-
 # --- Image Handling ---
 async def save_pasted_image(image, username):
      if not image: return None
-     try:
-         img_hash = hashlib.md5(image.tobytes()).hexdigest()[:8]; timestamp = format_timestamp_prefix(username); filename = f"{timestamp}_pasted_{img_hash}.png"; filepath = os.path.join(MEDIA_DIR, filename)
-         image.save(filepath, "PNG"); print(f"Pasted image saved: {filepath}"); return filepath
-     except Exception as e: print(f"Failed image save: {e}"); return None
-
+     try: img_hash = hashlib.md5(image.tobytes()).hexdigest()[:8]; timestamp = format_timestamp_prefix(username); filename = f"{timestamp}_pasted_{img_hash}.png"; filepath = os.path.join(MEDIA_DIR, filename); image.save(filepath, "PNG"); print(f"🖼️ Pasted image saved: {filepath}"); return filepath
+     except Exception as e: print(f"❌ Failed image save: {e}"); return None
 def paste_image_component():
       pasted_img = None; img_type = None
-      # Simplified paste component logic
-      paste_input_value = st.text_area("Paste Image Data Here", key="paste_input_area", height=50)
-      if st.button("Process Pasted Image 📋", key="process_paste_button"):
+      paste_input_value = st.text_area("📋 Paste Image Data Here", key="paste_input_area", height=50, value=st.session_state.get('paste_image_base64_input', ""), help="Paste image data directly (e.g., from clipboard)")
+      if st.button("🖼️ Process Pasted Image", key="process_paste_button"):
+           st.session_state.paste_image_base64_input = paste_input_value
            if paste_input_value and paste_input_value.startswith('data:image'):
                try:
                    mime_type = paste_input_value.split(';')[0].split(':')[1]; base64_str = paste_input_value.split(',')[1]; img_bytes = base64.b64decode(base64_str); pasted_img = Image.open(io.BytesIO(img_bytes)); img_type = mime_type.split('/')[1]
-                   st.image(pasted_img, caption=f"Pasted ({img_type.upper()})", width=150); st.session_state.paste_image_base64 = base64_str # Store processed base64
-                   # Clear input area state for next run - using callback is better if possible
-                   # st.session_state.paste_input_area = "" # Direct modification fails
-                   st.rerun() # Rerun necessary to potentially process image
-               except ImportError: st.error("Pillow library needed.")
-               except Exception as e: st.error(f"Img decode err: {e}"); st.session_state.paste_image_base64 = ""
-           else: st.warning("No valid image data pasted."); st.session_state.paste_image_base64 = ""
-      # Return the image if successfully processed in *this* run after button press
-      # This is tricky due to rerun, might need state flag
-      return pasted_img
-
-
+                   st.image(pasted_img, caption=f"🖼️ Pasted ({img_type.upper()})", width=150); st.session_state.paste_image_base64 = base64_str
+                   st.session_state.paste_image_base64_input = ""
+                   st.rerun()
+               except ImportError: st.error("⚠️ Pillow library needed for image pasting.")
+               except Exception as e: st.error(f"❌ Img decode err: {e}"); st.session_state.paste_image_base64 = ""; st.session_state.paste_image_base64_input = paste_input_value
+           else: st.warning("⚠️ No valid image data pasted."); st.session_state.paste_image_base64 = ""; st.session_state.paste_image_base64_input = paste_input_value
+      processed_b64 = st.session_state.get('paste_image_base64', '')
+      if processed_b64:
+           try: img_bytes = base64.b64decode(processed_b64); return Image.open(io.BytesIO(img_bytes))
+           except Exception: return None
+      return None
 # --- PDF Processing ---
-class AudioProcessor:
+class AudioProcessor: # Keep as is
       def __init__(self): self.cache_dir=AUDIO_CACHE_DIR; ensure_dir(self.cache_dir); self.metadata=json.load(open(f"{self.cache_dir}/metadata.json", 'r')) if os.path.exists(f"{self.cache_dir}/metadata.json") else {}
       def _save_metadata(self):
             try:
                  with open(f"{self.cache_dir}/metadata.json", 'w') as f: json.dump(self.metadata, f, indent=2)
-            except Exception as e: print(f"Failed metadata save: {e}")
-      async def create_audio(self, text, voice='en-US-AriaNeural'):
+            except Exception as e: print(f"❌ Failed metadata save: {e}")
+      async def create_audio(self, text, voice=DEFAULT_TTS_VOICE):
             cache_key=hashlib.md5(f"{text[:150]}:{voice}".encode()).hexdigest(); cache_path=os.path.join(self.cache_dir, f"{cache_key}.mp3");
             if cache_key in self.metadata and os.path.exists(cache_path): return cache_path
             text_cleaned=clean_text_for_tts(text);
@@ -492,86 +455,185 @@ class AudioProcessor:
                  communicate=edge_tts.Communicate(text_cleaned,voice); await communicate.save(cache_path)
                  if os.path.exists(cache_path) and os.path.getsize(cache_path) > 0: self.metadata[cache_key]={'timestamp': datetime.now().isoformat(), 'text_length': len(text_cleaned), 'voice': voice}; self._save_metadata(); return cache_path
                  else: return None
-            except Exception as e: print(f"TTS Create Audio Error: {e}"); return None
+            except Exception as e: print(f"❌ TTS Create Audio Error: {e}"); return None
 
-def process_pdf_tab(pdf_file, max_pages, voice):
-    st.subheader("PDF Processing Results")
-    if pdf_file is None:
-        st.info("Upload a PDF file and click 'Process PDF' to begin.")
-        return
+def process_pdf_tab(pdf_file, max_pages, voice): # Corrected version
+    st.subheader("📜 PDF Processing Results")
+    if pdf_file is None: st.info("⬆️ Upload a PDF file and click 'Process PDF' to begin."); return
     audio_processor = AudioProcessor()
     try:
-        reader=PdfReader(pdf_file)
-        if reader.is_encrypted:
-            st.warning("PDF is encrypted.")
-            return
-        total_pages_in_pdf = len(reader.pages)
-        pages_to_process = min(total_pages_in_pdf, max_pages);
-        st.write(f"Processing first {pages_to_process} of {total_pages_in_pdf} pages from '{pdf_file.name}'...")
+        reader=PdfReader(pdf_file);
+        if reader.is_encrypted: st.warning("🔒 PDF is encrypted."); return
+        total_pages_in_pdf = len(reader.pages); pages_to_process = min(total_pages_in_pdf, max_pages);
+        st.write(f"⏳ Processing first {pages_to_process} of {total_pages_in_pdf} pages from '{pdf_file.name}'...")
         texts, audios={}, {}; page_threads = []; results_lock = threading.Lock()
 
         def process_page_sync(page_num, page_text):
             async def run_async_audio(): return await audio_processor.create_audio(page_text, voice)
             try:
-                audio_path = asyncio.run(run_async_audio()) # asyncio.run is simpler here
-                if audio_path:
-                    with results_lock: audios[page_num] = audio_path
-            except Exception as page_e:
-                print(f"Err process page {page_num+1}: {page_e}")
+                 audio_path = asyncio.run(run_async_audio()) # Use asyncio.run in thread
+                 if audio_path:
+                      with results_lock: audios[page_num] = audio_path
+            except Exception as page_e: print(f"❌ Err process page {page_num+1}: {page_e}")
 
         # Start threads
         for i in range(pages_to_process):
-             try:
+             try: # Start try block for page processing
                  page = reader.pages[i]
-                 text = page.extract_text()
-                 if text and text.strip():
-                     texts[i]=text
-                     thread = threading.Thread(target=process_page_sync, args=(i, text))
-                     page_threads.append(thread)
-                     thread.start()
-                 else:
-                     texts[i] = "[No text extracted or page empty]"
-                     print(f"Page {i+1}: No text extracted.")
+                 text = page.extract_text() # Attempt text extraction
+                 if text and text.strip(): # Check extracted text
+                     texts[i]=text # Store text
+                     thread = threading.Thread(target=process_page_sync, args=(i, text)) # Create thread
+                     page_threads.append(thread) # Append thread
+                     thread.start() # Start thread
+                 else: # Handle empty extraction
+                     texts[i] = "[📄 No text extracted or page empty]"
+                     # print(f"Page {i+1}: No text extracted.") # Verbose
+             # Correctly indented except block
              except Exception as extract_e:
-                  texts[i] = f"[Error extracting text: {extract_e}]"
-                  print(f"Error page {i+1} extract: {extract_e}")
+                  texts[i] = f"[❌ Error extract: {extract_e}]" # Store error message
+                  print(f"Error page {i+1} extract: {extract_e}") # Log error
 
         # Wait for threads and display progress
-        progress_bar = st.progress(0.0, text="Processing pages...")
-        total_threads = len(page_threads)
-        start_join_time = time.time()
+        progress_bar = st.progress(0.0, text="✨ Transmuting pages to sound...")
+        total_threads = len(page_threads); start_join_time = time.time()
         while any(t.is_alive() for t in page_threads):
-            completed_threads = total_threads - sum(t.is_alive() for t in page_threads)
-            progress = completed_threads / total_threads if total_threads > 0 else 1.0
-            progress_bar.progress(min(progress, 1.0), text=f"Processed {completed_threads}/{total_threads} pages...")
-            if time.time() - start_join_time > 600: # 10 min timeout
-                print("PDF processing timed out.")
-                st.warning("Processing timed out.")
-                break
-            time.sleep(0.5) # Avoid busy-waiting
-        progress_bar.progress(1.0, text="Processing complete.")
+            completed_threads = total_threads - sum(t.is_alive() for t in page_threads); progress = completed_threads / total_threads if total_threads > 0 else 1.0
+            progress_bar.progress(min(progress, 1.0), text=f"✨ Processed {completed_threads}/{total_threads} pages...")
+            if time.time() - start_join_time > 600: print("⌛ PDF processing timed out."); st.warning("Processing timed out."); break
+            time.sleep(0.5)
+        progress_bar.progress(1.0, text="✅ Processing complete.")
 
         # Display results
-        st.write("Displaying results:")
+        st.write("🎶 Results:")
         for i in range(pages_to_process):
               with st.expander(f"Page {i+1}"):
-                   st.markdown(texts.get(i, "[Error getting text]"))
-                   audio_file = audios.get(i) # Get result from shared dict
-                   if audio_file:
-                        play_and_download_audio(audio_file)
+                   st.markdown(texts.get(i, "[❓ Error getting text]"))
+                   audio_file = audios.get(i)
+                   if audio_file: play_and_download_audio(audio_file)
                    else:
-                        # Check if text existed to differentiate between skipped vs failed
                         page_text = texts.get(i,"")
-                        if page_text.strip() and page_text != "[No text extracted or page empty]" and not page_text.startswith("[Error"):
-                             st.caption("Audio generation failed or timed out.")
-                        #else: # No text or error extracting text
-                        #     st.caption("No text to generate audio from.") # Implicit
+                        if page_text.strip() and not page_text.startswith("["): st.caption("🔇 Audio generation failed or timed out.")
+                        # else: st.caption("🔇 No text to generate audio from.") # Implicit
 
-    except ImportError:
-         st.error("PyPDF2 library needed for PDF processing.")
-    except Exception as pdf_e:
-         st.error(f"Error reading PDF '{pdf_file.name}': {pdf_e}");
-         st.exception(pdf_e)
+    except ImportError: st.error("⚠️ PyPDF2 library needed.")
+    except Exception as pdf_e: st.error(f"❌ Error reading PDF '{pdf_file.name}': {pdf_e}"); st.exception(pdf_e)
+
+
+# ==============================================================================
+# WebSocket Server Logic (Re-added for Chat/Presence)
+# ==============================================================================
+
+async def register_client(websocket):
+    client_id = str(websocket.id);
+    with clients_lock: connected_clients.add(client_id);
+    if 'active_connections' not in st.session_state: st.session_state.active_connections = defaultdict(dict);
+    st.session_state.active_connections[client_id] = websocket;
+    print(f"✅ Client registered: {client_id}. Total: {len(connected_clients)}")
+
+async def unregister_client(websocket):
+    client_id = str(websocket.id);
+    with clients_lock:
+        connected_clients.discard(client_id);
+        if 'active_connections' in st.session_state: st.session_state.active_connections.pop(client_id, None);
+    print(f"❌ Client unregistered: {client_id}. Remaining: {len(connected_clients)}")
+
+async def send_safely(websocket, message, client_id):
+     """Wrapper to send message and handle potential connection errors."""
+     try: await websocket.send(message)
+     except websockets.ConnectionClosed: print(f"❌ WS Send failed (Closed) client {client_id}"); raise
+     except RuntimeError as e: print(f"❌ WS Send failed (Runtime {e}) client {client_id}"); raise
+     except Exception as e: print(f"❌ WS Send failed (Other {e}) client {client_id}"); raise
+
+async def broadcast_message(message, exclude_id=None):
+    """Sends a message to all connected clients except the excluded one."""
+    with clients_lock:
+        if not connected_clients: return
+        current_client_ids = list(connected_clients)
+        active_connections_copy = st.session_state.active_connections.copy()
+
+    tasks = []
+    for client_id in current_client_ids:
+        if client_id == exclude_id: continue
+        websocket = active_connections_copy.get(client_id)
+        if websocket: tasks.append(asyncio.create_task(send_safely(websocket, message, client_id)))
+
+    if tasks: await asyncio.gather(*tasks, return_exceptions=True) # Wait and ignore errors here
+
+async def websocket_handler(websocket, path):
+    """Handles WebSocket connections and messages (primarily for Chat)."""
+    await register_client(websocket); client_id = str(websocket.id);
+    username = st.session_state.get('username', f"User_{client_id[:4]}")
+
+    try: # Announce join
+        print(f"✨ {username} ({client_id}) connected.")
+        await broadcast_message(json.dumps({"type": "user_join", "payload": {"username": username, "id": client_id}}), exclude_id=client_id)
+    except Exception as e: print(f"❌ Error during join announcement {client_id}: {e}")
+
+    try: # Message loop
+        async for message in websocket:
+            try:
+                data = json.loads(message); msg_type = data.get("type"); payload = data.get("payload", {});
+                sender_username = payload.get("username", username) # Username sent from client
+
+                if msg_type == "chat_message":
+                    chat_text = payload.get('message', ''); voice = payload.get('voice', FUN_USERNAMES.get(sender_username, DEFAULT_TTS_VOICE));
+                    print(f"💬 WS Recv Chat from {sender_username}: {chat_text[:30]}...")
+                    # Schedule save/TTS locally
+                    run_async(save_chat_entry, sender_username, chat_text, voice)
+                    # Broadcast message to other clients (they will update their UI)
+                    await broadcast_message(message, exclude_id=client_id)
+                elif msg_type == "ping": # Handle keepalive pings
+                     await websocket.send(json.dumps({"type": "pong"}))
+                # Add other message types if needed (e.g., simple presence)
+                else:
+                     print(f"⚠️ WS Recv unknown message type from {client_id}: {msg_type}")
+
+            except json.JSONDecodeError: print(f"⚠️ WS Invalid JSON from {client_id}: {message[:100]}...")
+            except Exception as e: print(f"❌ WS Error processing msg from {client_id}: {e}")
+    except websockets.ConnectionClosed: print(f"🔌 WS Client disconnected: {client_id} ({username})")
+    except Exception as e: print(f"❌ WS Unexpected handler error {client_id}: {e}")
+    finally:
+         await broadcast_message(json.dumps({"type": "user_leave", "payload": {"username": username, "id": client_id}}), exclude_id=client_id);
+         await unregister_client(websocket) # Cleanup
+
+async def run_websocket_server():
+    """Coroutine to run the WebSocket server."""
+    if st.session_state.get('server_running_flag', False): return # Prevent multiple starts
+    st.session_state['server_running_flag'] = True; print("⚙️ Attempting start WS server 0.0.0.0:8765...")
+    stop_event = asyncio.Event(); st.session_state['websocket_stop_event'] = stop_event
+    server = None
+    try:
+        server = await websockets.serve(websocket_handler, "0.0.0.0", 8765); st.session_state['server_instance'] = server
+        print(f"✅ WS server started: {server.sockets[0].getsockname()}. Waiting for stop signal...")
+        await stop_event.wait() # Keep server running
+    except OSError as e: print(f"### ❌ FAILED START WS SERVER: {e}"); st.session_state['server_running_flag'] = False;
+    except Exception as e: print(f"### ❌ UNEXPECTED WS SERVER ERROR: {e}"); st.session_state['server_running_flag'] = False;
+    finally:
+        print("⚙️ WS server task finishing...");
+        if server: server.close(); await server.wait_closed(); print("✅ WS server closed.")
+        st.session_state['server_running_flag'] = False; st.session_state['server_instance'] = None; st.session_state['websocket_stop_event'] = None
+
+def start_websocket_server_thread():
+    """Starts the WebSocket server in a separate thread if not already running."""
+    if st.session_state.get('server_task') and st.session_state.server_task.is_alive(): return
+    if st.session_state.get('server_running_flag', False): return
+    print("⚙️ Creating/starting new server thread.");
+    def run_loop(): # Wrapper to manage event loop in thread
+        loop = None
+        try: loop = asyncio.get_running_loop()
+        except RuntimeError: loop = asyncio.new_event_loop(); asyncio.set_event_loop(loop)
+        try: loop.run_until_complete(run_websocket_server())
+        finally:
+             if loop and not loop.is_closed():
+                  tasks = asyncio.all_tasks(loop);
+                  if tasks:
+                    for task in tasks: task.cancel()
+                    try: loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
+                    except asyncio.CancelledError: pass
+                  loop.close(); print("⚙️ Server thread loop closed.")
+    st.session_state.server_task = threading.Thread(target=run_loop, daemon=True); st.session_state.server_task.start(); time.sleep(1.5)
+    if not st.session_state.server_task.is_alive(): print("### ❌ Server thread failed to stay alive!")
 
 
 # ==============================================================================
@@ -581,188 +643,190 @@ def process_pdf_tab(pdf_file, max_pages, voice):
 def render_sidebar():
     """Renders the Streamlit sidebar contents."""
     with st.sidebar:
-        st.header("💾 World Management")
+        # 1. World Management
+        st.header("1. 💾 World Management")
+        st.caption("💾 Save the current view or ✨ load a past creation.")
 
-        # --- World Save ---
+        # World Save Button (simplified logic)
         current_file = st.session_state.get('current_world_file')
-        current_world_name = "Live State"
-        default_save_name = st.session_state.get('new_world_name', 'MyWorld')
-        if current_file:
-            parsed = parse_world_filename(os.path.join(SAVED_WORLDS_DIR, current_file))
-            current_world_name = parsed.get("name", current_file)
-            default_save_name = current_world_name # Default to overwriting current name
-
-        world_save_name = st.text_input(
-            "World Name for Save:",
-            key="world_save_name_input",
-            value=default_save_name,
-            help="Enter name to save as new, or keep current name to overwrite."
-        )
+        save_name_value = st.session_state.get('world_save_name_input', "MyDreamscape" if not current_file else parse_world_filename(os.path.join(SAVED_WORLDS_DIR, current_file)).get("name", current_file))
+        world_save_name = st.text_input("World Name:", key="world_save_name_input", value=save_name_value, help="Enter name to save.")
 
-        if st.button("💾 Save Current World View", key="sidebar_save_world"):
-            if not world_save_name.strip():
-                st.warning("Please enter a World Name.")
+        if st.button("💾 Save Current View", key="sidebar_save_world"):
+            if not world_save_name.strip(): st.warning("⚠️ Please enter a World Name.")
             else:
-                with st.spinner("Requesting world state & saving..."):
-                    js_world_state_str = streamlit_js_eval("getWorldStateForSave();", key="get_world_state_sidebar_save", want_result=True)
-                    if js_world_state_str:
-                        try:
-                            world_data_dict = json.loads(js_world_state_str)
-                            if isinstance(world_data_dict, dict):
-                                filename_to_save = ""
-                                is_overwrite = False
-                                if current_file:
-                                     parsed_current = parse_world_filename(os.path.join(SAVED_WORLDS_DIR, current_file))
-                                     # Check if input name matches the name part of the current file
-                                     if world_save_name == parsed_current.get('name', ''):
-                                          filename_to_save = current_file # Use existing basename
-                                          is_overwrite = True
-
-                                if not filename_to_save: # Create new filename if not overwriting
-                                     filename_to_save = generate_world_save_filename(st.session_state.username, world_save_name)
-
-                                if save_world_to_md(filename_to_save, world_data_dict):
-                                    action = "Overwritten" if is_overwrite else "Saved new"
-                                    st.success(f"World {action}: {filename_to_save}")
-                                    add_action_log(f"Saved world: {filename_to_save}")
-                                    st.session_state.current_world_file = filename_to_save # Track saved file
-                                    st.session_state.new_world_name = "MyWorld" # Reset default
-                                    st.rerun() # Refresh sidebar list
-                                else: st.error("Failed to save world state to file.")
-                            else: st.error("Invalid state format received from client.")
-                        except json.JSONDecodeError: st.error("Failed to decode state from client.")
-                        except Exception as e: st.error(f"Save error: {e}")
-                    else: st.warning("Did not receive world state from client.")
-
-        # --- World Load ---
+                # Store info needed for callback after JS returns data
+                st.session_state.pending_save_filename = generate_world_save_filename(st.session_state.username, world_save_name)
+                st.session_state.pending_save_op_text = f"Saving {world_save_name}..."
+                # Trigger JS to get state and call Python function `handle_js_save_data`
+                try:
+                     print("🐍 Requesting world state from JS for saving...")
+                     # JS function `getWorldStateForSave` now calls Python func `handle_js_save_data`
+                     streamlit_js_eval("getWorldStateForSave(true);", key="trigger_js_save")
+                     st.info("💾 Requesting state from view...")
+                except Exception as e: st.error(f"❌ Failed to request save state: {e}")
+
+        # World Load Section
         st.markdown("---")
-        st.header("📂 Load World")
+        st.header("2. 📂 Load World")
+        st.caption("📜 Unfurl a previously woven dreamscape.")
         saved_worlds = get_saved_worlds()
 
-        if not saved_worlds: st.caption("No saved worlds found.")
+        if not saved_worlds: st.caption("🌫️ The archives are empty.")
         else:
-            st.caption("Click button to load state.")
-            cols_header = st.columns([4, 1, 1]) # Adjusted column ratio
-            with cols_header[0]: st.write("**Name** (User, Time)")
-            with cols_header[1]: st.write("**Load**")
-            with cols_header[2]: st.write("**DL**")
-
-            # Simple list without expander for now
-            for world_info in saved_worlds:
-                f_basename = os.path.basename(world_info['filename'])
-                f_fullpath = os.path.join(SAVED_WORLDS_DIR, f_basename)
-                display_name = world_info.get('name', f_basename); user = world_info.get('user', 'N/A'); timestamp = world_info.get('timestamp', 'N/A')
-                display_text = f"{display_name} ({user}, {timestamp})"
-
-                col1, col2, col3 = st.columns([4, 1, 1])
-                with col1: st.write(f"<small>{display_text}</small>", unsafe_allow_html=True)
-                with col2:
-                    is_current = (st.session_state.get('current_world_file') == f_basename)
-                    btn_load = st.button("Load", key=f"load_{f_basename}", help=f"Load {f_basename}", disabled=is_current)
-                with col3: st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True)
-
-                if btn_load: # Handle click if not disabled
-                    print(f"Load button clicked for: {f_basename}")
-                    world_dict = load_world_from_md(f_basename)
-                    if world_dict is not None:
-                        st.session_state.world_to_load_data = world_dict # Queue data for JS
-                        st.session_state.current_world_file = f_basename
-                        add_action_log(f"Loading world: {f_basename}")
-                        st.rerun() # Trigger rerun to send data via injection/call
-                    else: st.error(f"Failed to parse world file: {f_basename}")
-
-
-        # --- Build Tools ---
+             cols_header = st.columns([4, 1, 1]);
+             with cols_header[0]: st.write("**Name** (User, Time)")
+             with cols_header[1]: st.write("**Load**")
+             with cols_header[2]: st.write("**DL**")
+
+             display_limit = 15
+             # Use a container for scrollability if list is long
+             list_container = st.container(height=300 if len(saved_worlds) > 7 else None)
+             with list_container:
+                 for world_info in saved_worlds:
+                    f_basename = os.path.basename(world_info['filename']); f_fullpath = os.path.join(SAVED_WORLDS_DIR, f_basename);
+                    display_name = world_info.get('name', f_basename); user = world_info.get('user', 'N/A'); timestamp = world_info.get('timestamp', 'N/A')
+                    display_text = f"{display_name} ({user}, {timestamp})"
+                    col1, col2, col3 = st.columns([4, 1, 1])
+                    with col1: st.write(f"<small>{display_text}</small>", unsafe_allow_html=True)
+                    with col2:
+                        is_current = (st.session_state.get('current_world_file') == f_basename)
+                        btn_load = st.button("✨", key=f"load_{f_basename}", help=f"Load {f_basename}", disabled=is_current)
+                    with col3: st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True)
+
+                    if btn_load:
+                        print(f"🖱️ Load button clicked for: {f_basename}")
+                        world_dict = load_world_from_md(f_basename)
+                        if world_dict is not None:
+                            st.session_state.world_to_load_data = world_dict # Queue data for JS
+                            st.session_state.current_world_file = f_basename
+                            add_action_log(f"Loading world: {f_basename}", emoji="📂")
+                            st.rerun()
+                        else: st.error(f"❌ Failed to parse world file: {f_basename}")
+
+        # Build Tools Section
         st.markdown("---")
-        st.header("🏗️ Build Tools")
-        st.caption("Select an object to place.")
+        st.header("3. 🛠️ Build Tools")
+        st.caption("Select your creative instrument.")
         tool_options = list(TOOLS_MAP.keys())
         current_tool_name = st.session_state.get('selected_object', 'None')
         try: tool_index = tool_options.index(current_tool_name)
         except ValueError: tool_index = 0
 
-        # Use columns for horizontal layout feel for Radio buttons
-        cols_tools = st.columns(len(tool_options))
         selected_tool = st.radio(
             "Select Tool:", options=tool_options, index=tool_index,
             format_func=lambda name: f"{TOOLS_MAP.get(name, '')} {name}",
-            key="tool_selector_radio", horizontal=True, label_visibility="collapsed" # Hide label, use header
+            key="tool_selector_radio", horizontal=True, label_visibility="collapsed"
         )
-
         if selected_tool != current_tool_name:
             st.session_state.selected_object = selected_tool
-            add_action_log(f"Selected tool: {selected_tool}")
-            try: # Use streamlit_js_eval, not sync
-                streamlit_js_eval(js_code=f"updateSelectedObjectType({json.dumps(selected_tool)});", key=f"update_tool_js_{selected_tool}")
-            except Exception as e: print(f"JS tool update error: {e}")
+            tool_emoji = TOOLS_MAP.get(selected_tool, '❓')
+            add_action_log(f"Tool selected: {selected_tool}", emoji=tool_emoji)
+            try: streamlit_js_eval(js_code=f"updateSelectedObjectType({json.dumps(selected_tool)});", key=f"update_tool_js_{selected_tool}")
+            except Exception as e: print(f"❌ JS tool update error: {e}")
             st.rerun()
 
-        # --- Action Log ---
+
+        # Action Log Section
         st.markdown("---")
-        st.header("📝 Action Log")
+        st.header("4. 📝 Action Log")
+        st.caption("📜 A chronicle of your recent creative acts.")
         log_container = st.container(height=200)
         with log_container:
             log_entries = st.session_state.get('action_log', [])
             if log_entries: st.code('\n'.join(log_entries), language="log")
-            else: st.caption("No actions recorded yet.")
+            else: st.caption("🌬️ The log awaits your first action...")
+
 
-        # --- Voice/User ---
+        # Voice/User Section
         st.markdown("---")
-        st.header("🗣️ Voice & User")
+        st.header("5. 👤 Voice & User")
+        st.caption("🎭 Choose your persona in this realm.")
         current_username = st.session_state.get('username', "DefaultUser")
         username_options = list(FUN_USERNAMES.keys()) if FUN_USERNAMES else [current_username]
         current_index = 0;
-        if current_username in username_options: try: current_index = username_options.index(current_username)
-        except ValueError: pass
+        try:
+            if current_username in username_options: current_index = username_options.index(current_username)
+        except ValueError: pass # Keep index 0 if not found
+
         new_username = st.selectbox("Change Name/Voice", options=username_options, index=current_index, key="username_select", format_func=lambda x: x.split(" ")[0])
-        if new_username != st.session_state.username:
+        if new_username != st.session_state.get('username'):
+            old_username = st.session_state.username
+            change_msg = json.dumps({"type":"user_rename", "payload": {"old_username": old_username, "new_username": new_username}})
+            run_async(broadcast_message, change_msg) # Broadcast name change if WS is running
             st.session_state.username = new_username; st.session_state.tts_voice = FUN_USERNAMES.get(new_username, DEFAULT_TTS_VOICE); save_username(st.session_state.username)
-            add_action_log(f"Username changed to {new_username}")
+            add_action_log(f"Persona changed to {new_username}", emoji="🎭")
             st.rerun()
-        st.session_state['enable_audio'] = st.toggle("Enable TTS Audio", value=st.session_state.get('enable_audio', True))
+        st.session_state['enable_audio'] = st.toggle("🔊 Enable TTS Audio", value=st.session_state.get('enable_audio', True), help="Generate audio for chat messages?")
 
 
 def render_main_content():
     """Renders the main content area with tabs."""
     st.title(f"{Site_Name} - User: {st.session_state.username}")
 
-    # Check if world data needs to be sent to JS
+    # 1. Check if world data needs to be sent to JS (loaded via sidebar button)
     world_data_to_load = st.session_state.pop('world_to_load_data', None)
     if world_data_to_load is not None:
-        print(f"Sending loaded world state ({len(world_data_to_load)} objects) to JS...")
+        print(f"🐍 Sending loaded world state ({len(world_data_to_load)} objects) to JS...")
         try:
             streamlit_js_eval(js_code=f"loadWorldState({json.dumps(world_data_to_load)});", key="load_world_js")
-            st.toast("World loaded in 3D view.", icon="🔄")
-        except Exception as e:
-            st.error(f"Failed to send loaded world state to JS: {e}")
+            st.toast("🌌 World loaded in 3D view.", icon="🔄")
+        except Exception as e: st.error(f"❌ Failed to send loaded world state to JS: {e}")
 
-    # Set up the mechanism for JS to call Python when an object is placed
-    # This defines the JS function `window.sendPlacedObjectToPython`
+    # 2. Set up JS communication handlers (Object Placement & Save Data Callback)
     streamlit_js_eval(
         js_code="""
-            if (!window.sendPlacedObjectToPython) {
-                console.log('Defining sendPlacedObjectToPython for JS->Python comms...');
+            // Ensure functions are defined only once per page load
+            if (!window.streamlitPythonCallSetupDone) {
+                console.log('🐍 Setting up JS->Python communication functions...');
                 window.sendPlacedObjectToPython = (objectData) => {
                     console.log('JS sending placed object:', objectData);
-                    // Call Python function handle_js_object_placed, passing data directly
                     streamlit_js_eval(python_code='handle_js_object_placed(data=' + JSON.stringify(objectData) + ')', key='js_place_event_handler');
-                }
-            }
+                };
+                window.sendSaveDataToPython = (jsonData) => {
+                     console.log('JS sending saved world state back to Python...');
+                     streamlit_js_eval(python_code='handle_js_save_data(data=' + JSON.stringify(jsonData) + ')', key='js_save_state_handler');
+                 };
+                 window.streamlitPythonCallSetupDone = true;
+             }
         """,
-        key="setup_js_place_event_handler" # Key for the setup code itself
+        key="setup_js_comms" # Key for the setup code itself
     )
 
-    # Check if the Python handler function was triggered in the previous interaction
+    # 3. Process data received from JS callbacks (if any were triggered)
+    # Check for placement data
     if 'js_place_event_handler' in st.session_state:
-        # The handle_js_object_placed function should have stored data in this key
         placed_data = st.session_state.pop('js_object_placed_data', None)
-        if placed_data:
-            print(f"Python processed stored placed object data: {placed_data.get('obj_id')}")
-            # Action log already added in handle_js_object_placed.
-            # No server-side dict to update, client manages its state until save.
-            pass
-        # Remove the trigger key itself to prevent re-processing
-        del st.session_state['js_place_event_handler']
+        if placed_data: print(f"🐍 Python processed placed object: {placed_data.get('obj_id')}")
+        del st.session_state['js_place_event_handler'] # Clear trigger
+
+    # Check for save data
+    if 'js_save_state_handler' in st.session_state:
+        saved_data_str = st.session_state.pop('js_save_state_data', None)
+        del st.session_state['js_save_state_handler']
+        if saved_data_str:
+            print("🐍 Python processing saved world data received from JS...")
+            try:
+                world_data_dict = json.loads(saved_data_str)
+                if isinstance(world_data_dict, dict):
+                    save_filename = st.session_state.get("pending_save_filename") # Get filename set by button
+                    save_op_text = st.session_state.get("pending_save_op_text", f"Saving {save_filename}...")
+                    is_overwrite = st.session_state.get("pending_save_is_overwrite", False)
+                    if save_filename:
+                         with st.spinner(save_op_text):
+                             if save_world_to_md(save_filename, world_data_dict):
+                                 action = "Overwritten" if is_overwrite else "Saved new"; st.success(f"World {action}: {save_filename}");
+                                 add_action_log(f"Saved world: {save_filename}", emoji="💾")
+                                 st.session_state.current_world_file = save_filename # Update current file
+                                 # Clear pending save state
+                                 st.session_state.pop("pending_save_filename", None); st.session_state.pop("pending_save_op_text", None); st.session_state.pop("pending_save_is_overwrite", None)
+                                 st.rerun() # Refresh lists
+                             else: st.error("❌ Failed to save world state to file.")
+                    else: st.error("❌ Save triggered but filename was missing in state.")
+                else: st.error("❌ Invalid save data format received.")
+            except json.JSONDecodeError: st.error("❌ Failed to decode save data from JS.")
+            except Exception as e: st.error(f"❌ Error processing save data: {e}"); st.exception(e)
+        else: print("⚠️ Save callback triggered, but no save data found.")
 
 
     # Define Tabs
@@ -770,142 +834,100 @@ def render_main_content():
 
     # --- World Builder Tab ---
     with tab_world:
-        st.header("Shared 3D World")
-        st.caption("Place objects using sidebar tools. Use Sidebar to Save/Load.")
+        st.header("🌌 Shared Dreamscape")
+        st.caption("✨ Weave reality with sidebar tools. Save your creations!")
         current_file_basename = st.session_state.get('current_world_file', None)
         if current_file_basename:
              full_path = os.path.join(SAVED_WORLDS_DIR, current_file_basename)
-             if os.path.exists(full_path): parsed = parse_world_filename(full_path); st.info(f"Current World: **{parsed['name']}** (`{current_file_basename}`)")
-             else: st.warning(f"Loaded file '{current_file_basename}' missing."); st.session_state.current_world_file = None
-        else: st.info("Live State Active (Save to persist)")
+             if os.path.exists(full_path): parsed = parse_world_filename(full_path); st.info(f"🌠 Viewing: **{parsed['name']}** (`{current_file_basename}`)")
+             else: st.warning(f"⚠️ Loaded file '{current_file_basename}' missing."); st.session_state.current_world_file = None
+        else: st.info("☁️ Live State Active (Save to persist)")
 
         # Embed HTML Component
         html_file_path = 'index.html'
         try:
             with open(html_file_path, 'r', encoding='utf-8') as f: html_template = f.read()
             # Inject state needed by JS
-            # Load initial data for injection *only if* no specific load is pending
-            initial_world_data = {}
-            if world_data_to_load is None: # Check if data was *not* popped above
-                 if st.session_state.get('current_world_file'):
-                      loaded_dict = load_world_from_md(st.session_state.current_world_file)
-                      if loaded_dict: initial_world_data = loaded_dict
-                 # If current_world_file is None AND world_data_to_load is None, initial_world_data remains {}
+            initial_world_data = {} # Default empty, loadWorldState handles initial load
+            if world_data_to_load is None and st.session_state.get('current_world_file'):
+                 # If a file is selected, but wasn't just loaded (e.g., page refresh), load its data for initial injection
+                 loaded_dict = load_world_from_md(st.session_state.current_world_file)
+                 if loaded_dict: initial_world_data = loaded_dict
 
             js_injection_script = f"""<script>
     window.USERNAME = {json.dumps(st.session_state.username)};
     window.SELECTED_OBJECT_TYPE = {json.dumps(st.session_state.selected_object)};
     window.PLOT_WIDTH = {json.dumps(PLOT_WIDTH)};
     window.PLOT_DEPTH = {json.dumps(PLOT_DEPTH)};
-    // Send current state ONLY if not handled by explicit loadWorldState call
-    window.INITIAL_WORLD_OBJECTS = {json.dumps(initial_world_data)};
-    console.log("Streamlit State Injected:", {{ username: window.USERNAME, selectedObject: window.SELECTED_OBJECT_TYPE, initialObjects: {len(initial_world_data)} }});
+    window.INITIAL_WORLD_OBJECTS = {json.dumps(initial_world_data)}; /* Used only if loadWorldState isn't called */
+    console.log("🐍 Streamlit State Injected:", {{ username: window.USERNAME, selectedObject: window.SELECTED_OBJECT_TYPE, initialObjectsInject: {len(initial_world_data)} }});
 </script>"""
             html_content_with_state = html_template.replace('</head>', js_injection_script + '\n</head>', 1)
             components.html(html_content_with_state, height=700, scrolling=False)
-        except FileNotFoundError: st.error(f"CRITICAL ERROR: Could not find '{html_file_path}'.")
-        except Exception as e: st.error(f"Error loading 3D component: {e}"); st.exception(e)
+        except FileNotFoundError: st.error(f"❌ CRITICAL ERROR: Could not find '{html_file_path}'.")
+        except Exception as e: st.error(f"❌ Error loading 3D component: {e}"); st.exception(e)
 
     # --- Chat Tab ---
     with tab_chat:
-        st.header(f"💬 Chat")
+        st.header(f"💬 Whispers in the Void")
         chat_history_list = st.session_state.get('chat_history', [])
         if not chat_history_list: chat_history_list = asyncio.run(load_chat_history())
         chat_container = st.container(height=500)
         with chat_container:
              if chat_history_list: st.markdown("----\n".join(reversed(chat_history_list[-50:])))
-             else: st.caption("No chat messages yet.")
+             else: st.caption("🌬️ Silence reigns...")
 
         def clear_chat_input_callback(): st.session_state.message_input = ""
         message_value = st.text_input("Your Message:", key="message_input", label_visibility="collapsed")
-        send_button_clicked = st.button("Send Chat", key="send_chat_button", on_click=clear_chat_input_callback)
+        send_button_clicked = st.button("✉️ Send Message", key="send_chat_button", on_click=clear_chat_input_callback)
 
         if send_button_clicked:
-            message_to_send = message_value # Value before potential clear by callback
+            message_to_send = message_value
             if message_to_send.strip() and message_to_send != st.session_state.get('last_message', ''):
                 st.session_state.last_message = message_to_send
                 voice = st.session_state.get('tts_voice', DEFAULT_TTS_VOICE)
+                # Use run_async for background save/TTS generation
                 run_async(save_chat_entry, st.session_state.username, message_to_send, voice)
-                # Rerun is handled implicitly by button click + callback
+                add_action_log(f"Sent chat: {message_to_send[:20]}...", emoji="💬")
+                # Rerun is handled implicitly by button + on_click
             elif send_button_clicked: st.toast("Message empty or same as last.")
 
     # --- PDF Tab ---
     with tab_pdf:
-         st.header("📚 PDF Tools")
-         pdf_file = st.file_uploader("Upload PDF for Audio Conversion", type="pdf", key="pdf_upload")
-         max_pages = st.slider('Max Pages to Process', 1, 50, 10, key="pdf_pages")
+         st.header("📚 Tome Translator")
+         st.caption("🔊 Give voice to the silent knowledge within PDF scrolls.")
+         pdf_file = st.file_uploader("Upload PDF Scroll", type="pdf", key="pdf_upload")
+         max_pages = st.slider('Max Pages to Animate', 1, 50, 10, key="pdf_pages")
          if pdf_file:
-             if st.button("Process PDF to Audio", key="process_pdf_button"):
-                 with st.spinner("Processing PDF... This may take time."):
+             if st.button("🎙️ Animate PDF to Audio", key="process_pdf_button"):
+                 with st.spinner("✨ Transcribing ancient glyphs to sound..."):
                      process_pdf_tab(pdf_file, max_pages, st.session_state.tts_voice)
 
     # --- Files & Settings Tab ---
     with tab_files:
-        st.header("📂 Files & Settings")
-        st.subheader("💾 World Management")
-        current_file_basename = st.session_state.get('current_world_file', None)
+        st.header("📂 Archives & Settings")
+        st.caption("⚙️ Manage saved scrolls and application settings.")
 
-        if current_file_basename:
-            full_path_for_parse = os.path.join(SAVED_WORLDS_DIR, current_file_basename)
-            save_label = f"Save Changes to '{current_file_basename}'"
-            if os.path.exists(full_path_for_parse): parsed = parse_world_filename(full_path_for_parse); save_label = f"Save Changes to '{parsed['name']}'"
-            if st.button(save_label, key="save_current_world_files", help=f"Overwrite '{current_file_basename}'"):
-                 if not os.path.exists(full_path_for_parse): st.error(f"Cannot save, file missing.")
-                 else:
-                     with st.spinner("Requesting state & saving..."):
-                          js_world_state_str = streamlit_js_eval("getWorldStateForSave();", key="get_world_state_save_current", want_result=True)
-                          if js_world_state_str:
-                               try:
-                                   world_data_dict = json.loads(js_world_state_str)
-                                   if isinstance(world_data_dict, dict):
-                                       if save_world_to_md(current_file_basename, world_data_dict): st.success("Current world saved!"); add_action_log(f"Saved world: {current_file_basename}")
-                                       else: st.error("Failed to save.")
-                                   else: st.error("Invalid format from client.")
-                               except json.JSONDecodeError: st.error("Failed to decode state from client.")
-                          else: st.warning("Did not receive world state from client.")
-        else: st.info("Load a world or use 'Save As New Version' below.")
-
-        st.subheader("Save As New Version")
-        new_name_files = st.text_input("World Name:", key="new_world_name_files_tab", value=st.session_state.get('new_world_name', 'MyWorld'))
-        if st.button("💾 Save Current View as New Version", key="save_new_version_files"):
-             if new_name_files.strip():
-                 with st.spinner(f"Requesting state & saving as '{new_name_files}'..."):
-                      js_world_state_str = streamlit_js_eval("getWorldStateForSave();", key="get_world_state_save_new", want_result=True)
-                      if js_world_state_str:
-                           try:
-                               world_data_dict = json.loads(js_world_state_str)
-                               if isinstance(world_data_dict, dict):
-                                   new_filename_base = generate_world_save_filename(st.session_state.username, new_name_files)
-                                   if save_world_to_md(new_filename_base, world_data_dict):
-                                       st.success(f"Saved as {new_filename_base}")
-                                       st.session_state.current_world_file = new_filename_base; st.session_state.new_world_name = "MyWorld";
-                                       add_action_log(f"Saved new world: {new_filename_base}")
-                                       st.rerun()
-                                   else: st.error("Failed to save new version.")
-                               else: st.error("Invalid format from client.")
-                           except json.JSONDecodeError: st.error("Failed to decode state from client.")
-                      else: st.warning("Did not receive world state from client.")
-             else: st.warning("Please enter a name.")
-
-        # Removed Server Status Section
-
-        st.subheader("🗑️ Delete Files")
+        st.subheader("💾 World Scroll Management")
+        # Save buttons moved to sidebar for this iteration
+
+        st.subheader("🗑️ Archive Maintenance")
+        st.caption("🧹 Cleanse the old to make way for the new.")
         st.warning("Deletion is permanent!", icon="⚠️")
         col_del1, col_del2, col_del3, col_del4 = st.columns(4)
         with col_del1:
-             if st.button("🗑️ Chats", key="del_chat_md"): delete_files([os.path.join(CHAT_DIR, "*.md")]); st.session_state.chat_history = []; st.rerun()
+             if st.button("🗑️ Chats", key="del_chat_md"): delete_files([os.path.join(CHAT_DIR, "*.md")]); st.session_state.chat_history = []; add_action_log("Cleared Chats", emoji="🧹"); st.rerun()
         with col_del2:
-            if st.button("🗑️ Audio", key="del_audio_mp3"): delete_files([os.path.join(AUDIO_DIR, "*.mp3"), os.path.join(AUDIO_CACHE_DIR, "*.mp3")]); st.session_state.audio_cache = {}; st.rerun()
+            if st.button("🗑️ Audio", key="del_audio_mp3"): delete_files([os.path.join(AUDIO_DIR, "*.mp3"), os.path.join(AUDIO_CACHE_DIR, "*.mp3")]); st.session_state.audio_cache = {}; add_action_log("Cleared Audio", emoji="🧹"); st.rerun()
         with col_del3:
-            # Corrected delete pattern using prefix
-            if st.button("🗑️ Worlds", key="del_worlds_md"): delete_files([os.path.join(SAVED_WORLDS_DIR, f"{WORLD_STATE_FILE_MD_PREFIX}*.md")]); st.session_state.current_world_file = None; st.rerun()
+            if st.button("🗑️ Worlds", key="del_worlds_md"): delete_files([os.path.join(SAVED_WORLDS_DIR, f"{WORLD_STATE_FILE_MD_PREFIX}*.md")]); st.session_state.current_world_file = None; add_action_log("Cleared Worlds", emoji="🧹"); st.rerun()
         with col_del4:
-            if st.button("🗑️ All Gen", key="del_all_gen"): delete_files([os.path.join(CHAT_DIR, "*.md"), os.path.join(AUDIO_DIR, "*.mp3"), os.path.join(AUDIO_CACHE_DIR, "*.mp3"), os.path.join(SAVED_WORLDS_DIR, "*.md"), os.path.join(MEDIA_DIR, "*.zip")]); st.session_state.chat_history = []; st.session_state.audio_cache = {}; st.session_state.current_world_file = None; st.rerun()
+            if st.button("🗑️ All Gen", key="del_all_gen"): delete_files([os.path.join(CHAT_DIR, "*.md"), os.path.join(AUDIO_DIR, "*.mp3"), os.path.join(AUDIO_CACHE_DIR, "*.mp3"), os.path.join(SAVED_WORLDS_DIR, "*.md"), os.path.join(MEDIA_DIR, "*.zip")]); st.session_state.chat_history = []; st.session_state.audio_cache = {}; st.session_state.current_world_file = None; add_action_log("Cleared All Generated", emoji="🔥"); st.rerun()
 
         st.subheader("📦 Download Archives")
+        st.caption("Bundle your creations for safekeeping or sharing.")
         col_zip1, col_zip2, col_zip3 = st.columns(3)
         with col_zip1:
-            # Corrected path for zipping worlds
             if st.button("Zip Worlds"): create_zip_of_files(glob.glob(os.path.join(SAVED_WORLDS_DIR, f"{WORLD_STATE_FILE_MD_PREFIX}*.md")), "Worlds")
         with col_zip2:
             if st.button("Zip Chats"): create_zip_of_files(glob.glob(os.path.join(CHAT_DIR, "*.md")), "Chats")
@@ -916,9 +938,7 @@ def render_main_content():
             st.caption("Existing Zip Files:")
             for zip_file in zip_files: st.markdown(get_download_link(zip_file, "zip"), unsafe_allow_html=True)
         else:
-            # Correct indentation confirmed here
-            st.caption("No zip archives found.")
-
+            st.caption("🌬️ No archives found.")
 
 # ==============================================================================
 # Main Execution Logic
@@ -933,25 +953,22 @@ def initialize_app():
         if loaded_user and loaded_user in FUN_USERNAMES: st.session_state.username = loaded_user; st.session_state.tts_voice = FUN_USERNAMES[loaded_user]
         else: st.session_state.username = random.choice(list(FUN_USERNAMES.keys())) if FUN_USERNAMES else "User"; st.session_state.tts_voice = FUN_USERNAMES.get(st.session_state.username, DEFAULT_TTS_VOICE); save_username(st.session_state.username)
 
-    # Set up initial world state to load IF this is the first run AND no specific load is already pending
-    if 'world_to_load_data' not in st.session_state or st.session_state.world_to_load_data is None:
-        if st.session_state.get('current_world_file') is None: # Only load initially if no world is 'active'
-            print("Attempting initial load of most recent world...")
-            saved_worlds = get_saved_worlds()
-            if saved_worlds:
-                 latest_world_file_basename = os.path.basename(saved_worlds[0]['filename'])
-                 print(f"Queueing most recent world for load: {latest_world_file_basename}")
-                 world_dict = load_world_from_md(latest_world_file_basename)
-                 if world_dict is not None:
-                      st.session_state.world_to_load_data = world_dict # Queue data to be sent to JS
-                      st.session_state.current_world_file = latest_world_file_basename # Set as current
-                 else: print("Failed to load most recent world.")
-            else:
-                 print("No saved worlds found, starting empty.");
-                 st.session_state.world_to_load_data = {} # Send empty state to JS initially
+    # Queue initial world state load IF no world is selected AND no load is pending
+    if st.session_state.get('world_to_load_data') is None and st.session_state.get('current_world_file') is None:
+        print("🐍 Attempting initial load of most recent world...")
+        saved_worlds = get_saved_worlds()
+        if saved_worlds:
+             latest_world_file_basename = os.path.basename(saved_worlds[0]['filename'])
+             print(f"🐍 Queueing most recent world for load: {latest_world_file_basename}")
+             world_dict = load_world_from_md(latest_world_file_basename)
+             if world_dict is not None:
+                  st.session_state.world_to_load_data = world_dict # Queue data
+                  st.session_state.current_world_file = latest_world_file_basename # Set as current
+             else: print("❌ Failed to load most recent world."); st.session_state.world_to_load_data = {} # Send empty state
+        else: print("🌫️ No saved worlds found."); st.session_state.world_to_load_data = {} # Send empty state
 
 
 if __name__ == "__main__":
     initialize_app() # Initialize state, user, queue initial world load data
-    render_sidebar() # Render sidebar UI (includes load buttons)
+    render_sidebar() # Render sidebar UI
     render_main_content() # Render main UI (includes logic to send queued world data to JS)