Update app.py

app.py

@@ -1,7 +1,6 @@
-# app.py (Refactored & Consolidated - Corrected Indentation)
+# app.py (Simplified - No WebSockets, Direct JS Communication)
 import streamlit as st
-import asyncio
-import websockets
+import asyncio # Keep for TTS
 import uuid
 from datetime import datetime
 import os
@@ -12,76 +11,62 @@ import glob
 import base64
 import io
 import streamlit.components.v1 as components
-import edge_tts
+import edge_tts # Keep for TTS
 import nest_asyncio
 import re
 import pytz
 import shutil
-from PyPDF2 import PdfReader
+from PyPDF2 import PdfReader # Keep if PDF tab is kept
 import threading
 import json
 import zipfile
 from dotenv import load_dotenv
-from streamlit_marquee import streamlit_marquee # Keep import if used
+from streamlit_marquee import streamlit_marquee # Keep if used
 from collections import defaultdict, Counter
-import pandas as pd # Keep for potential fallback logic if needed
-from streamlit_js_eval import streamlit_js_eval
+# import pandas as pd # Only needed if CSV fallback kept, can likely remove
+from streamlit_js_eval import streamlit_js_eval, sync # Use sync for direct calls
 from PIL import Image # Needed for paste_image_component
 
 # ==============================================================================
 # Configuration & Constants
 # ==============================================================================
 
-# 🛠️ Patch asyncio for nesting
+# 🛠️ Patch asyncio for nesting (May still be needed for TTS)
 nest_asyncio.apply()
 
 # 🎨 Page Config
-st.set_page_config(
-    page_title="🤖🏗️ Shared World Builder 🏆",
-    page_icon="🏗️",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
+st.set_page_config(page_title="🏗️ Simpler World Builder 🏆", page_icon="🏗️", layout="wide", initial_sidebar_state="expanded")
 
 # General Constants
-icons = '🤖🏗️🗣️💾'
-Site_Name = '🤖🏗️ Shared World Builder 🗣️'
-START_ROOM = "World Lobby 🌍"
-MEDIA_DIR = "." # Base directory for general files
+Site_Name = '🏗️ Simpler World Builder'
+MEDIA_DIR = "."
 STATE_FILE = "user_state.txt" # For remembering username
 
-# User/Chat Constants
-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",
-}
-EDGE_TTS_VOICES = list(set(FUN_USERNAMES.values()))
-CHAT_DIR = "chat_logs"
+# User/Chat Constants (Simplified - No longer needed for WS identity)
+# FUN_USERNAMES = { ... } # Can remove if not used elsewhere
+# EDGE_TTS_VOICES = list(set(FUN_USERNAMES.values())) # Define default voice directly if needed
+DEFAULT_TTS_VOICE = "en-US-AriaNeural"
+CHAT_DIR = "chat_logs" # Keep if chat tab remains
 
 # Audio Constants
 AUDIO_CACHE_DIR = "audio_cache"
 AUDIO_DIR = "audio_logs"
 
 # World Builder Constants
-SAVED_WORLDS_DIR = "saved_worlds" # Directory for MD world files
+SAVED_WORLDS_DIR = "saved_worlds"
 PLOT_WIDTH = 50.0 # Needed for JS injection
 PLOT_DEPTH = 50.0 # Needed for JS injection
-WORLD_STATE_FILE_MD_PREFIX = "🌍_" # Prefix for world save files
+WORLD_STATE_FILE_MD_PREFIX = "🌍_"
 
 # File Emojis
 FILE_EMOJIS = {"md": "📝", "mp3": "🎵", "png": "🖼️", "mp4": "🎥", "zip": "📦", "json": "📄"}
 
-# --- Mapping Emojis to Primitive Types ---
-# Ensure these types match the createPrimitiveMesh function keys in index.html
+# Mapping Emojis to Primitive Types
 PRIMITIVE_MAP = {
     "🌳": "Tree", "🗿": "Rock", "🏛️": "Simple House", "🌲": "Pine Tree", "🧱": "Brick Wall",
     "🔵": "Sphere", "📦": "Cube", "🧴": "Cylinder", "🍦": "Cone", "🍩": "Torus",
     "🍄": "Mushroom", "🌵": "Cactus", "🔥": "Campfire", "⭐": "Star", "💎": "Gem",
     "🗼": "Tower", "🚧": "Barrier", "⛲": "Fountain", "🏮": "Lantern", "팻": "Sign Post"
-    # Add more pairs up to ~20 if desired
 }
 
 # --- Directories ---
@@ -90,107 +75,60 @@ for d in [CHAT_DIR, AUDIO_DIR, AUDIO_CACHE_DIR, SAVED_WORLDS_DIR]:
 
 # --- API Keys (Placeholder) ---
 load_dotenv()
-# ANTHROPIC_KEY = os.getenv('ANTHROPIC_API_KEY', st.secrets.get('ANTHROPIC_API_KEY', ""))
-# OPENAI_KEY = os.getenv('OPENAI_API_KEY', st.secrets.get('OPENAI_API_KEY', ""))
 
-# --- Global State & Locks ---
+# --- Global State & Lock ---
+# Lock remains important for modifying the shared dictionary from potentially different Streamlit sessions/reruns
 world_objects_lock = threading.Lock()
-world_objects = defaultdict(dict) # In-memory world state {obj_id: data}
-connected_clients = set() # Holds client_id strings
+# THIS NOW REPRESENTS THE STATE LOADED FROM A FILE OR BUILT UP LOCALLY BEFORE SAVING
+# IT IS *NOT* A LIVE REPRESENTATION OF ALL USERS' ACTIONS
+world_objects = defaultdict(dict)
 
 # ==============================================================================
-# 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=30):
-    """Cleans a string part for use in a filename."""
     if not isinstance(text, str): text = "invalid_name"
