Update app.py

app.py

@@ -1,6 +1,7 @@
-# app.py (Refactored - Client State Save, Action Log, Radio Tools)
+# app.py (Full Code - Including process_pdf_tab fix)
 import streamlit as st
 import asyncio
+# import websockets # Removed - Not using WS for state sync
 import uuid
 from datetime import datetime
 import os
@@ -16,28 +17,38 @@ import nest_asyncio
 import re
 import pytz
 import shutil
-# from PyPDF2 import PdfReader # Keep if PDF tab is kept
-import threading # Keep lock for potential future use or background tasks
+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 collections import defaultdict, Counter, deque # Use deque for action log
 # import pandas as pd # Removed dependency
-from streamlit_js_eval import streamlit_js_eval
+from streamlit_js_eval import streamlit_js_eval, sync # Use sync was removed, re-checking - use streamlit_js_eval
 from PIL import Image # Needed for paste_image_component
 
 # ==============================================================================
 # Configuration & Constants
 # ==============================================================================
-st.set_page_config(page_title="🌍🏗️ World Action Builder 🏆", page_icon="🏗️", layout="wide", initial_sidebar_state="expanded")
-nest_asyncio.apply() # Patch asyncio
+
+# 🛠️ 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
-Site_Name = '🌍🏗️ World Action Builder'
-MEDIA_DIR = "."
-STATE_FILE = "user_state.txt"
-DEFAULT_TTS_VOICE = "en-US-AriaNeural"
+icons = '🤖🏗️🗣️💾'
+Site_Name = '🤖🏗️ Shared World Builder 🗣️'
+START_ROOM = "World Lobby 🌍" # Used? Maybe just for chat title
+MEDIA_DIR = "." # Base directory for general files
+STATE_FILE = "user_state.txt" # For remembering username
 
 # User/Chat Constants
 FUN_USERNAMES = {
@@ -46,23 +57,20 @@ FUN_USERNAMES = {
     "PixelPainter 🎨": "en-CA-ClaraNeural", "VoxelVortex 🌪️": "en-US-GuyNeural",
     "CosmicCrafter ✨": "en-GB-RyanNeural", "GeoGuru 🗺️": "en-AU-WilliamNeural",
     "BlockBard 🧱": "en-CA-LiamNeural", "SoundSculptor 🔊": "en-US-AnaNeural",
-    # Add more if desired
 }
-# Define available voices based on the dictionary (needed for TTS)
-EDGE_TTS_VOICES = list(set(FUN_USERNAMES.values()))
-DEFAULT_TTS_VOICE = "en-US-AriaNeural" # Keep a default
+EDGE_TTS_VOICES = list(set(FUN_USERNAMES.values())) # Define available voices
+DEFAULT_TTS_VOICE = "en-US-AriaNeural"
 CHAT_DIR = "chat_logs"
 
-# Directories
-CHAT_DIR = "chat_logs"
+# Audio Constants
 AUDIO_CACHE_DIR = "audio_cache"
 AUDIO_DIR = "audio_logs"
-SAVED_WORLDS_DIR = "saved_worlds"
 
 # World Builder Constants
-PLOT_WIDTH = 50.0
-PLOT_DEPTH = 50.0
-WORLD_STATE_FILE_MD_PREFIX = "🌍_"
+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
 MAX_ACTION_LOG_SIZE = 30 # Max entries in sidebar action log
 
 # File Emojis
@@ -86,6 +94,11 @@ for d in [CHAT_DIR, AUDIO_DIR, AUDIO_CACHE_DIR, SAVED_WORLDS_DIR]:
 # --- API Keys (Placeholder) ---
 load_dotenv()
 
+# --- Global State & Locks (Removed world_objects global, only client tracking if WS re-added) ---
+# Lock might still be useful if background tasks modify shared resources (like file lists?) - Keep for now
+app_lock = threading.Lock()
+# connected_clients = set() # Removed WS client tracking
+
 # ==============================================================================
 # Utility Functions
 # ==============================================================================
@@ -94,15 +107,16 @@ def get_current_time_str(tz='UTC'):
     except Exception: now_aware = datetime.now(pytz.utc)
     return now_aware.strftime('%Y%m%d_%H%M%S')
 
-def clean_filename_part(text, max_len=25): # Shorter max len
+def clean_filename_part(text, max_len=25):
     if not isinstance(text, str): text = "invalid_name"
     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."""
+    """Runs an async function safely from a sync context using create_task or asyncio.run."""
     try: loop = asyncio.get_running_loop(); return loop.create_task(async_func(*args, **kwargs))
     except RuntimeError:
+        # 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 run_async new loop: {e}"); return None
     except Exception as e: print(f"Error run_async schedule task: {e}"); return None
@@ -114,52 +128,33 @@ def ensure_dir(dir_path): os.makedirs(dir_path, exist_ok=True)
 # ==============================================================================
 def generate_world_save_filename(username="User", world_name="World"):
     """Generates filename including username, world name, timestamp."""
-    timestamp = get_current_time_str()
-    clean_user = clean_filename_part(username, 15)
-    clean_world = clean_filename_part(world_name, 20)
-    rand_hash = hashlib.md5(str(time.time()).encode() + username.encode() + world_name.encode()).hexdigest()[:4]
+    timestamp = get_current_time_str(); clean_user = clean_filename_part(username, 15);
+    clean_world = clean_filename_part(world_name, 20);
+    rand_hash = hashlib.md5(str(time.time()).encode()+username.encode()+world_name.encode()).hexdigest()[:4]
     return f"{WORLD_STATE_FILE_MD_PREFIX}{clean_world}_by_{clean_user}_{timestamp}_{rand_hash}.md"
 
 def parse_world_filename(filename):
-    """Extracts info from filename if possible, otherwise returns defaults."""
+    """Extracts info from filename (Name, User, Time, Hash)."""
     basename = os.path.basename(filename)
-    # Check prefix and suffix
     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('_')
-        # Check if structure matches Name_by_User_Timestamp_Hash
+        core = basename[len(WORLD_STATE_FILE_MD_PREFIX):-3]; parts = core.split('_')
         if len(parts) >= 5 and parts[-3] == "by":
-            timestamp_str = parts[-2]
-            username = parts[-4]
-            world_name = " ".join(parts[:-4]) # Join potential name parts
-            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
-            except (ValueError, pytz.exceptions.AmbiguousTimeError, pytz.exceptions.NonExistentTimeError):
-                dt_obj = None # Parsing failed
+            timestamp_str = parts[-2]; username = parts[-4]; world_name = " ".join(parts[:-4]); dt_obj = None
+            try: dt_obj = pytz.utc.localize(datetime.strptime(timestamp_str, '%Y%m%d_%H%M%S'))
+            except Exception: dt_obj = None
             return {"name": world_name or "Untitled", "user": username, "timestamp": timestamp_str, "dt": dt_obj, "filename": filename}
-
-    # Fallback for unknown format or if parsing above failed
-    # This section runs if the 'if' conditions above weren't fully met
-    # print(f"Using fallback parsing for filename: {basename}") # Debugging log
-    dt_fallback = None
-    try: # Try getting modification time
-        mtime = os.path.getmtime(filename)
-        dt_fallback = datetime.fromtimestamp(mtime, tz=pytz.utc)
-    except Exception: # Ignore errors getting mtime
-        pass
-    # CORRECTED INDENTATION: This return belongs to the main function scope for the fallback case
+    # Fallback
+    dt_fallback = None; try: mtime = os.path.getmtime(filename); dt_fallback = datetime.fromtimestamp(mtime, tz=pytz.utc)
+    except Exception: pass
     return {"name": basename.replace('.md','').replace(WORLD_STATE_FILE_MD_PREFIX, ''), "user": "Unknown", "timestamp": "Unknown", "dt": dt_fallback, "filename": filename}
 
-    
 def save_world_to_md(target_filename_base, world_data_dict):
     """Saves the provided world state dictionary to a specific MD file."""
+    # No global state modification, just write the provided dict
     save_path = os.path.join(SAVED_WORLDS_DIR, target_filename_base)
     print(f"Saving {len(world_data_dict)} objects to MD file: {save_path}...")
     success = False
-    # No lock needed as we're writing data received from JS, not modifying shared state directly
-    parsed_info = parse_world_filename(save_path)
+    parsed_info = parse_world_filename(save_path) # Parse final path
     timestamp_save = get_current_time_str()
     md_content = f"""# World State: {parsed_info['name']} by {parsed_info['user']}
 * **File Saved:** {timestamp_save} (UTC)
@@ -177,7 +172,7 @@ def save_world_to_md(target_filename_base, world_data_dict):
     return success
 
 def load_world_from_md(filename_base):
-    """Loads world state dict from an MD file (basename), DOES NOT update global state."""
+    """Loads world state dict from an MD file (basename), returns dict or None."""
     load_path = os.path.join(SAVED_WORLDS_DIR, filename_base)
     print(f"Loading world state dictionary from MD file: {load_path}...")
     if not os.path.exists(load_path): st.error(f"World file not found: {filename_base}"); return None
@@ -204,12 +199,12 @@ def get_saved_worlds():
 # ==============================================================================
 # User State & Session Init
 # ==============================================================================
-def save_username(username): # Keep as is
+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(): # Keep as is
+def load_username():
     if os.path.exists(STATE_FILE):
         try:
             with open(STATE_FILE, 'r') as f: return f.read().strip()
@@ -226,7 +221,7 @@ def init_session_state():
         'selected_object': 'None', # Current building tool
         'current_world_file': None, # Track loaded world filename (basename)
         'new_world_name': "MyWorld",
-        'action_log': deque(maxlen=MAX_ACTION_LOG_SIZE), # Use deque for fixed-size log
+        'action_log': deque(maxlen=MAX_ACTION_LOG_SIZE),
         'world_to_load_data': None, # Temp storage for state loaded from file before sending to JS
         'js_object_placed_data': None # Temp storage for data coming from JS place event
     }
