Update app.py

app.py

@@ -1,952 +1,306 @@
-# app.py (Refactored & Consolidated)
+# app.py
 import streamlit as st
-import asyncio
-import websockets
-import uuid
-from datetime import datetime
-import os
-import random
-import time
-import hashlib
-import glob
-import base64
-import io
 import streamlit.components.v1 as components
-import edge_tts
-import nest_asyncio
-import re
-import pytz
-import shutil
-from PyPDF2 import PdfReader
-import threading
+import os
 import json
-import zipfile
-from dotenv import load_dotenv
-from streamlit_marquee import streamlit_marquee
-from collections import defaultdict, Counter
-import pandas as pd # Still used for fallback CSV load? Keep for now.
-from streamlit_js_eval import streamlit_js_eval
-from PIL import Image
-
-# ==============================================================================
-# Configuration & Constants
-# ==============================================================================
-
-# 🛠️ Patch asyncio for nesting
-nest_asyncio.apply()
-
-# 🎨 Page Config
-st.set_page_config(
-    page_title="🤖🏗️ Shared 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
-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"
-
-# Audio Constants
-AUDIO_CACHE_DIR = "audio_cache"
-AUDIO_DIR = "audio_logs"
-
-# World Builder Constants
-SAVED_WORLDS_DIR = "saved_worlds" # Directory for MD world files
-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
-
-# File Emojis
-FILE_EMOJIS = {"md": "📝", "mp3": "🎵", "png": "🖼️", "mp4": "🎥", "zip": "📦", "json": "📄"}
-
-# API Keys (Load from .env or secrets)
-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', ""))
-
-# 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"
-}
-
-# ==============================================================================
-# Global State & Locks
-# ==============================================================================
-
-# Thread lock for accessing shared world state
-world_objects_lock = threading.Lock()
-# In-memory world state {obj_id: data} - Use defaultdict for convenience
-world_objects = defaultdict(dict)
-# Set of active WebSocket client IDs
-connected_clients = set()
-
-# ==============================================================================
-# Utility Functions
-# ==============================================================================
-
-def get_current_time_str(tz='UTC'):
-    """Gets formatted timestamp string in specified timezone (default UTC)."""
+import pandas as pd
+import uuid
+import math # For floor function
+# from PIL import Image, ImageDraw # No longer needed for minimap
+from streamlit_js_eval import streamlit_js_eval # For JS communication
+
+# --- Constants ---
+SAVE_DIR = "saved_worlds"
+PLOT_WIDTH = 50.0 # Width of each plot in 3D space
+PLOT_DEPTH = 50.0 # Depth of each plot (can be same as width)
+CSV_COLUMNS = ['obj_id', 'type', 'pos_x', 'pos_y', 'pos_z', 'rot_x', 'rot_y', 'rot_z', 'rot_order']
+
+# --- Ensure Save Directory Exists ---
+os.makedirs(SAVE_DIR, exist_ok=True)
+
+# --- Helper Functions ---
+
+@st.cache_data(ttl=3600) # Cache plot list
+def load_plot_metadata():
+    """Scans save dir for plot_X*_Z*.csv, sorts, calculates metadata."""
+    plots = []
+    plot_files = []
     try:
-        timezone = pytz.timezone(tz)
-        # Get current datetime localized to the specified timezone
-        now_aware = datetime.now(timezone)
-    except pytz.UnknownTimeZoneError:
-        # Fallback to UTC if timezone is unknown
-        now_aware = datetime.now(pytz.utc)
+        plot_files = [f for f in os.listdir(SAVE_DIR) if f.endswith(".csv") and f.startswith("plot_X")]
+    except FileNotFoundError:
+        st.error(f"Save directory '{SAVE_DIR}' not found.")
+        return []
     except Exception as e:
-         # General fallback if timezone localization fails
-         print(f"Timezone error ({tz}), using UTC. Error: {e}")
-         now_aware = datetime.now(pytz.utc)
+        st.error(f"Error listing save directory '{SAVE_DIR}': {e}")
+        return []
 
-    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
-    return text[:max_len]
-
-def run_async(async_func, *args, **kwargs):
-    """Runs an async function safely from a sync context."""
-    try:
-        loop = asyncio.get_running_loop()
-        # Schedule as task if loop is running
-        return loop.create_task(async_func(*args, **kwargs))
-    except RuntimeError: # No running loop
-        # Run in a new loop (blocks until completion)
+    # Parse filenames to get grid coordinates
+    parsed_plots = []
+    for filename in plot_files:
         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 # Indicate error or failure