-    text = re.sub(r'\s+', '_', text) # Replace spaces
-    text = re.sub(r'[^\w\-.]', '', text) # Keep word chars, hyphen, period
+    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."""
-    try:
-        loop = asyncio.get_running_loop()
-        return loop.create_task(async_func(*args, **kwargs))
-    except RuntimeError: # No running loop in this thread
-        # 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)
-
-# Ensure directories exist on startup
-for d in [CHAT_DIR, AUDIO_DIR, AUDIO_CACHE_DIR, SAVED_WORLDS_DIR]:
-    ensure_dir(d)
+def ensure_dir(dir_path): os.makedirs(dir_path, exist_ok=True)
 
 # ==============================================================================
-# World State File Handling (Markdown + JSON)
+# World State File Handling (Markdown + JSON) - Keep as is
 # ==============================================================================
-
 def generate_world_save_filename(name="World"):
-    """Generates a filename for saving world state MD files."""
-    timestamp = get_current_time_str() # Use UTC for consistency
-    clean_name = clean_filename_part(name)
-    rand_hash = hashlib.md5(str(time.time()).encode() + name.encode()).hexdigest()[:6] # Seed hash
+    timestamp = get_current_time_str(); clean_name = clean_filename_part(name);
+    rand_hash = hashlib.md5(str(time.time()).encode() + name.encode()).hexdigest()[:6]
     return f"{WORLD_STATE_FILE_MD_PREFIX}{clean_name}_{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_name = basename[len(WORLD_STATE_FILE_MD_PREFIX):-3]
-        parts = core_name.split('_')
-        if len(parts) >= 3: # Expecting Name_Timestamp_Hash
-            timestamp_str = parts[-2]
-            name_parts = parts[:-2]; name = "_".join(name_parts) if name_parts else "Untitled"
-            dt_obj = None
-            try:
-                dt_obj = datetime.strptime(timestamp_str, '%Y%m%d_%H%M%S')
-                dt_obj = pytz.utc.localize(dt_obj)
-            except (ValueError, pytz.exceptions.AmbiguousTimeError, pytz.exceptions.NonExistentTimeError): dt_obj = None
+        core_name = basename[len(WORLD_STATE_FILE_MD_PREFIX):-3]; parts = core_name.split('_')
+        if len(parts) >= 3:
+            timestamp_str = parts[-2]; name_parts = parts[:-2]; name = "_".join(name_parts) if name_parts else "Untitled"; 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": name.replace('_', ' '), "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)
+    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',''), "timestamp": "Unknown", "dt": dt_fallback, "filename": filename}
 
-
 def save_world_state_to_md(target_filename_base):
-    """Saves the current in-memory world state to a specific MD file (basename)."""
+    """Saves the current 'world_objects' state to a specific MD file."""
     global world_objects
     save_path = os.path.join(SAVED_WORLDS_DIR, target_filename_base)
     print(f"Acquiring lock to save world state to: {save_path}...")
     success = False
     with world_objects_lock:
-        world_data_dict = dict(world_objects)
-        print(f"Saving {len(world_data_dict)} objects...")
-        parsed_info = parse_world_filename(save_path)
-        timestamp_save = get_current_time_str()
+        world_data_dict = dict(world_objects); 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']}
 * **File Saved:** {timestamp_save} (UTC)
 * **Source Timestamp:** {parsed_info['timestamp']}
@@ -200,29 +138,23 @@ def save_world_state_to_md(target_filename_base):
 {json.dumps(world_data_dict, indent=2)}
 ```"""
         try:
-            ensure_dir(SAVED_WORLDS_DIR)
+            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}")
+            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_state_from_md(filename_base):
-    """Loads world state from an MD file (basename), updates global state, returns success bool."""
+    """Loads world state from MD, updates global 'world_objects', returns success bool."""
     global world_objects
     load_path = os.path.join(SAVED_WORLDS_DIR, filename_base)
     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()
-        json_match = re.search(r"```json\s*(\{[\s\S]*?\})\s*```", content, re.IGNORECASE) # More robust regex
+        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 False
-
         world_data_dict = json.loads(json_match.group(1))
-
         print(f"Acquiring lock to update world state from {filename_base}...")
         with world_objects_lock:
              world_objects.clear()
@@ -231,31 +163,28 @@ def load_world_state_from_md(filename_base):
         print(f"Loaded {loaded_count} objects from {filename_base}. Lock released.")
         st.session_state.current_world_file = filename_base
         return True
-
-    except json.JSONDecodeError as e: st.error(f"Invalid JSON found 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."""
     try:
-        ensure_dir(SAVED_WORLDS_DIR)
+        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]
         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
 # ==============================================================================
 
-def save_username(username):
+def save_username(username): # Keep this simple utility
     try:
         with open(STATE_FILE, 'w') as f: f.write(username)
     except Exception as e: print(f"Failed save username: {e}")
 
-def load_username():
+def load_username(): # Keep this
     if os.path.exists(STATE_FILE):
         try:
             with open(STATE_FILE, 'r') as f: return f.read().strip()
@@ -265,66 +194,29 @@ def load_username():
 def init_session_state():
     """Initializes Streamlit session state variables."""
     defaults = {
-        'server_running_flag': False, 'server_instance': None, 'server_task': None,
-        'active_connections': defaultdict(dict), 'last_chat_update': 0, 'message_input': "",
-        'audio_cache': {}, 'tts_voice': "en-US-AriaNeural", 'chat_history': [],
-        'marquee_settings': {"background": "#1E1E1E", "color": "#FFFFFF", "font-size": "14px", "animationDuration": "20s", "width": "100%", "lineHeight": "35px"},
+        # Removed WS state: server_running_flag, server_instance, server_task, active_connections
+        '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': "", 'timer_start': time.time(), 'last_sent_transcript': "",
-        'last_refresh': time.time(), 'auto_refresh': False, 'refresh_rate': 30,
-        'selected_object': 'None', 'initial_world_state_loaded': False,
+        'last_message': "",
+        'selected_object': 'None', # Current building tool
+        'initial_world_state_loaded': False, # Flag to load state only once per session
         'current_world_file': None, # Track loaded world filename (basename)
-        'operation_timings': {}, 'performance_metrics': defaultdict(list),
-        'paste_image_base64': "", 'new_world_name': "MyWorld"
+        'paste_image_base64': "", 'new_world_name': "MyWorld",
+        'js_event_data': None # NEW: To store data pushed from JS
     }
     for k, v in defaults.items():
         if k not in st.session_state: st.session_state[k] = v
     # Ensure complex types initialized correctly