@@ -251,34 +246,40 @@ def add_action_log(message):
     st.session_state.action_log.appendleft(f"[{timestamp}] {message}") # Add to front
 
 # ==============================================================================
-# JS Communication Handler Function (Called from JS via streamlit_js_eval)
+# JS Communication Handler Function
 # ==============================================================================
-# NOTE: Functions called by streamlit_js_eval run in the main Python thread.
-# Avoid blocking operations here. Use session state to pass data if needed.
-
-def handle_js_object_placed(data):
+# Define this at the top level so streamlit_js_eval can find it
+def handle_js_object_placed(data): # Renamed arg for clarity
     """Callback triggered by JS when an object is placed."""
-    print(f"Python received object placed event: {data}") # Debug
-    if isinstance(data, dict) and data.get('obj_id') and data.get('type'):
+    print(f"Python received object placed event data: {type(data)}") # Debug type
+    # Data from streamlit_js_eval might already be a dict if json_data='...' was NOT used
+    # Let's assume data is already a dict/list from JS object sent.
+    # If it comes as a string, we need json.loads()
+    processed_data = None
+    if isinstance(data, str):
+        try:
+            processed_data = json.loads(data)
+        except json.JSONDecodeError:
+            print("Failed to decode JSON data from JS object place event.")
+            return False # Indicate failure
+    elif isinstance(data, dict):
+         processed_data = data # Assume it's already a dict
+    else:
+        print(f"Received unexpected data type from JS place event: {type(data)}")
+        return False
+
+    if processed_data and 'obj_id' in processed_data and 'type' in processed_data:
         # Store data in session state to be processed in the main script flow