-    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)
-
-# ==============================================================================
-# World State File Handling (Markdown + JSON)
-# ==============================================================================
-
-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
-    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)
-    # Ensure prefix and suffix are correct
-    if basename.startswith(WORLD_STATE_FILE_MD_PREFIX) and basename.endswith(".md"):
-        parts = basename[len(WORLD_STATE_FILE_MD_PREFIX):-3].split('_') # Remove prefix and suffix before split
-        if len(parts) >= 3: # Expecting Name_Timestamp_Hash
-            timestamp_str = parts[-2]
-            name = " ".join(parts[:-2]) # Join potentially multiple parts for name
-            dt_obj = None
-            try: # Try parsing timestamp
-                dt_obj = datetime.strptime(timestamp_str, '%Y%m%d_%H%M%S')
-                dt_obj = pytz.utc.localize(dt_obj) # Assume UTC since generated with UTC
-            except (ValueError, pytz.exceptions.AmbiguousTimeError, pytz.exceptions.NonExistentTimeError):
-                dt_obj = None # Parsing failed or timezone issue
-            return {"name": name or "Untitled", "timestamp": timestamp_str, "dt": dt_obj, "filename": filename}
-
-    # Fallback for unknown format or parsing failure
-    dt_fallback = None
+            parts = filename[:-4].split('_') # Remove .csv
+            grid_x = int(parts[1][1:]) # Extract number after X
+            grid_z = int(parts[2][1:]) # Extract number after Z
+            # Extract name if present (parts after Z coordinate)
+            plot_name = " ".join(parts[3:]) if len(parts) > 3 else f"Plot ({grid_x},{grid_z})"
+
+            parsed_plots.append({
+                'id': filename[:-4], # Use filename base as unique ID
+                'filename': filename,
+                'grid_x': grid_x,
+                'grid_z': grid_z,
+                'name': plot_name,
+                'x_offset': grid_x * PLOT_WIDTH,
+                'z_offset': grid_z * PLOT_DEPTH # Use PLOT_DEPTH for Z offset
+            })
+        except (IndexError, ValueError):
+            st.warning(f"Could not parse grid coordinates from filename: {filename}. Skipping.")
+            continue
+
+    # Sort primarily by X, then by Z
+    parsed_plots.sort(key=lambda p: (p['grid_x'], p['grid_z']))
+
+    return parsed_plots
+
+def load_plot_objects(filename, x_offset, z_offset):
+    """Loads objects from a CSV, applying the plot's world offsets."""
+    file_path = os.path.join(SAVE_DIR, filename)
+    objects = []
     try:
-         mtime = os.path.getmtime(filename)
-         dt_fallback = datetime.fromtimestamp(mtime, tz=pytz.utc)
-    except Exception: pass # Ignore errors getting mtime
-    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)."""
-    global world_objects
-    save_path = os.path.join(SAVED_WORLDS_DIR, target_filename_base)
-    print(f"Acquiring lock to save {len(world_objects)} objects to: {save_path}...")
-    success = False
-    with world_objects_lock:
-        world_data_dict = dict(world_objects) # Create copy inside lock
-        print(f"Saving {len(world_data_dict)} objects...")
-        parsed_info = parse_world_filename(target_filename_base) # Use original filename for info
-        timestamp_save = get_current_time_str()
-        md_content = f"""# World State: {parsed_info['name']}
-* **File Saved:** {timestamp_save} (UTC)
-* **Original Timestamp:** {parsed_info['timestamp']}
-* **Objects:** {len(world_data_dict)}
-
-```json
-{json.dumps(world_data_dict, indent=2)}
-```"""
-        try:
-            ensure_dir(SAVED_WORLDS_DIR) # Ensure dir exists
-            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}")
-            # Avoid st.error in potentially non-main thread
-    return success
-
-def load_world_state_from_md(filename_base):
-    """Loads world state from an MD file (basename), updates global state, 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}")
+        df = pd.read_csv(file_path)
+        # Check required columns
+        if not all(col in df.columns for col in ['type', 'pos_x', 'pos_y', 'pos_z']):
+             st.warning(f"CSV '{filename}' missing essential columns. Skipping.")
+             return []
+        # Add defaults for optional columns
+        df['obj_id'] = df.get('obj_id', pd.Series([str(uuid.uuid4()) for _ in range(len(df))]))
+        for col, default in [('rot_x', 0.0), ('rot_y', 0.0), ('rot_z', 0.0), ('rot_order', 'XYZ')]:
+             if col not in df.columns: df[col] = default
+
+        for _, row in df.iterrows():
+            obj_data = row.to_dict()
+            # Apply world offset
+            obj_data['pos_x'] += x_offset
+            obj_data['pos_z'] += z_offset # Apply Z offset too
+            objects.append(obj_data)
+        return objects
+    except FileNotFoundError:
+        st.error(f"File not found during object load: {filename}")
+        return []
+    except pd.errors.EmptyDataError:
+         return [] # Empty file is valid
+    except Exception as e:
+        st.error(f"Error loading objects from {filename}: {e}")
+        return []
+
+def save_plot_data(filename, objects_data_list, plot_x_offset, plot_z_offset):
+    """Saves object data list to a CSV, making positions relative to plot origin."""
+    file_path = os.path.join(SAVE_DIR, filename)
+    relative_objects = []
+    if not isinstance(objects_data_list, list):
+        st.error("Invalid data format received for saving (expected a list).")
         return False
 