-    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.marquee_settings, dict): st.session_state.marquee_settings = defaults['marquee_settings']
     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 = {}
 
+
 # ==============================================================================
-# Audio / TTS / Chat / File Handling Helpers
+# Audio / TTS / Chat / File Handling Helpers (Largely unchanged, remove WS calls)
 # ==============================================================================
-
-# --- Text & File Helpers ---
-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)
-        # print(f"Created file: {save_path}"); # Verbose
-        return save_path
-    except Exception as e: print(f"Error creating file {save_path}: {e}"); return None
-
-def get_download_link(file_path, file_type="md"):
-    """Generates a base64 download link for a given file."""
-    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)
-    except OSError: mtime = 0
-    cache_key = f"dl_{file_path}_{mtime}";
-    if 'download_link_cache' not in st.session_state: st.session_state.download_link_cache = {}
-    if cache_key not in st.session_state.download_link_cache:
-        try:
-            with open(file_path, "rb") as f: b64 = base64.b64encode(f.read()).decode()
-            mime_types = {"md": "text/markdown", "mp3": "audio/mpeg", "png": "image/png", "mp4": "video/mp4", "zip": "application/zip", "json": "application/json"}
-            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>"
-    return st.session_state.download_link_cache.get(cache_key, "<small>CacheErr</small>")
-
-# --- Audio / TTS ---
-async def async_edge_tts_generate(text, voice, username):
-    """Generates TTS audio using EdgeTTS and caches the result."""
+async def async_edge_tts_generate(text, voice, username): # No change needed
     if not text: return None
     cache_key = hashlib.md5(f"{text[:150]}_{voice}".encode()).hexdigest();
     if 'audio_cache' not in st.session_state: st.session_state.audio_cache = {}
@@ -340,8 +232,7 @@ async def async_edge_tts_generate(text, voice, username):
         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):
-    """Displays audio player and download link in Streamlit."""
+def play_and_download_audio(file_path): # No change needed
     if file_path and os.path.exists(file_path):
         try:
              st.audio(file_path)
@@ -349,9 +240,7 @@ def play_and_download_audio(file_path):
              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}")
 
-# --- Chat ---
-async def save_chat_entry(username, message, voice, is_markdown=False):
-    """Saves chat entry to a file and session state, generates audio."""
+async def save_chat_entry(username, message, voice, is_markdown=False): # No change needed
     if not message.strip(): return None, None
     timestamp_str = get_current_time_str();
     entry = f"[{timestamp_str}] {username} ({voice}): {message}" if not is_markdown else f"[{timestamp_str}] {username} ({voice}):\n```markdown\n{message}\n```"
@@ -361,16 +250,14 @@ async def save_chat_entry(username, message, voice, is_markdown=False):
     st.session_state.chat_history.append(entry) # Add to live history
     audio_file = None;
     if st.session_state.get('enable_audio', True):
-         tts_message = message # Use original message for TTS
+         tts_message = message
          audio_file = await async_edge_tts_generate(tts_message, voice, username)
     return md_file, audio_file
 
-async def load_chat_history():
-    """Loads chat history from files if session state is empty."""
+async def load_chat_history(): # No change needed
     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:
@@ -381,8 +268,8 @@ async def load_chat_history():
         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"):
+# --- File Management (Keep Create Zip, Delete Files) ---
+def create_zip_of_files(files_to_zip, prefix="Archive"): # Keep as is
     if not files_to_zip: st.warning("No files provided to zip."); return None
     timestamp = format_timestamp_prefix(f"Zip_{prefix}"); zip_name = f"{prefix}_{timestamp}.zip"
     try:
@@ -394,16 +281,14 @@ def create_zip_of_files(files_to_zip, prefix="Archive"):
         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
 
-def delete_files(file_patterns, exclude_files=None):
-    """Deletes files matching patterns, excluding protected/specified files."""
+def delete_files(file_patterns, exclude_files=None): # Keep as is
     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) # Protect currently loaded world
+    if current_world_base: protected.append(current_world_base)
     if exclude_files: protected.extend(exclude_files)
-
     deleted_count = 0; errors = 0
     for pattern in file_patterns:
-         pattern_path = pattern # Assume pattern includes path from os.path.join
+         pattern_path = pattern
          print(f"Attempting to delete files matching: {pattern_path}")
          try:
               files_to_delete = glob.glob(pattern_path)
@@ -422,50 +307,45 @@ def delete_files(file_patterns, exclude_files=None):
     st.session_state['download_link_cache'] = {}; st.session_state['audio_cache'] = {}
 
 
-# --- Image Handling ---
-async def save_pasted_image(image, username):
+# --- Image Handling (Keep paste component logic) ---
+async def save_pasted_image(image, username): # Keep as is
      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
 
-def paste_image_component():
+def paste_image_component(): # Keep as is
       pasted_img = None; img_type = None
-      # Use a button outside the form to trigger processing the text_area value
       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', ""))
       if st.button("Process Pasted Image 📋", key="process_paste_button"):