-        st.session_state.js_object_placed_data = data
-        # Add to action log immediately
-        add_action_log(f"Placed {data.get('type', 'object')} ({data.get('obj_id', 'N/A')[:6]}...)")
-        # Need a rerun for the main loop to process st.session_state.js_object_placed_data
-        # However, triggering rerun from here can be complex.
-        # Let the natural Streamlit flow handle picking it up.
+        st.session_state.js_object_placed_data = processed_data
+        add_action_log(f"Placed {processed_data.get('type', 'object')} ({processed_data.get('obj_id', 'N/A')[:6]}...)")
     else:
-        print("Received invalid object placement data from JS.")
+        print("Received invalid object placement data structure from JS.")
+        return False
     return True # Acknowledge receipt to JS
 
-
 # ==============================================================================
-# Audio / TTS / Chat / File Handling Helpers (Unchanged from previous)
+# Audio / TTS / Chat / File Handling Helpers (Keep implementations)
 # ==============================================================================
-# (Include the full code for these helpers: clean_text_for_tts, create_file,
-#  get_download_link, async_edge_tts_generate, play_and_download_audio,
-#  save_chat_entry, load_chat_history, create_zip_of_files, delete_files,
-#  save_pasted_image, paste_image_component, AudioProcessor, process_pdf_tab)
 # --- Placeholder for brevity ---
 def clean_text_for_tts(text): # ... implementation ...
     if not isinstance(text, str): return "No text"
@@ -422,7 +423,43 @@ class AudioProcessor: # ... implementation ...
                  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): # ... implementation ... (Keep if needed)
+def process_pdf_tab(pdf_file, max_pages, voice): # ... implementation ...
+    st.subheader("PDF Processing Results");
+    if pdf_file is None: st.info("Upload a PDF file and click 'Process PDF' to begin."); return
+    audio_processor = AudioProcessor();
+    try:
+        reader=PdfReader(pdf_file);
+        if reader.is_encrypted: st.warning("PDF is encrypted."); return
+        total_pages=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):
+            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}")
+        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]"
+             except Exception as extract_e: texts[i] = f"[Error extract: {extract_e}]"; print(f"Error page {i+1} extract: {extract_e}")
+        progress_bar = st.progress(0.0, text="Processing pages...")
+        total_threads = len(page_threads); start_join_time = time.time()
+        while any(t.is_alive() for t in page_threads):
+            completed_threads = total_threads - sum(t.is_alive() for t in page_threads); progress = completed_threads / total_threads if total_threads > 0 else 1.0
+            progress_bar.progress(min(progress, 1.0), text=f"Processed {completed_threads}/{total_threads} pages...")
+            if time.time() - start_join_time > 600: print("PDF processing timed out."); break
+            time.sleep(0.5)
+        progress_bar.progress(1.0, text="Processing complete.")
+        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 was skipped.")
+    except ImportError: st.error("PyPDF2 library needed for PDF processing.")
+    except Exception as pdf_e: st.error(f"Err read PDF: {pdf_e}"); st.exception(pdf_e)
 
 
 # ==============================================================================
@@ -435,118 +472,94 @@ def render_sidebar():
         st.header("💾 World Management")
 
         # --- World Save ---
-        current_world_name = "Live State"
         current_file = st.session_state.get('current_world_file')
+        current_world_name = "Live State"
         if current_file:
-            parsed = parse_world_filename(os.path.join(SAVED_WORLDS_DIR, current_file))
-            current_world_name = parsed.get("name", current_file)
-
-        save_button_label = f"💾 Save '{current_world_name}'" if current_file else "💾 Save Live State as New..."
-        if st.button(save_button_label, key="sidebar_save_world", help="Save the current state of the 3D world."):
-            with st.spinner("Requesting world state from client..."):
-                # Ask JS for the current world state
-                js_world_state_str = streamlit_js_eval("getWorldStateForSave();", key="get_world_state_js", want_result=True)
-
-            if js_world_state_str:
-                try:
-                    world_data_dict = json.loads(js_world_state_str)
-                    if isinstance(world_data_dict, dict):
-                        save_filename = ""
-                        if current_file: # Overwrite existing file
-                             save_filename = current_file
-                             op_text = f"Overwriting '{current_world_name}'..."
-                        else: # Save as new - prompt for name? Use session state?
-                            world_name_to_save = st.session_state.get("new_world_name", "NewWorld") # Get name from state
-                            if not world_name_to_save.strip(): world_name_to_save = "NewWorld"
-                            save_filename = generate_world_save_filename(st.session_state.username, world_name_to_save)
-                            op_text = f"Saving as new version '{world_name_to_save}'..."
-
-                        with st.spinner(op_text):
-                            if save_world_to_md(save_filename, world_data_dict):
-                                st.success(f"World saved as {save_filename}")
-                                add_action_log(f"Saved world: {save_filename}")
-                                st.session_state.current_world_file = save_filename # Track saved file
-                                st.rerun() # Refresh sidebar list
-                            else:
-                                st.error("Failed to save world state to file.")
-                    else:
-                         st.error("Received invalid world state format from client.")
-                except json.JSONDecodeError:
-                    st.error("Failed to decode world state received from client.")
-                except Exception as e:
-                     st.error(f"Error during save process: {e}")
-            else:
-                st.warning("Did not receive world state from client.")
-        # Input for "Save As New" name (used if no file loaded)
-        if not current_file:
-             st.text_input("World Name for Save:", key="new_world_name", value=st.session_state.get('new_world_name', 'MyWorld'))
+             parsed = parse_world_filename(os.path.join(SAVED_WORLDS_DIR, current_file)) # Parse full path for name
+             current_world_name = parsed.get("name", current_file)
+
+        # Input for Save name (used for both Save and Save As New)
+        world_save_name = st.text_input(
+            "World Name for Save:",
+            key="world_save_name_input",
+            value=current_world_name if current_file else st.session_state.get('new_world_name', 'MyWorld'),
+            help="Enter name to save as new, or keep current name to overwrite."
+        )
 
+        if st.button("💾 Save Current World View", key="sidebar_save_world", help="Saves the current 3D view state to a file."):
+            if not world_save_name.strip():
+                st.warning("Please enter a World Name before saving.")
+            else:
+                with st.spinner("Requesting world state & saving..."):
+                    js_world_state_str = streamlit_js_eval("getWorldStateForSave();", key="get_world_state_sidebar_save", want_result=True)
+                    if js_world_state_str:
+                        try:
+                            world_data_dict = json.loads(js_world_state_str)
+                            if isinstance(world_data_dict, dict):
+                                # Decide filename: Overwrite if name matches current loaded file's derived name, else new file
+                                filename_to_save = ""
+                                is_overwrite = False
+                                if current_file:
+                                     parsed_current = parse_world_filename(os.path.join(SAVED_WORLDS_DIR, current_file))
+                                     # Check if input name matches the name part of the current file
+                                     if world_save_name == parsed_current.get('name', ''):
+                                          filename_to_save = current_file
+                                          is_overwrite = True
+
+                                if not filename_to_save: # Create new filename if not overwriting
+                                     filename_to_save = generate_world_save_filename(st.session_state.username, world_save_name)
+
+                                if save_world_to_md(filename_to_save, world_data_dict):
+                                    action = "Overwritten" if is_overwrite else "Saved new"
+                                    st.success(f"World {action}: {filename_to_save}")
+                                    add_action_log(f"Saved world: {filename_to_save}")
+                                    st.session_state.current_world_file = filename_to_save # Track saved file
+                                    st.session_state.new_world_name = "MyWorld" # Reset default potentially
+                                    # Clear the input only if it was a new save? Optional.
+                                    # st.session_state.world_save_name_input = current_world_name if is_overwrite else "MyWorld"
+                                    st.rerun() # Refresh sidebar list
+                                else: st.error("Failed to save world state.")
+                            else: st.error("Invalid state format from client.")
+                        except json.JSONDecodeError: st.error("Failed to decode state from client.")
+                        except Exception as e: st.error(f"Save error: {e}")
+                    else: st.warning("Did not receive world state from client.")
 
         # --- World Load ---
         st.markdown("---")
         st.header("📂 Load World")
         saved_worlds = get_saved_worlds()
 
-        if not saved_worlds:
-             st.caption("No saved worlds found.")
+        if not saved_worlds: st.caption("No saved worlds found.")
         else:
-             st.caption("Click to load a saved state.")
-             # Display load buttons and download links
-             cols = st.columns([4, 1]) # Columns for name and download button
-             with cols[0]: st.write("**Name** (User, Time)")
-             with cols[1]: st.write("**DL**")
-             display_limit = 15
-             for i, world_info in enumerate(saved_worlds):
+             st.caption("Click button to load state.")
+             cols_header = st.columns([3, 1, 1])
+             with cols_header[0]: st.write("**Name** (User, Time)")
+             with cols_header[1]: st.write("**Load**")
+             with cols_header[2]: st.write("**DL**")
+             display_limit = 15; displayed_count = 0
+             for world_info in 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)
-                user = world_info.get('user', 'N/A')
-                timestamp = world_info.get('timestamp', 'N/A')
+                f_fullpath = os.path.join(SAVED_WORLDS_DIR, f_basename)
+                display_name = world_info.get('name', f_basename); user = world_info.get('user', 'N/A'); timestamp = world_info.get('timestamp', 'N/A')
                 display_text = f"{display_name} ({user}, {timestamp})"
 
-                # Logic for expander
-                is_last_displayed = i == display_limit -1
-                show_expander_trigger = len(saved_worlds) > display_limit and is_last_displayed
-
+                # Use expander for items beyond limit
                 container = st