+    for obj in objects_data_list:
+        pos = obj.get('position', {})
+        rot = obj.get('rotation', {})
+        obj_type = obj.get('type', 'Unknown')
+        obj_id = obj.get('obj_id', str(uuid.uuid4()))
+
+        if not all(k in pos for k in ['x', 'y', 'z']) or obj_type == 'Unknown':
+            print(f"Skipping malformed object during save prep: {obj}")
+            continue
+
+        relative_obj = {
+            'obj_id': obj_id, 'type': obj_type,
+            'pos_x': pos.get('x', 0.0) - plot_x_offset, # Make relative X
+            'pos_y': pos.get('y', 0.0),
+            'pos_z': pos.get('z', 0.0) - plot_z_offset, # Make relative Z
+            'rot_x': rot.get('_x', 0.0), 'rot_y': rot.get('_y', 0.0), 'rot_z': rot.get('_z', 0.0),
+            'rot_order': rot.get('_order', 'XYZ')
+        }
+        relative_objects.append(relative_obj)
+
     try:
-        with open(load_path, 'r', encoding='utf-8') as f: content = f.read()
-        json_match = re.search(r"```json\s*(\{.*?\})\s*```", content, re.DOTALL | 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() # Clear previous state
-             for k, v in world_data_dict.items(): world_objects[str(k)] = v # Update with loaded data
-             loaded_count = len(world_objects)
-        print(f"Loaded {loaded_count} objects from {filename_base}. Lock released.")
-        st.session_state.current_world_file = filename_base # Track loaded file (basename)
+        df = pd.DataFrame(relative_objects, columns=CSV_COLUMNS)
+        df.to_csv(file_path, index=False)
+        st.success(f"Saved {len(relative_objects)} objects to {filename}")
         return True
+    except Exception as e:
+        st.error(f"Failed to save plot data to {filename}: {e}")
+        return False
 
-    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 MD files and parses them."""
+# --- Page Config ---
+st.set_page_config( page_title="Infinite World Builder", layout="wide")
+
+# --- Initialize Session State ---
+if 'selected_object' not in st.session_state: st.session_state.selected_object = 'None'
+if 'new_plot_name' not in st.session_state: st.session_state.new_plot_name = "" # No longer used for filename
+if 'js_save_data_result' not in st.session_state: st.session_state.js_save_data_result = None
+
+# --- Load Plot Metadata ---
+# This is now the source of truth for saved plots
+plots_metadata = load_plot_metadata()
+
+# --- Load ALL Objects for Rendering ---
+all_initial_objects = []
+for plot in plots_metadata:
+    all_initial_objects.extend(load_plot_objects(plot['filename'], plot['x_offset'], plot['z_offset']))
+
+# --- Sidebar ---
+with st.sidebar:
+    st.title("🏗️ World Controls")
+
+    st.header("Navigation (Plots)")
+    st.caption("Click to teleport player to a plot.")
+    max_cols = 2 # Adjust columns for potentially more buttons
+    cols = st.columns(max_cols)
+    col_idx = 0
+    # Sort buttons by grid coords for logical layout
+    sorted_plots_for_nav = sorted(plots_metadata, key=lambda p: (p['grid_x'], p['grid_z']))
+    for plot in sorted_plots_for_nav:
+        button_label = f"➡️ {plot.get('name', plot['id'])} ({plot['grid_x']},{plot['grid_z']})"
+        if cols[col_idx].button(button_label, key=f"nav_{plot['id']}"):
+            target_x = plot['x_offset']
+            target_z = plot['z_offset'] # Use Z offset too
+            try:
+                # Tell JS where to teleport (center of plot approx)
+                js_code = f"teleportPlayer({target_x + PLOT_WIDTH/2}, {target_z + PLOT_DEPTH/2});"
+                streamlit_js_eval(js_code=js_code, key=f"teleport_{plot['id']}")
+            except Exception as e:
+                 st.error(f"Failed to send teleport command: {e}")
+        col_idx = (col_idx + 1) % max_cols
+
+    st.markdown("---")
+
+    # --- Object Placement ---
+    st.header("Place Objects")
+    object_types = ["None", "Simple House", "Tree", "Rock", "Fence Post"]
+    current_object_index = object_types.index(st.session_state.selected_object) if st.session_state.selected_object in object_types else 0
+    selected_object_type_widget = st.selectbox(
+        "Select Object:", options=object_types, index=current_object_index, key="selected_object_widget"
+    )
+    if selected_object_type_widget != st.session_state.selected_object:
+         st.session_state.selected_object = selected_object_type_widget
+         # Rerun will happen, JS reloads state via sessionStorage, Python injects new selection
+
+    st.markdown("---")
+
+    # --- Saving ---
+    st.header("Save Work")
+    st.caption("Saves newly placed objects to the plot the player is currently in. If it's a new area, a new plot file is created.")
+    if st.button("💾 Save Current Work", key="save_button"):
+        # Trigger JS to get data AND player position
+        js_get_data_code = "getSaveDataAndPosition();" # JS function needs update
+        streamlit_js_eval(js_code=js_get_data_code, key="js_save_processor")
+        st.rerun() # Rerun to process result
+
+
+# --- Process Save Data ---
+save_data_from_js = st.session_state.get("js_save_processor", None)
+
+if save_data_from_js is not None:
+    st.info("Received save data from client...")
+    save_processed_successfully = False
     try:
-        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 if available (newest first)
-        parsed_worlds.sort(key=lambda x: x['dt'] if x['dt'] else datetime.min.replace(tzinfo=pytz.utc), reverse=True)
-        return parsed_worlds
+        # Expecting { playerPosition: {x,y,z}, objectsToSave: [...] }
+        payload = json.loads(save_data_from_js) if isinstance(save_data_from_js, str) else save_data_from_js
+
+        if isinstance(payload, dict) and 'playerPosition' in payload and 'objectsToSave' in payload:
+            player_pos = payload['playerPosition']
+            objects_to_save = payload['objectsToSave']
+
+            if isinstance(objects_to_save, list): # Allow saving empty list (clears new objects)
+                # Determine target plot based on player position
+                target_grid_x = math.floor(player_pos.get('x', 0.0) / PLOT_WIDTH)
+                target_grid_z = math.floor(player_pos.get('z', 0.0) / PLOT_DEPTH) # Use Z pos too
+
+                target_filename = f"plot_X{target_grid_x}_Z{target_grid_z}.csv"
+                target_plot_x_offset = target_grid_x * PLOT_WIDTH
+                target_plot_z_offset = target_grid_z * PLOT_DEPTH
+
+                st.write(f"Attempting to save plot: {target_filename} (Player at: x={player_pos.get('x', 0):.1f}, z={player_pos.get('z', 0):.1f})")
+
+                # Check if this plot already exists in metadata (for logging/future logic)
+                is_new_plot_file = not os.path.exists(os.path.join(SAVE_DIR, target_filename))
+
+                save_ok = save_plot_data(target_filename, objects_to_save, target_plot_x_offset, target_plot_z_offset)
+
+                if save_ok:
+                    load_plot_metadata.clear() # Clear cache to force reload metadata
+                    try: # Tell JS to clear its unsaved state
+                         streamlit_js_eval(js_code="resetNewlyPlacedObjects();", key="reset_js_state")
+                    except Exception as js_e:
+                         st.warning(f"Could not reset JS state after save: {js_e}")
+
+                    if is_new_plot_file:
+                        st.success(f"New plot created and saved: {target_filename}")
+                    else:
+                        st.success(f"Updated existing plot: {target_filename}")
+                    save_processed_successfully = True
+                else:
+                    st.error(f"Failed to save plot data to file: {target_filename}")
+            else:
+                st.error("Invalid 'objectsToSave' format received (expected list).")
+        else:
+            st.error("Invalid save payload structure received from client.")
+            print("Received payload:", payload) # Log for debugging
+
+    except json.JSONDecodeError:
+        st.error("Failed to decode save data from client.")
+        print("Received raw data:", save_data_from_js)
     except Exception as e:
-         print(f"Error scanning saved worlds: {e}")
-         st.error(f"Could not scan saved worlds: {e}")
-         return []
+        st.error(f"Error processing save: {e}")
+        st.exception(e)
 
-# ==============================================================================
-# User State & Session Init
-# ==============================================================================
+    # Clear the trigger data from session state
+    st.session_state.js_save_processor = None
+    # Rerun after processing to reflect changes
+    if save_processed_successfully:
+        st.rerun()
 
-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}")
 
-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}")
-    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), '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"},
-        '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,
-        'current_world_file': None, # Track loaded world filename (basename)
-        'operation_timings': {}, 'performance_metrics': defaultdict(list),
-        'paste_image_base64': "", 'new_world_name': "MyWorld"
-    }
-    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
-# ==============================================================================
-
-# --- Text & File Helpers ---
-def clean_text_for_tts(text):
-    if not isinstance(text, str): return "No text"
-    text = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', text) # Remove markdown links, keep text
-    text = re.sub(r'[#*_`!]', '', text) # Remove some markdown chars
-    text = ' '.join(text.split()) # Normalize whitespace
-    return text[:250] or "No text"
-
-def create_file(content, username, file_type="md", save_path=None):
-    if not save_path:
-         # Generate filename if specific path not given
-         filename = generate_filename(content, username, file_type)
-         save_path = os.path.join(MEDIA_DIR, filename) # Save to base dir by default
-    ensure_dir(os.path.dirname(save_path)) # Ensure directory exists
-    try:
-        with open(save_path, 'w', encoding='utf-8') as f: f.write(content)
-        print(f"Created file: {save_path}"); 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}">{FILE_EMOJIS.get(file_type, "📄")} DL</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."""
-    if not text: return None
-    # Cache key based on text hash and voice
-    cache_key = hashlib.md5(f"{text[:150]}_{voice}".encode()).hexdigest()
-    if 'audio_cache' not in st.session_state: st.session_state.audio_cache = {}
-    cached_path = st.session_state.audio_cache.get(cache_key)
-    if cached_path and os.path.exists(cached_path): return cached_path
-
-    text_cleaned = clean_text_for_tts(text);
-    if not text_cleaned or text_cleaned == "No text": return None
-    filename_base = generate_filename(text_cleaned, username, "mp3"); save_path = os.path.join(AUDIO_DIR, filename_base);
-    ensure_dir(AUDIO_DIR)
-    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
-
-def play_and_download_audio(file_path):
-    """Displays audio player and download link in Streamlit."""
-    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: {e}")
-    else: st.warning(f"Audio file not found: {os.path.basename(file_path) if file_path else 'N/A'}")
-
-# --- Chat ---
-async def save_chat_entry(username, message, voice, is_markdown=False):
-    """Saves chat entry to a file and session state, generates audio."""
-    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```"
-    md_filename_base = generate_filename(message, username, "md"); md_file_path = os.path.join(CHAT_DIR, md_filename_base); md_file = create_file(entry, username, "md", save_path=md_file_path)
-    if 'chat_history' not in st.session_state: st.session_state.chat_history = [];
-    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
-         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."""
-    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...")
-        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}")
-        st.session_state.chat_history = temp_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"):
-    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:
-        print(f"Creating zip: {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
-
-def delete_files(file_patterns, exclude_files=None):
-    protected = [STATE_FILE, "app.py", "index.html", "requirements.txt", "README.md"]
-    # Dynamically protect all currently saved world files unless explicitly targeted
-    try:
-        current_worlds = [os.path.basename(w['filename']) for w in get_saved_worlds()]
-        protected.extend(current_worlds)
-    except Exception: pass # Ignore if world listing fails
-    if exclude_files: protected.extend(exclude_files)
-
-    deleted_count = 0; errors = 0
-    for pattern in file_patterns:
-         pattern_path = os.path.join(MEDIA_DIR, pattern) # Assume relative to app dir
-         try:
-              files_to_delete = glob.glob(pattern_path)
-              if not files_to_delete: continue
-              for f_path in files_to_delete:
-                   basename = os.path.basename(f_path)
-                   # Check if it's a file and NOT protected
-                   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"Err matching {pattern}: {glob_e}"); errors += 1
-    msg = 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.")
-    # Clear relevant caches
-    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
-
-def paste_image_component():
-      pasted_img = None; img_type = None
-      with st.form(key="paste_form"):
-           paste_input = st.text_area("Paste Image Data Here (Ctrl+V)", key="paste_input_area", height=50); submit_button = st.form_submit_button("Paste Image 📋")
-           if submit_button and paste_input and paste_input.startswith('data:image'):
-               try:
-                   mime_type = paste_input.split(';')[0].split(':')[1]; base64_str = paste_input.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
-               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 = ""
-           elif submit_button: st.warning("No valid img data."); st.session_state.paste_image_base64 = ""
-      # Return the image object if successfully pasted and submitted
-      return pasted_img if submit_button and pasted_img else None
-
-
-# --- PDF Processing ---
-# Note: Depends on PyPDF2 and potentially AudioProcessor class if generating audio
-class AudioProcessor:
-      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'):
-            cache_key=hashlib.md5(f"{text[:150]}:{voice}".encode()).hexdigest(); cache_path=f"{self.cache_dir}/{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);
-            if not text_cleaned: return None
-            ensure_dir(os.path.dirname(cache_path))
-            try:
-                 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
-
-def process_pdf_tab(pdf_file, max_pages, voice):
-      st.subheader("PDF Processing")
-      if pdf_file is None:
-           st.info("Upload a PDF file to begin.")
-           return
-      audio_processor = AudioProcessor() # Instance for this run
-      try:
-          reader=PdfReader(pdf_file); 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()
-
-          def process_page_sync(page_num, page_text):
-              # Runs async audio generation in a separate thread
-              async def run_async_audio(): return await audio_processor.create_audio(page_text, voice)
-              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):
-               text=reader.pages[i].extract_text();
-               if text: 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]"
-
-          # Display results as they become available (or after join)
-          st.progress(0) # Placeholder for progress
-          # Wait for threads and display - consider using st.empty() for updates
-          for thread in page_threads: thread.join()
-
-          for i in range(total_pages):
-                with st.expander(f"Page {i+1}"):
-                     st.markdown(texts.get(i, "[Error getting text]"))
-                     audio_file = audios.get(i)
-                     if audio_file: play_and_download_audio(audio_file)
-                     else: st.caption("Audio generation failed or pending.")
-
-      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}) # Force full refresh
-    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]}") # Get username for this session
-    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", {});
-                # Use username from payload if provided, otherwise session username
-                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"));
-                    # Schedule save/TTS, but broadcast immediately
-                    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") # Optionally include 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)
-
-                # Add more handlers here
-
-            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() # Keep 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():
-        loop = asyncio.new_event_loop(); asyncio.set_event_loop(loop)
-        try: loop.run_until_complete(run_websocket_server())
-        finally: 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!")
-
-
-# ==============================================================================
-# Streamlit UI Layout
-# ==============================================================================
-
-def render_sidebar():
-    """Renders the Streamlit sidebar contents."""
-    with st.sidebar:
-        st.header("💾 World Versions")
-        st.caption("Load or save named world states.")
-
-        # World Selector
-        saved_worlds = get_saved_worlds()
-        # Create display text mapping filename to formatted string
-        world_options = {w['filename']: f"{w['name']} ({w['timestamp']})" for w in saved_worlds}
-        # Get the currently selected filename (basename) from session state
-        current_selection_basename = st.session_state.get('current_world_file', None)
-
-        # Prepare options for radio button: None first, then filenames
-        radio_options_list = [None] + [w['filename'] for w in saved_worlds] # Store full path initially? No, use basename.
-        radio_options_basenames = [None] + [os.path.basename(w['filename']) for w in saved_worlds]
-
-        # Find the index of the current selection in the options list
-        current_radio_index = 0 # Default to "Live State"
-        if current_selection_basename and current_selection_basename in radio_options_basenames:
-             try:
-                  current_radio_index = radio_options_basenames.index(current_selection_basename)
-             except ValueError:
-                  current_radio_index = 0 # Fallback if filename somehow not in list
-
-        # Display radio buttons
-        selected_basename = st.radio(
-             "Load World:",
-             options=radio_options_basenames,
-             index=current_radio_index,
-             format_func=lambda x: "Live State (Unsaved)" if x is None else world_options.get(os.path.join(SAVED_WORLDS_DIR, x), x), # Format using full path to get name/time? complex
-             key="world_selector_radio"
-         )
-
-        # Handle selection change
-        if selected_basename != current_selection_basename:
-             st.session_state.current_world_file = selected_basename # Store basename
-             if selected_basename:
-                  with st.spinner(f"Loading {selected_basename}..."):
-                      if load_world_state_from_md(selected_basename):
-                          run_async(broadcast_world_update) # Broadcast new state
-                          st.toast("World loaded!", icon="✅")
-                      else:
-                          st.error("Failed to load world."); st.session_state.current_world_file = None # Reset on failure
-             else:
-                  print("Switched to live state.")
-                  # Optionally clear world or just stop tracking file? Stop tracking.
-                  # Maybe broadcast current live state if switching TO live?
-                  # run_async(broadcast_world_update) # Broadcast current live state
-                  st.toast("Switched to Live State.")
-             st.rerun()
-
-        # Display download links
-        st.caption("Download:")
-        cols = st.columns([3, 1]) # Columns for name and download button
-        with cols[0]: st.write("**Name**")
-        with cols[1]: st.write("**Link**")
-        for world_info in saved_worlds:
-            f_basename = os.path.basename(world_info['filename'])
-            f_fullpath = world_info['filename'] # Full path needed for reading file
-            display_name = world_info.get('name', f_basename)
-            timestamp = world_info.get('timestamp', 'N/A')
-            col1, col2 = st.columns([3, 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)
-
-
-        st.markdown("---")
-
-        # Save New Version moved to Files Tab
-
-        # Build Tools section
-        st.header("🏗️ Build Tools")
-        st.caption("Select an object to place.")
-        cols = st.columns(5)
-        col_idx = 0
-        current_tool = st.session_state.get('selected_object', 'None')
-        for emoji, name in PRIMITIVE_MAP.items():
-            button_key = f"primitive_{name}"; button_type = "primary" if current_tool == name else "secondary"
-            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: streamlit_js_eval(f"updateSelectedObjectType({json.dumps(name)});", key=f"update_tool_js_{name}")) # Fire-and-forget JS update
-                    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"))
-                  st.rerun()
-
-        # Voice/User section
-        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
-        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.rerun()
-        st.session_state['enable_audio'] = st.toggle("Enable TTS Audio", value=st.session_state.get('enable_audio', True))
-
-
-def render_main_content():
-    """Renders the main content area with tabs."""
-    st.title(f"{Site_Name} - User: {st.session_state.username}")
-
-    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!")
-        current_file = st.session_state.get('current_world_file', None)
-        if current_file: parsed = parse_world_filename(current_file); st.info(f"Current World: **{parsed['name']}** (`{os.path.basename(current_file)}`)")
-        else: st.info("Live State Active (Unsaved changes will be lost unless saved as new version)")
-
-        # Embed HTML Component
-        html_file_path = 'index.html'
-        try:
-            with open(html_file_path, 'r', encoding='utf-8') as f: html_template = f.read()
-            try: # Get WS URL
-                 from streamlit.web.server.server import Server
-                 session_info = Server.get_current()._get_session_info(st.runtime.scriptrunner.get_script_run_ctx().session_id)
-                 server_host = session_info.ws.stream.request.host.split(':')[0]
-                 ws_url = f"ws://{server_host}:8765"
-            except Exception: ws_url = "ws://localhost:8765"
-
-            js_injection_script = f"""<script>
-    window.USERNAME = {json.dumps(st.session_state.username)};
-    window.WEBSOCKET_URL = {json.dumps(ws_url)};
+# --- Main Area ---
+st.header("Infinite Shared 3D World")
+st.caption("Move to empty areas to expand the world. Use sidebar 'Save' to save work to current plot.")
+
+# --- Load and Prepare HTML ---
+html_file_path = 'index.html'
+html_content_with_state = None
+
+try:
+    with open(html_file_path, 'r', encoding='utf-8') as f:
+        html_template = f.read()
+
+    # --- Inject Python state into JavaScript ---
+    js_injection_script = f"""
+<script>
+    window.ALL_INITIAL_OBJECTS = {json.dumps(all_initial_objects)};
+    window.PLOTS_METADATA = {json.dumps(plots_metadata)}; // Send plot info to JS
     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 }});
-</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)
-
-    # --- Chat Tab ---
-    with tab_chat:
-        st.header(f"{START_ROOM} Chat")
-        chat_history = run_async(load_chat_history).result() if 'chat_history' not in st.session_state else st.session_state.chat_history # Load sync if needed
-        chat_container = st.container(height=500)
-        with chat_container:
-             if chat_history: st.markdown("----\n".join(reversed(chat_history[-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
-
-        if send_button_clicked or should_autosend:
-            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}})
-                run_async(broadcast_message, ws_message) # Send via WS
-                run_async(save_chat_entry, st.session_state.username, message_to_send, voice) # Save locally
-                st.session_state.message_input = "" # Clear state for next run
-                st.rerun()
-            elif send_button_clicked: st.toast("Message empty or same as last.")
-
-        st.checkbox("Autosend Chat", key="autosend") # Toggle autosend
-
-    # --- 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") # Limit pages
-         if pdf_file:
-              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 State Management")
-        current_file = st.session_state.get('current_world_file', None)
-
-        # Save Current Version Button
-        if current_file:
-             parsed = parse_world_filename(current_file); save_label = f"Save Changes to '{parsed['name']}'"
-             if st.button(save_label, key="save_current_world", help=f"Overwrite '{os.path.basename(current_file)}' with current live state."):
-                 with st.spinner(f"Overwriting {os.path.basename(current_file)}..."):
-                     if save_world_state_to_md(current_file): st.success("Current world version saved!")
-                     else: st.error("Failed to save world state.")
-         else:
-             st.info("Load a world version from the sidebar or use 'Save New Version' below to save the current live state.")
-
-        # Save As New Version Section
-        st.subheader("Save As New Version")
-        new_name_files = st.text_input("New World Name:", key="new_world_name_files") # Use different key from sidebar one if kept there
-        if st.button("💾 Save Live State as New Version", key="save_new_version_files"):
-             if new_name_files.strip():
-                  new_filename = generate_world_save_filename(new_name_files) # Generates basename
-                  with st.spinner(f"Saving new version '{new_name_files}'..."):
-                      if save_world_state_to_md(new_filename): # Pass basename
-                          st.success(f"Saved as {new_filename}")
-                          st.session_state.current_world_file = new_filename # Switch to new file automatically
-                          st.session_state.new_world_name_files = "" # Reset input
-                          st.rerun()
-                      else: st.error("Failed to save new version.")
-             else: st.warning("Please enter a name for the new world version.")
-
-        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))
-
-        # File Deletion
-        st.subheader("🗑️ Delete Files")
-        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()
-        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:
-            if st.button("🗑️ Worlds", key="del_worlds_md", help="Deletes world save files (.md) in saved_worlds"): 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", help="Deletes Chats, Audio, Worlds, Zips"): 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"), "*.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_files = sorted(glob.glob("*.zip"), key=os.path.getmtime, reverse=True)
-        if zip_files:
-             for zip_file in zip_files: st.markdown(get_download_link(zip_file, "zip"), unsafe_allow_html=True)
-        else: st.caption("No zip archives found.")
-
-
-# ==============================================================================
-# Main Execution Logic
-# ==============================================================================
-
-def initialize_world():
-    """Loads initial world state (most recent) if not already loaded."""
-    if not st.session_state.get('initial_world_state_loaded', False):
-        print("Performing initial world load...")
-        saved_worlds = get_saved_worlds()
-        if saved_worlds:
-             latest_world_file_basename = os.path.basename(saved_worlds[0]['filename'])
-             print(f"Loading most recent world on startup: {latest_world_file_basename}")
-             load_world_state_from_md(latest_world_file_basename) # This updates global state and sets session state 'current_world_file'
-         else:
-              print("No saved worlds found, starting with empty state.")
-              with world_objects_lock: world_objects.clear() # Ensure empty state
-              st.session_state.current_world_file = None # Ensure no file is marked as loaded
-         st.session_state.initial_world_state_loaded = True
-         print("Initial world load complete.")
-
-
-if __name__ == "__main__":
-    # 1. Initialize session state first
-    init_session_state()
-
-    # 2. Start WebSocket server thread if needed
-    # Use server_running_flag to prevent multiple start attempts within one session
-    if not st.session_state.get('server_running_flag', False):
-         if 'server_task' not in st.session_state or not st.session_state.server_task.is_alive():
-              start_websocket_server_thread()
-         else:
-              # If task exists but flag is false, maybe update flag?
-              if st.session_state.server_task.is_alive():
-                  st.session_state.server_running_flag = True
-                  print("Corrected server_running_flag based on alive thread.")
-
-
-    # 3. Load initial world state from disk if needed
-    initialize_world()
-
-    # 4. Render the UI (Sidebar and Main Content)
-    render_sidebar()
-    render_main_content()
+    console.log("Streamlit State Injected:", {{
+        selectedObject: window.SELECTED_OBJECT_TYPE,
+        initialObjectsCount: window.ALL_INITIAL_OBJECTS ? window.ALL_INITIAL_OBJECTS.length : 0,
+        plotCount: window.PLOTS_METADATA ? window.PLOTS_METADATA.length : 0,
+        plotWidth: window.PLOT_WIDTH,
+        plotDepth: window.PLOT_DEPTH
+    }});
+</script>
+"""
+    html_content_with_state = html_template.replace('</head>', js_injection_script + '\n</head>', 1)
+
+    # --- Embed HTML Component ---
+    components.html(
+        html_content_with_state,
+        height=750,
+        scrolling=False
+    )
+
+except FileNotFoundError:
+    st.error(f"CRITICAL ERROR: Could not find the file '{html_file_path}'.")
+    st.warning(f"Make sure `{html_file_path}` is in the same directory as `app.py` and `{SAVE_DIR}` exists.")
+except Exception as e:
+    st.error(f"An critical error occurred during HTML preparation or component rendering: {e}")
+    st.exception(e)