-           st.session_state.paste_image_base64_input = paste_input_value # Store value when button clicked
+           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 b64
-                   st.session_state.paste_image_base64_input = "" # Clear input area state
-                   st.experimental_rerun() # Rerun to clear text area visually
+                   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 = "" # Clear input state on success
+                   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 = ""
+               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 # Keep invalid data
            else:
-                st.warning("No valid image data pasted."); st.session_state.paste_image_base64 = ""; st.session_state.paste_image_base64_input = paste_input_value # Keep invalid data if user wants to edit?
-
-      # Return the image if it was processed successfully *in the previous run* (due to rerun)
+                st.warning("No valid image data pasted."); st.session_state.paste_image_base64 = ""; st.session_state.paste_image_base64_input = paste_input_value
+      # Return image if processed in previous run
       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 # Failed to decode stored 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:
+# --- PDF Processing (Keep if desired) ---
+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'):
+      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);
@@ -477,49 +357,40 @@ class AudioProcessor:
                  else: return None
             except Exception as e: print(f"TTS Create Audio Error: {e}"); return None
 
-def process_pdf_tab(pdf_file, max_pages, voice):
+def process_pdf_tab(pdf_file, max_pages, voice): # Keep as is
     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)
+        reader=PdfReader(pdf_file);
         if reader.is_encrypted: st.warning("PDF is encrypted."); return
         total_pages=min(len(reader.pages),max_pages);
         st.write(f"Processing first {total_pages} pages of '{pdf_file.name}'...")
         texts, audios={}, {}; page_threads = []; results_lock = threading.Lock()
 
-        # Nested function to process each page in a thread
         def process_page_sync(page_num, page_text):
             async def run_async_audio(): return await audio_processor.create_audio(page_text, voice)
-            try:
-                 # Using asyncio.run here is simpler in thread context than managing loops explicitly
-                 audio_path = asyncio.run(run_async_audio())
+            try: audio_path = asyncio.run(run_async_audio())
                  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(total_pages):
              try:
                  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]"
+                 else: texts[i] = "[No text extracted]"
              except Exception as extract_e: texts[i] = f"[Error extract: {extract_e}]"; print(f"Error page {i+1} extract: {extract_e}")
 
-        # 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()
+        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
+            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."); break # 10 min timeout
+            if time.time() - start_join_time > 600: print("PDF processing timed out."); break
             time.sleep(0.5)
         progress_bar.progress(1.0, text="Processing complete.")
 
-        # Display results
-        st.write("Displaying results:")
         for i in range(total_pages):
               with st.expander(f"Page {i+1}"):
                    st.markdown(texts.get(i, "[Error getting text]"))
@@ -530,139 +401,6 @@ def process_pdf_tab(pdf_file, max_pages, voice):
     except Exception as pdf_e: st.error(f"Err read PDF: {pdf_e}"); st.exception(pdf_e)
 
 