-                if show_expander_trigger and i == display_limit :
-                     container = st.expander(f"Show {len(saved_worlds)-display_limit} more...")
-
-                if i < display_limit or show_expander_trigger : # Render items within limit or inside expander
-                     with container:
-                          # Special handling to render first item inside expander if triggered
-                          if show_expander_trigger and i == display_limit:
-                              col1_exp, col2_exp, col3_exp = st.columns([3, 1, 1]);
-                              with col1_exp: btn_load = st.button(f"{display_text}", key=f"load_{f_basename}", help=f"Load {f_basename}", use_container_width=True)
-                              with col3_exp: st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True)
-                          # Render items normally (either before limit or after limit inside expander)
-                          elif i < display_limit or not show_expander_trigger:
-                               col1, col2, col3 = st.columns([3, 1, 1]) # Added extra col for button
-                               with col1: st.write(f"<small>{display_text}</small>", unsafe_allow_html=True)
-                               with col2: btn_load = st.button("Load", key=f"load_{f_basename}", help=f"Load {f_basename}")
-                               with col3: st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True)
-                          else: # Render remaining items inside expander
-                                for world_info_more in saved_worlds[display_limit+1:]: # Iterate remaining
-                                    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); u_more=world_info_more.get('user','N/A'); ts_more=world_info_more.get('timestamp','N/A')
-                                    disp_more = f"{dn_more} ({u_more}, {ts_more})"
-                                    colA, colB, colC = st.columns([3, 1, 1]);
-                                    with colA: st.write(f"<small>{disp_more}</small>", unsafe_allow_html=True)
-                                    with colB: btn_load_more = st.button("Load", key=f"load_{f_bn_more}", help=f"Load {f_bn_more}")
-                                    with colC: st.markdown(get_download_link(f_fp_more, "md"), unsafe_allow_html=True)
-                                    # Handle button click for these items
-                                    if btn_load_more:
-                                        print(f"Load button clicked for: {f_bn_more}")
-                                        world_dict = load_world_from_md(f_bn_more)
-                                        if world_dict is not None:
-                                            st.session_state.world_to_load_data = world_dict # Store data to send to JS
-                                            st.session_state.current_world_file = f_bn_more
-                                            add_action_log(f"Loading world: {f_bn_more}")
-                                            st.rerun() # Trigger rerun to send data via injection/call
-                                        else: st.error(f"Failed to parse world file: {f_bn_more}")
-                                break # Stop outer loop after handling expander fully
-
-                     # Handle button click for items outside/at start of expander
-                     if btn_load:
+                if displayed_count >= display_limit:
+                     if 'expander_open' not in st.session_state: st.session_state.expander_open = False
+                     container = st.expander(f"Show {len(saved_worlds)-display_limit} more...", expanded=st.session_state.expander_open)
+                     if not container: break # Should not happen, safety
+
+                with container: # Display inside sidebar or expander
+                     col1, col2, col3 = st.columns([3, 1, 1])
+                     with col1: st.write(f"<small>{display_text}</small>", unsafe_allow_html=True)
+                     with col2:
+                          # Disable button if already loaded
+                          is_current = (st.session_state.get('current_world_file') == f_basename)
+                          btn_load = st.button("Load", key=f"load_{f_basename}", help=f"Load {f_basename}", disabled=is_current)
+                     with col3: st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True)
+
+                     if btn_load: # Handle click if not disabled
                           print(f"Load button clicked for: {f_basename}")
                           world_dict = load_world_from_md(f_basename)
                           if world_dict is not None:
@@ -556,32 +569,31 @@ def render_sidebar():
                               st.rerun()
                           else: st.error(f"Failed to parse world file: {f_basename}")
 
+                displayed_count += 1
+                if displayed_count >= display_limit and len(saved_worlds) > display_limit:
+                     # Toggle expander state if needed for next items - complex logic, maybe remove expander for simplicity?
+                     # For now, just rely on the single expander after the limit is hit.
+                     pass
+
+
         # --- Build Tools ---
         st.markdown("---")
         st.header("🏗️ Build Tools")
         st.caption("Select an object to place.")
-        # Use Radio Buttons for Tool Selection
-        tool_options = list(TOOLS_MAP.keys()) # "None", "Tree", "Rock", etc.
+        tool_options = list(TOOLS_MAP.keys())
         current_tool_name = st.session_state.get('selected_object', 'None')
+        try: tool_index = tool_options.index(current_tool_name)
+        except ValueError: tool_index = 0 # Default to None/index 0
 
         selected_tool = st.radio(
-            "Select Tool:",
-            options=tool_options,
-            index=tool_options.index(current_tool_name) if current_tool_name in tool_options else 0,
-            format_func=lambda name: f"{TOOLS_MAP.get(name, '')} {name}", # Show emoji + name
-            key="tool_selector_radio",
-            horizontal=True # Make radio horizontal if preferred
+            "Select Tool:", options=tool_options, index=tool_index,
+            format_func=lambda name: f"{TOOLS_MAP.get(name, '')} {name}",
+            key="tool_selector_radio", horizontal=True
         )
-
-# Handle tool change
         if selected_tool != current_tool_name:
             st.session_state.selected_object = selected_tool
             add_action_log(f"Selected tool: {selected_tool}")