-# ==============================================================================
-# WebSocket Server Logic
-# ==============================================================================
-
-async def register_client(websocket):
-    client_id = str(websocket.id); 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); 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."""
-    if not connected_clients: return
-    tasks = []; current_client_ids = list(connected_clients); active_connections_copy = st.session_state.active_connections.copy()
-    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) # Gather results/exceptions
-
-async def broadcast_world_update():
-    """Broadcasts the current world state to all clients."""
-    with world_objects_lock: current_state_payload = dict(world_objects)
-    update_msg = json.dumps({"type": "initial_state", "payload": current_state_payload})
-    print(f"Broadcasting full world update ({len(current_state_payload)} objects)...")
-    await broadcast_message(update_msg)
-
-async def websocket_handler(websocket, path):
-    """Handles WebSocket connections and messages."""
-    await register_client(websocket); client_id = str(websocket.id);
-    username = st.session_state.get('username', f"User_{client_id[:4]}")
-    try: # Send initial state
-        with world_objects_lock: initial_state_payload = dict(world_objects)
-        initial_state_msg = json.dumps({"type": "initial_state", "payload": initial_state_payload}); await websocket.send(initial_state_msg)
-        print(f"Sent initial state ({len(initial_state_payload)} objs) to {client_id}")
-        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 initial phase {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)
-
-                if msg_type == "chat_message":
-                    chat_text = payload.get('message', ''); voice = payload.get('voice', FUN_USERNAMES.get(sender_username, "en-US-AriaNeural"));
-                    run_async(save_chat_entry, sender_username, chat_text, voice) # Fire-and-forget save
-                    await broadcast_message(message, exclude_id=client_id) # Forward original msg
-
-                elif msg_type == "place_object":
-                    obj_data = payload.get("object_data");
-                    if obj_data and 'obj_id' in obj_data and 'type' in obj_data:
-                        with world_objects_lock: world_objects[obj_data['obj_id']] = obj_data
-                        broadcast_payload = json.dumps({"type": "object_placed", "payload": {"object_data": obj_data, "username": sender_username}});
-                        await broadcast_message(broadcast_payload, exclude_id=client_id)
-                    else: print(f"WS Invalid place_object payload: {payload}")
-
-                elif msg_type == "delete_object":
-                     obj_id = payload.get("obj_id"); removed = False
-                     if obj_id:
-                          with world_objects_lock:
-                              if obj_id in world_objects: del world_objects[obj_id]; removed = True
-                          if removed:
-                               broadcast_payload = json.dumps({"type": "object_deleted", "payload": {"obj_id": obj_id, "username": sender_username}});
-                               await broadcast_message(broadcast_payload, exclude_id=client_id)
-                     else: print(f"WS Invalid delete_object payload: {payload}")
-
-                elif msg_type == "player_position":
-                     pos_data = payload.get("position"); rot_data = payload.get("rotation")
-                     if pos_data:
-                          broadcast_payload = json.dumps({"type": "player_moved", "payload": {"username": sender_username, "id": client_id, "position": pos_data, "rotation": rot_data}});
-                          await broadcast_message(broadcast_payload, exclude_id=client_id)
-
-            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)
-
-
-async def run_websocket_server():
-    """Coroutine to run the WebSocket server."""
-    if st.session_state.get('server_running_flag', False): return
-    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()
-    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():
-        loop = None
-        try: loop = asyncio.get_running_loop() # Check if loop exists in this thread
-        except RuntimeError: loop = asyncio.new_event_loop(); asyncio.set_event_loop(loop) # Create if not exists
-        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 # Expected if tasks cancelled
-                  loop.close(); print("Server thread loop closed.")
-             else: print("Server thread loop already closed or None.")
-    st.session_state.server_task = threading.Thread(target=run_loop, daemon=True); st.session_state.server_task.start(); time.sleep(1.5) # Allow time to start
-    if not st.session_state.server_task.is_alive(): print("### Server thread failed to stay alive!")
-
-
 # ==============================================================================
 # Streamlit UI Layout Functions
 # ==============================================================================
@@ -688,43 +426,52 @@ def render_sidebar():
              key="world_selector_radio"
          )
 
+        # Handle selection change
         if selected_basename != current_selection_basename:
              st.session_state.current_world_file = selected_basename
              if selected_basename:
                   with st.spinner(f"Loading {selected_basename}..."):
                       if load_world_state_from_md(selected_basename):
-                          run_async(broadcast_world_update); st.toast("World loaded!", icon="✅")
+                          st.toast("World loaded!", icon="✅")
+                          # Rerun will cause component to reload with injected state from world_objects
                       else: st.error("Failed to load world."); st.session_state.current_world_file = None
              else: print("Switched to live state."); st.toast("Switched to Live State.")
-             st.rerun()
+             st.rerun() # Rerun needed to update main view and component state
 
+        # Download Links for Worlds
         st.caption("Download:")
         cols = st.columns([4, 1])
         with cols[0]: st.write("**Name** (Timestamp)")
         with cols[1]: st.write("**DL**", help="Download")
         display_limit = 10
         for i, world_info in enumerate(saved_worlds):
-            f_basename = os.path.basename(world_info['filename'])
-            f_fullpath = os.path.join(SAVED_WORLDS_DIR, f_basename) # Reconstruct full path
-            display_name = world_info.get('name', f_basename)
-            timestamp = world_info.get('timestamp', 'N/A')
-            if i < display_limit:
-                col1, col2 = st.columns([4, 1]);
-                with col1: st.write(f"<small>{display_name} ({timestamp})</small>", unsafe_allow_html=True)
-                with col2: st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True)
-            elif i == display_limit: # Show expander starting from the limit item
-                 with st.expander(f"Show {len(saved_worlds)-display_limit} more..."):
-                    # Display the current item first inside expander
-                    col1_exp, col2_exp = st.columns([4, 1]);
-                    with col1_exp: st.write(f"<small>{display_name} ({timestamp})</small>", unsafe_allow_html=True)
-                    with col2_exp: st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True)
-                    # Display rest inside expander
-                    for world_info_more in saved_worlds[display_limit+1:]:
-                        f_basename_more = os.path.basename(world_info_more['filename']); f_fullpath_more = os.path.join(SAVED_WORLDS_DIR, f_basename_more); display_name_more = world_info_more.get('name', f_basename_more); timestamp_more = world_info_more.get('timestamp', 'N/A')
-                        colA, colB = st.columns([4, 1]);
-                        with colA: st.write(f"<small>{display_name_more} ({timestamp_more})</small>", unsafe_allow_html=True)
-                        with colB: st.markdown(get_download_link(f_fullpath_more, "md"), unsafe_allow_html=True)
-                 break # Stop outer loop after showing expander content
+            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); timestamp = world_info.get('timestamp', 'N/A')
+            is_last_displayed = i == display_limit -1
+            show_expander_trigger = len(saved_worlds) > display_limit and is_last_displayed
+
+            # Display logic adjusted for expander
+            if i < display_limit or (show_expander_trigger and i == display_limit): # Display items up to limit, and first item in expander
+                 container = st if i < display_limit else st.expander(f"Show {len(saved_worlds)-display_limit} more...")
+                 with container:
+                      # If it's the trigger for expander, display current item first
+                      if show_expander_trigger and i == display_limit:
+                          col1_exp, col2_exp = st.columns([4, 1]);
+                          with col1_exp: st.write(f"<small>{display_name} ({timestamp})</small>", unsafe_allow_html=True)
+                          with col2_exp: st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True)
+                      # Display items before the limit, or items after limit within expander
+                      elif i < display_limit:
+                           col1, col2 = st.columns([4, 1]);
+                           with col1: st.write(f"<small>{display_name} ({timestamp})</small>", unsafe_allow_html=True)
+                           with col2: st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True)
+                      # Now display remaining items inside the expander if triggered
+                      if show_expander_trigger and i == display_limit:
+                           for world_info_more in saved_worlds[display_limit+1:]:
+                               f_bn_more=os.path.basename(world_info_more['filename']); f_fp_more=os.path.join(SAVED_WORLDS_DIR, f_bn_more); dn_more=world_info_more.get('name',f_bn_more); ts_more=world_info_more.get('timestamp','N/A')
+                               colA, colB = st.columns([4, 1]);
+                               with colA: st.write(f"<small>{dn_more} ({ts_more})</small>", unsafe_allow_html=True)
+                               with colB: st.markdown(get_download_link(f_fp_more, "md"), unsafe_allow_html=True)
+                 if show_expander_trigger: break # Stop outer loop after processing expander
 
 
         st.markdown("---")
@@ -738,28 +485,29 @@ def render_sidebar():
             if cols[col_idx % 5].button(emoji, key=button_key, help=name, type=button_type, use_container_width=True):
                 if st.session_state.get('selected_object', 'None') != name:
                     st.session_state.selected_object = name
-                    run_async(lambda name_arg=name: streamlit_js_eval(f"updateSelectedObjectType({json.dumps(name_arg)});", key=f"update_tool_js_{name_arg}"))
+                    # Fire and forget JS update
+                    sync(js_code=f"updateSelectedObjectType({json.dumps(name)});", key=f"update_tool_js_{name}")
                     st.rerun()
             col_idx += 1
         st.markdown("---")
         if st.button("🚫 Clear Tool", key="clear_tool", use_container_width=True):
              if st.session_state.get('selected_object', 'None') != 'None':
                   st.session_state.selected_object = 'None';
-                  run_async(lambda: streamlit_js_eval("updateSelectedObjectType('None');", key="update_tool_js_none"))
+                  sync(js_code="updateSelectedObjectType('None');", key="update_tool_js_none")
                   st.rerun()
 
         st.markdown("---")
         st.header("🗣️ Voice & User")
-        current_username = st.session_state.get('username', list(FUN_USERNAMES.keys())[0])
-        username_options = list(FUN_USERNAMES.keys()); current_index = 0
+        current_username = st.session_state.get('username', list(FUN_USERNAMES.keys())[0]) if FUN_USERNAMES else "DefaultUser"
+        username_options = list(FUN_USERNAMES.keys()) if FUN_USERNAMES else [current_username]
+        current_index = 0
         try: current_index = username_options.index(current_username)
         except ValueError: current_index = 0
         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:
-            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)
-            st.session_state.username = new_username; st.session_state.tts_voice = FUN_USERNAMES[new_username]; save_username(st.session_state.username)
+            st.session_state.username = new_username;
+            st.session_state.tts_voice = FUN_USERNAMES.get(new_username, DEFAULT_TTS_VOICE); # Use get with default
+            save_username(st.session_state.username)
             st.rerun()
         st.session_state['enable_audio'] = st.toggle("Enable TTS Audio", value=st.session_state.get('enable_audio', True))
 
@@ -768,68 +516,114 @@ def render_main_content():
     """Renders the main content area with tabs."""
     st.title(f"{Site_Name} - User: {st.session_state.username}")
 
+    # Check for JS event data pushed from the component
+    # Use a unique key for the event listener setup
+    js_event = streamlit_js_eval(
+        js_code="""
+            // Ensure the listener is attached only once
+            if (!window.streamlitComponentEventAttached) {
+                window.addEventListener('message', event => {
+                    // Basic check for component message structure
+                    if (event.data.type === 'streamlit:componentChanged' && event.data.data) {
+                         // Send the component's value back to Python under a specific key
+                         Streamlit.setComponentValue({ type: 'js_event', payload: event.data.data });
+                    }
+                });
+                window.streamlitComponentEventAttached = true; // Flag it
+            }
+            // Return null initially or on standard runs
+            null;
+        """,
+        key="component_event_listener" # Unique key for this setup code
+    )
+
+    # Process event data if received
+    if js_event and isinstance(js_event, dict) and js_event.get("type") == "js_event":
+        event_payload = js_event.get("payload")
+        print(f"Received JS Event Payload: {event_payload}") # Debug log
+        if isinstance(event_payload, dict):
+            action = event_payload.get("action")
+            data = event_payload.get("data")
+
+            if action == "object_placed" and data:
+                print(f"Processing object placed event for {data.get('obj_id')}")
+                # Add object to in-memory state (use lock)
+                with world_objects_lock:
+                    world_objects[data['obj_id']] = data
+                # Clear the event from state to prevent reprocessing
+                # This might require careful handling if rerun happens before processing fully
+                # Maybe process directly instead of setting session state? Let's try direct.
+                # st.session_state.js_event_data = None # Clear trigger? No, js_event is the trigger value itself.
+                st.toast(f"Placed {data.get('type', 'object')}!", icon="➕")
+                # No rerun needed here, object added to server memory. User sees local obj.
+                # Save happens manually via button.
+
+            elif action == "object_deleted" and data:
+                 obj_id = data.get("obj_id")
+                 if obj_id:
+                     print(f"Processing object deleted event for {obj_id}")
+                     with world_objects_lock:
+                          if obj_id in world_objects:
+                              del world_objects[obj_id]
+                              st.toast(f"Deleted object {obj_id[:6]}...", icon="➖")
+                          else:
+                              st.toast(f"Object {obj_id[:6]}... already deleted.", icon="❓")
+                     # st.session_state.js_event_data = None
+
+            # Add more event types as needed
+
+    # Define Tabs
     tab_world, tab_chat, tab_pdf, tab_files = st.tabs(["🏗️ World Builder", "🗣️ Chat", "📚 PDF Tools", "📂 Files & Settings"])
 
     # --- World Builder Tab ---
     with tab_world:
         st.header("Shared 3D World")
-        st.caption("Place objects using the sidebar tools. Changes are shared live!")
+        st.caption("Place objects using sidebar tools. Use Files tab to Save/Load.")
         current_file_basename = st.session_state.get('current_world_file', None)
         if current_file_basename:
-             # Construct full path only if needed for parsing, might fail if file deleted externally
              full_path_for_parse = os.path.join(SAVED_WORLDS_DIR, current_file_basename)
-             if os.path.exists(full_path_for_parse):
-                 parsed = parse_world_filename(full_path_for_parse)
-                 st.info(f"Current World: **{parsed['name']}** (`{current_file_basename}`)")
-             else: # File might have been deleted
-                 st.warning(f"Loaded world file '{current_file_basename}' seems to be missing.")
-                 st.session_state.current_world_file = None # Clear state
-        else: st.info("Live State Active (Unsaved changes only persist if saved)")
+             if os.path.exists(full_path_for_parse): parsed = parse_world_filename(full_path_for_parse); 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 As New Version 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()
-            ws_url = "ws://localhost:8765" # Default
-            try: # Get WS URL (Best effort)
-                 from streamlit.web.server.server import Server
-                 session_info = Server.get_current()._get_session_info(st.runtime.scriptrunner.get_script_run_ctx().session_id)
-                 # Different streamlit versions might have different attribute names
-                 host_attr = getattr(session_info.ws.stream.request, 'host', None) # Try 'host'
-                 if not host_attr and hasattr(session_info.client, 'request'): host_attr = getattr(session_info.client.request, 'host', None) # Try client.request
-                 if host_attr:
-                    server_host = host_attr.split(':')[0]
-                    ws_url = f"ws://{server_host}:8765"
-                 else: raise AttributeError("Host attribute not found")
-            except Exception as e: print(f"WS URL detection failed ({e}), using localhost.")
-
+            ws_url = "ws://localhost:8765" # Default (WebSockets not used for state sync now)
+            # Inject state needed by JS (like current tool)
             js_injection_script = f"""<script>
     window.USERNAME = {json.dumps(st.session_state.username)};