-            # CORRECTED: Use streamlit_js_eval instead of sync
-            # This sends the update to JS without needing a return value immediately
-            streamlit_js_eval(js_code=f"updateSelectedObjectType({json.dumps(selected_tool)});", key=f"update_tool_js_{selected_tool}")
-            # Rerun to potentially update other UI elements if needed, though maybe optional
-            # if only JS state needs update for the tool. Let's keep it for now.
+            run_async(lambda tool=selected_tool: streamlit_js_eval(f"updateSelectedObjectType({json.dumps(tool)});", key=f"update_tool_js_{tool}"))
             st.rerun()
 
         # --- Action Log ---
@@ -589,26 +601,21 @@ def render_sidebar():
         st.header("📝 Action Log")
         log_container = st.container(height=200)
         with log_container:
-            if 'action_log' in st.session_state and st.session_state.action_log:
-                # Display log entries (newest first)
-                st.code('\n'.join(st.session_state.action_log), language="log")
-            else:
-                st.caption("No actions recorded yet.")
-
+            log_entries = st.session_state.get('action_log', [])
+            if log_entries: st.code('\n'.join(log_entries), language="log")
+            else: st.caption("No actions recorded yet.")
 
         # --- Voice/User ---
         st.markdown("---")
         st.header("🗣️ Voice & User")
-        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
+        current_username = st.session_state.get('username', "DefaultUser")
+        username_options = list(FUN_USERNAMES.keys()) if FUN_USERNAMES else [current_username]
+        current_index = 0;
+        if current_username in username_options: try: current_index = username_options.index(current_username)
+        except ValueError: pass
         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:
-            st.session_state.username = new_username;
-            st.session_state.tts_voice = FUN_USERNAMES.get(new_username, DEFAULT_TTS_VOICE);
-            save_username(st.session_state.username)
-            # Add action log entry for name change?
+            st.session_state.username = new_username; st.session_state.tts_voice = FUN_USERNAMES.get(new_username, DEFAULT_TTS_VOICE); save_username(st.session_state.username)
             add_action_log(f"Username changed to {new_username}")
             st.rerun()
         st.session_state['enable_audio'] = st.toggle("Enable TTS Audio", value=st.session_state.get('enable_audio', True))
@@ -618,50 +625,37 @@ def render_main_content():
     """Renders the main content area with tabs."""
     st.title(f"{Site_Name} - User: {st.session_state.username}")
 
-    # Check if we need to send newly loaded world data to JS
-    world_data_to_load = st.session_state.pop('world_to_load_data', None) # Use pop to consume
+    # Check if world data needs to be sent to JS
+    world_data_to_load = st.session_state.pop('world_to_load_data', None)
     if world_data_to_load is not None:
         print(f"Sending loaded world state ({len(world_data_to_load)} objects) to JS...")
-        # Call the JS function to load the state
-        sync(js_code=f"loadWorldState({json.dumps(world_data_to_load)});", key="load_world_js")
+        # Use sync version of streamlit_js_eval if we need confirmation or it simplifies flow
+        # However, just calling the JS function might be enough if JS handles errors.
+        streamlit_js_eval(js_code=f"loadWorldState({json.dumps(world_data_to_load)});", key="load_world_js")
         st.toast("World loaded in 3D view.", icon="🔄")
 