-    window.WEBSOCKET_URL = {json.dumps(ws_url)};
+    // window.WEBSOCKET_URL = {json.dumps(ws_url)}; // No longer needed for state sync
     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)};
-    console.log("Streamlit State Injected:", {{ username: window.USERNAME, websocketUrl: window.WEBSOCKET_URL, selectedObject: window.SELECTED_OBJECT_TYPE }});
+    // Send the current world objects for initial draw
+    window.INITIAL_WORLD_OBJECTS = {json.dumps(dict(world_objects))};
+    console.log("Streamlit State Injected:", {{ username: window.USERNAME, selectedObject: window.SELECTED_OBJECT_TYPE, initialObjects: {len(world_objects)} }});
 </script>"""
             html_content_with_state = html_template.replace('</head>', js_injection_script + '\n</head>', 1)
+            # Use a key for the component to potentially receive data via setComponentValue
+            # component_key = "three_world_component" # Define a key
+            # html_component_value = components.html(html_content_with_state, height=700, scrolling=False, key=component_key)
+
+            # Using streamlit_js_eval to receive events is more explicit
             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)
 
     # --- Chat Tab ---
     with tab_chat:
         st.header(f"{START_ROOM} Chat")
-        # Load history - use run_async result or session state if already loaded
         if 'chat_history' not in st.session_state or not st.session_state.chat_history:
-             chat_history_list = asyncio.run(load_chat_history()) # Blocking load if first time
+             chat_history_list = asyncio.run(load_chat_history())
         else: chat_history_list = st.session_state.chat_history
-
         chat_container = st.container(height=500)
         with chat_container:
-             if chat_history_list: st.markdown("----\n".join(reversed(chat_history_list[-50:]))) # Show last 50
+             if chat_history_list: st.markdown("----\n".join(reversed(chat_history_list[-50:])))
              else: st.caption("No chat messages yet.")
 
-        # Chat Input Area
         message_value = st.text_input("Your Message:", key="message_input", label_visibility="collapsed")
         send_button_clicked = st.button("Send Chat 💬", key="send_chat_button")
         should_autosend = st.session_state.get('autosend', False) and message_value
@@ -838,12 +632,12 @@ def render_main_content():
             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 = FUN_USERNAMES.get(st.session_state.username, "en-US-AriaNeural")
-                ws_message = json.dumps({"type": "chat_message", "payload": {"username": st.session_state.username, "message": message_to_send, "voice": voice}})
-                # Use helper to run async tasks without blocking main thread excessively
-                run_async(broadcast_message, ws_message)
+                voice = st.session_state.get('tts_voice', DEFAULT_TTS_VOICE)
+                # Directly save and update history, no WS needed for chat display?
+                # If chat needs to be real-time, WS is still required for that part.
+                # Let's assume chat is NOT real-time for now to simplify fully.
                 run_async(save_chat_entry, st.session_state.username, message_to_send, voice)
-                st.session_state.message_input = "" # Clear state for next run
+                st.session_state.message_input = ""
                 st.rerun()
             elif send_button_clicked: st.toast("Message empty or same as last.")
         st.checkbox("Autosend Chat", key="autosend")
@@ -854,7 +648,6 @@ def render_main_content():
          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")
          if pdf_file:
-             # Use a button to trigger potentially long processing
              if st.button("Process PDF to Audio", key="process_pdf_button"):
                  with st.spinner("Processing PDF... This may take time."):
                      process_pdf_tab(pdf_file, max_pages, st.session_state.tts_voice)
@@ -865,26 +658,21 @@ def render_main_content():
         st.subheader("💾 World State Management")
         current_file_basename = st.session_state.get('current_world_file', None)
 
-        # Save Current Version Button
         if current_file_basename:
-            # Need full path to parse filename correctly
             full_path_for_parse = os.path.join(SAVED_WORLDS_DIR, current_file_basename)
-            # Check existence before parsing display name
-            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", help=f"Overwrite '{current_file_basename}'"):
-                     with st.spinner(f"Overwriting {current_file_basename}..."):
-                         if save_world_state_to_md(current_file_basename): st.success("Current world saved!")
-                         else: st.error("Failed to save world state.")
-            else:
-                 st.warning(f"Currently selected world file '{current_file_basename}' not found. Cannot save changes to it.")
-        else:
-            st.info("Load a world from the sidebar to enable saving changes to it.")
+            if os.path.exists(full_path_for_parse): parsed = parse_world_filename(full_path_for_parse); save_label = f"Save Changes to '{parsed['name']}'"
+            else: parsed = None; save_label = f"Save Changes (File '{current_file_basename}' missing)"
+
+            if st.button(save_label, key="save_current_world", help=f"Overwrite '{current_file_basename}'"):
+                 if not os.path.exists(full_path_for_parse):
+                      st.error(f"Cannot save, file '{current_file_basename}' no longer exists.")
+                 else:
+                      with st.spinner(f"Overwriting {current_file_basename}..."):
+                          if save_world_state_to_md(current_file_basename): st.success("Current world saved!")
+                          else: st.error("Failed to save world state.")
+        else: st.info("Load a world from the sidebar or use 'Save As New Version' below.")
 
-        # Save As New Version Section
         st.subheader("Save As New Version")
-        # Ensure key for text input is unique if it exists elsewhere
         new_name_files = st.text_input("New World Name:", key="new_world_name_files_tab", value=st.session_state.get('new_world_name', 'MyWorld'))
         if st.button("💾 Save Live State as New Version", key="save_new_version_files"):
              if new_name_files.strip():
@@ -892,19 +680,12 @@ def render_main_content():
                   with st.spinner(f"Saving new version '{new_name_files}'..."):
                       if save_world_state_to_md(new_filename_base):
                           st.success(f"Saved as {new_filename_base}")
-                          st.session_state.current_world_file = new_filename_base
-                          st.session_state.new_world_name = "MyWorld"; st.rerun() # Rerun to update sidebar
+                          st.session_state.current_world_file = new_filename_base; st.session_state.new_world_name = "MyWorld"; st.rerun()
                       else: st.error("Failed to save new version.")
              else: st.warning("Please enter a name.")
 
-        st.subheader("⚙️ Server Status")
-        col_ws, col_clients = st.columns(2)
-        with col_ws:
-             server_alive = st.session_state.get('server_task') and st.session_state.server_task.is_alive(); ws_status = "Running" if server_alive else "Stopped"; st.metric("WebSocket Server", ws_status)
-             if not server_alive and st.button("Restart Server Thread", key="restart_ws"): start_websocket_server_thread(); st.rerun()
-        with col_clients: st.metric("Connected Clients", len(connected_clients))
+        # --- Removed Server Status Section ---
 
-        # File Deletion
         st.subheader("🗑️ Delete Files")
         st.warning("Deletion is permanent!", icon="⚠️")
         col_del1, col_del2, col_del3, col_del4 = st.columns(4)
@@ -913,29 +694,27 @@ def render_main_content():
         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()
         with col_del3:
-            # Use prefix in delete pattern
             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()
         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()
 
-        # Download Archives
         st.subheader("📦 Download Archives")
+        # Zip Buttons
+        col_zip1, col_zip2, col_zip3 = st.columns(3)
+        with col_zip1:
+            if st.button("Zip Worlds"): create_zip_of_files(glob.glob(os.path.join(SAVED_WORLDS_DIR, "*.md")), "Worlds")
+        with col_zip2:
+            if st.button("Zip Chats"): create_zip_of_files(glob.glob(os.path.join(CHAT_DIR, "*.md")), "Chats")
+        with col_zip3:
+            if st.button("Zip Audio"): create_zip_of_files(glob.glob(os.path.join(AUDIO_DIR, "*.mp3")) + glob.glob(os.path.join(AUDIO_CACHE_DIR, "*.mp3")), "Audio")
+        # List existing zips
         zip_files = sorted(glob.glob(os.path.join(MEDIA_DIR,"*.zip")), key=os.path.getmtime, reverse=True)
         if zip_files:
-             col_zip1, col_zip2, col_zip3 = st.columns(3)
-             # Gather files for zipping inside the button click
-             with col_zip1:
-                  if st.button("Zip Worlds"): create_zip_of_files(glob.glob(os.path.join(SAVED_WORLDS_DIR, "*.md")), "Worlds")
-             with col_zip2:
-                   if st.button("Zip Chats"): create_zip_of_files(glob.glob(os.path.join(CHAT_DIR, "*.md")), "Chats")
-             with col_zip3:
-                   if st.button("Zip Audio"): create_zip_of_files(glob.glob(os.path.join(AUDIO_DIR, "*.mp3")) + glob.glob(os.path.join(AUDIO_CACHE_DIR, "*.mp3")), "Audio")
-
-             st.caption("Existing Zip Files:")
-             for zip_file in zip_files: st.markdown(get_download_link(zip_file, "zip"), unsafe_allow_html=True)
+            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 for the else block
-             st.caption("No zip archives found.")
+            st.caption("No zip archives found.")
+
 
 # ==============================================================================
 # Main Execution Logic
@@ -952,25 +731,24 @@ def initialize_world():
              print(f"Loading most recent world on startup: {latest_world_file_basename}")
              if load_world_state_from_md(latest_world_file_basename): loaded_successfully = True
              else: print("Failed to load most recent world, starting empty.")
-        else: print("No saved worlds found, starting with empty state.")
+         else: print("No saved worlds found, starting with empty state.")
         if not loaded_successfully:
-             with world_objects_lock: world_objects.clear(); # Ensure empty state
+             with world_objects_lock: world_objects.clear();
              st.session_state.current_world_file = None
         st.session_state.initial_world_state_loaded = True
         print("Initial world load process complete.")
 
 if __name__ == "__main__":
-    # 1. Initialize session state (must be first)
+    # 1. Initialize session state
     init_session_state()
 
-    # 2. Start WebSocket server thread if needed
-    server_thread = st.session_state.get('server_task'); server_alive = server_thread is not None and server_thread.is_alive()
-    if not st.session_state.get('server_running_flag', False) and not server_alive: start_websocket_server_thread()
-    elif server_alive and not st.session_state.get('server_running_flag', False): st.session_state.server_running_flag = True # Correct flag
+    # --- Removed WebSocket Server Start ---
 
     # 3. Load initial world state (once per session)
     initialize_world()
 
     # 4. Render the UI
     render_sidebar()
-    render_main_content()
+    render_main_content()
+
+    # --- Removed Periodic Save ---