-
-    # Check for object placement data coming back from JS
-    # Use streamlit_js_eval to define a Python function callable from JS
-    # Note: This function runs in the main Python thread when called by JS.
-    # It should be quick and ideally just set session state.
-    placed_object_data = streamlit_js_eval(
+    # Set up the mechanism for JS to call Python when an object is placed
+    streamlit_js_eval(
         js_code="""
-            // Define function in JS global scope if not already defined
-            if (typeof window.sendPlacedObjectToPython !== 'function') {
+            if (!window.sendPlacedObjectToPython) {
                 window.sendPlacedObjectToPython = (objectData) => {
-                    // Call the Python function 'handle_js_object_placed'
-                    // Pass data as a JSON string for safety
-                    streamlit_js_eval(`handle_js_object_placed(json_data='${JSON.stringify(objectData)}')`, key='js_place_event_handler');
+                    // Call Python function 'handle_js_object_placed' via its unique key
+                    streamlit_js_eval(`handle_js_object_placed(${JSON.stringify(objectData)})`, key='js_place_event_handler');
                 }
             }
-            null; // Return null from initial setup call
         """,
-        key="setup_js_place_event_handler"
+        key="setup_js_place_event_handler" # Key for the setup code itself
     )
 
-    # Check if the handler function was called (by checking if its key is in session_state)
-    if 'js_place_event_handler' in st.session_state:
-        # The handle_js_object_placed function (defined globally in Python)
-        # would have been called and stored data in st.session_state.js_object_placed_data
-        # Process data stored by the callback
-        processed_data = st.session_state.pop('js_object_placed_data', None) # Use pop to consume
-        if processed_data:
-            print(f"Processing stored placed object data: {processed_data.get('obj_id')}")
-            # Action log entry was already added in the handler function.
-            # Object exists client-side. Server doesn't need to store it live, only on Save.
-            # Might trigger a mini-rerun if processing changes UI elements? Unlikely here.
-            # st.rerun() # Avoid rerun if possible, log entry is enough for now
-            pass # Main processing (adding to server state dict) removed
-
-        # Important: Clear the trigger key from session_state so it doesn't re-process
-        del st.session_state['js_place_event_handler']
+    # Check if the Python handler function was triggered in the previous interaction
+    # Note: The Python function `handle_js_object_placed` should have been defined globally
+    # and it likely stored data in st.session_state.js_object_placed_data
+    placed_data = st.session_state.pop('js_object_placed_data', None) # Use pop to consume
+    if placed_data:
+        print(f"Processed stored placed object data: {placed_data.get('obj_id')}")
+        # Action log already added in handle_js_object_placed.
+        # No further action needed here in this simplified model (no server state update).
+        pass
 
 
     # Define Tabs
@@ -670,26 +664,25 @@ def render_main_content():
     # --- World Builder Tab ---
     with tab_world:
         st.header("Shared 3D World")
-        st.caption("Place objects using sidebar tools. Use Sidebar to Save/Load.")
+        st.caption("Place objects using sidebar tools. Use Sidebar/Files tab to Save/Load.")
         current_file_basename = st.session_state.get('current_world_file', None)
         if current_file_basename:
-             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}`)")
+             full_path = os.path.join(SAVED_WORLDS_DIR, current_file_basename)
+             if os.path.exists(full_path): parsed = parse_world_filename(full_path); st.info(f"Current World: **{parsed['name']}** (`{current_file_basename}`)")
              else: st.warning(f"Loaded file '{current_file_basename}' missing."); st.session_state.current_world_file = None
-        else: st.info("Live State Active (Save to persist changes)")
+        else: st.info("Live State Active (Save to persist)")
 
         # Embed HTML Component
         html_file_path = 'index.html'
         try:
             with open(html_file_path, 'r', encoding='utf-8') as f: html_template = f.read()
-            # Inject state needed by JS (Tool, Constants)
-            # Initial world state is loaded via explicit JS call if world_to_load_data exists
+            # Inject state needed by JS
             js_injection_script = f"""<script>
     window.USERNAME = {json.dumps(st.session_state.username)};
     window.SELECTED_OBJECT_TYPE = {json.dumps(st.session_state.selected_object)};
     window.PLOT_WIDTH = {json.dumps(PLOT_WIDTH)};
     window.PLOT_DEPTH = {json.dumps(PLOT_DEPTH)};
-    // INITIAL_WORLD_OBJECTS injection removed - handled by loadWorldState JS call
+    // Initial world state is now loaded via loadWorldState() JS call triggered by Python
     console.log("Streamlit State Injected:", {{ username: window.USERNAME, selectedObject: window.SELECTED_OBJECT_TYPE }});
 </script>"""
             html_content_with_state = html_template.replace('</head>', js_injection_script + '\n</head>', 1)
@@ -699,29 +692,30 @@ def render_main_content():
 
     # --- Chat Tab ---
     with tab_chat:
-        st.header(f"💬 Chat") # Simplified header
-        # Load chat history
+        st.header(f"💬 Chat")
         chat_history_list = st.session_state.get('chat_history', [])
-        if not chat_history_list: chat_history_list = asyncio.run(load_chat_history()) # Load if empty
-
+        if not chat_history_list: chat_history_list = asyncio.run(load_chat_history())
         chat_container = st.container(height=500)
         with chat_container:
              if chat_history_list: st.markdown("----\n".join(reversed(chat_history_list[-50:])))
              else: st.caption("No chat messages yet.")
 
-        # Chat Input
+        # Define callback for chat input clear
+        def clear_chat_input_callback():
+            st.session_state.message_input = ""
+
         message_value = st.text_input("Your Message:", key="message_input", label_visibility="collapsed")
-        send_button_clicked = st.button("Send Chat", key="send_chat_button")
-        # Removed autosend for simplicity, can be added back
-        if send_button_clicked:
-            message_to_send = message_value
+        send_button_clicked = st.button("Send Chat", key="send_chat_button", on_click=clear_chat_input_callback)
+        # Removed autosend for simplicity
+
+        if send_button_clicked: # Process only on button click now
+            message_to_send = message_value # Value before potential clear by callback
             if message_to_send.strip() and message_to_send != st.session_state.get('last_message', ''):
                 st.session_state.last_message = message_to_send
                 voice = st.session_state.get('tts_voice', DEFAULT_TTS_VOICE)
-                # Save entry and generate audio (fire-and-forget)
+                # Use run_async for background tasks
                 run_async(save_chat_entry, st.session_state.username, message_to_send, voice)
-                st.session_state.message_input = "" # Clear state for next run
-                st.rerun()
+                # Rerun is handled implicitly by button click + callback
             elif send_button_clicked: st.toast("Message empty or same as last.")
 
     # --- PDF Tab ---
@@ -740,10 +734,9 @@ def render_main_content():
         st.subheader("💾 World Management")
         current_file_basename = st.session_state.get('current_world_file', None)
 
-        # Save Current Version Button (if a world is loaded)
         if current_file_basename:
             full_path_for_parse = os.path.join(SAVED_WORLDS_DIR, current_file_basename)
-            save_label = f"Save Changes to '{current_file_basename}'" # Default label
+            save_label = f"Save Changes to '{current_file_basename}'"
             if os.path.exists(full_path_for_parse): parsed = parse_world_filename(full_path_for_parse); save_label = f"Save Changes to '{parsed['name']}'"
             if st.button(save_label, key="save_current_world_files", help=f"Overwrite '{current_file_basename}'"):
                  if not os.path.exists(full_path_for_parse): st.error(f"Cannot save, file missing.")
@@ -754,15 +747,13 @@ def render_main_content():
                                try:
                                    world_data_dict = json.loads(js_world_state_str)
                                    if isinstance(world_data_dict, dict):
-                                       if save_world_to_md(current_file_basename, world_data_dict):
-                                           st.success("Current world saved!"); add_action_log(f"Saved world: {current_file_basename}")
+                                       if save_world_to_md(current_file_basename, world_data_dict): st.success("Current world saved!"); add_action_log(f"Saved world: {current_file_basename}")
                                        else: st.error("Failed to save.")
                                    else: st.error("Invalid format from client.")
                                except json.JSONDecodeError: st.error("Failed to decode state from client.")
                           else: st.warning("Did not receive world state from client.")
-        else: st.info("Load a world from the sidebar to enable 'Save Changes'.")
+        else: st.info("Load a world or use 'Save As New Version' below.")
 
-        # Save As New Version Section
         st.subheader("Save As New Version")
         new_name_files = st.text_input("World Name:", key="new_world_name_files_tab", value=st.session_state.get('new_world_name', 'MyWorld'))
         if st.button("💾 Save Current View as New Version", key="save_new_version_files"):
@@ -785,7 +776,8 @@ def render_main_content():
                       else: st.warning("Did not receive world state from client.")
              else: st.warning("Please enter a name.")
 
-        # File Deletion
+        # Removed Server Status Section
+
         st.subheader("🗑️ Delete Files")
         st.warning("Deletion is permanent!", icon="⚠️")
         col_del1, col_del2, col_del3, col_del4 = st.columns(4)
@@ -798,11 +790,10 @@ def render_main_content():
         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")
         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, f"{WORLD_STATE_FILE_MD_PREFIX}*.md")), "Worlds")
+            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:
@@ -811,7 +802,8 @@ def render_main_content():
         if zip_files:
             st.caption("Existing 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.")
+        else:
+            st.caption("No zip archives found.")
 
 
 # ==============================================================================
@@ -821,36 +813,28 @@ def render_main_content():
 def initialize_app():
     """Handles session init and initial world load."""
     init_session_state()
-    # Load username here after init
+    # Load username
     if not st.session_state.username:
         loaded_user = load_username()
-        if loaded_user and loaded_user in FUN_USERNAMES:
-             st.session_state.username = loaded_user
-             st.session_state.tts_voice = FUN_USERNAMES[loaded_user]
-        else:
-             st.session_state.username = random.choice(list(FUN_USERNAMES.keys())) if FUN_USERNAMES else "User"
-             st.session_state.tts_voice = FUN_USERNAMES.get(st.session_state.username, DEFAULT_TTS_VOICE)
-             save_username(st.session_state.username) # Save the newly assigned name
-
-    # Load initial world state (most recent) if not already handled by load button click
-    # Check 'world_to_load_data' first - if present, it means a load was just triggered.
-    if 'world_to_load_data' not in st.session_state or st.session_state.world_to_load_data is None:
-        # Only load from file if no specific world load is pending
-        if st.session_state.get('current_world_file') is None: # And no world currently selected
-            print("Attempting initial load of most recent world...")
-            saved_worlds = get_saved_worlds()
-            if saved_worlds:
-                 latest_world_file_basename = os.path.basename(saved_worlds[0]['filename'])
-                 print(f"Loading most recent world on startup: {latest_world_file_basename}")
-                 world_dict = load_world_from_md(latest_world_file_basename)
-                 if world_dict is not None:
-                      st.session_state.world_to_load_data = world_dict # Set data to be sent to JS
-                      st.session_state.current_world_file = latest_world_file_basename # Update selection state
-                 else: print("Failed to load most recent world.")
-            else: print("No saved worlds found for initial load.")
+        if loaded_user and loaded_user in FUN_USERNAMES: st.session_state.username = loaded_user; st.session_state.tts_voice = FUN_USERNAMES[loaded_user]
+        else: st.session_state.username = random.choice(list(FUN_USERNAMES.keys())) if FUN_USERNAMES else "User"; st.session_state.tts_voice = FUN_USERNAMES.get(st.session_state.username, DEFAULT_TTS_VOICE); save_username(st.session_state.username)
+
+    # Load initial world state (most recent) if no specific world load is pending from a button click
+    if st.session_state.get('world_to_load_data') is None and st.session_state.get('current_world_file') is None:
+        print("Attempting initial load of most recent world...")
+        saved_worlds = get_saved_worlds()
+        if saved_worlds:
+             latest_world_file_basename = os.path.basename(saved_worlds[0]['filename'])
+             print(f"Loading most recent world on startup: {latest_world_file_basename}")
+             world_dict = load_world_from_md(latest_world_file_basename)
+             if world_dict is not None:
+                  st.session_state.world_to_load_data = world_dict # Set data to be sent to JS
+                  st.session_state.current_world_file = latest_world_file_basename # Update selection state
+             else: print("Failed to load most recent world.")
+        else: print("No saved worlds found for initial load.")
 
 
 if __name__ == "__main__":
-    initialize_app() # Initialize state, load user, potentially load initial world data state
-    render_sidebar() # Render sidebar UI
-    render_main_content() # Render main UI content (includes logic to send loaded world data to JS)
+    initialize_app() # Initialize state, user, potentially queue initial world load data
+    render_sidebar() # Render sidebar UI (includes load buttons)
+    render_main_content() # Render main UI (includes logic to send loaded world data to JS)