Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py
+# app.py (Full Code - Fixes Applied, Single Statements per Line)
 import streamlit as st
 import asyncio
 import uuid
@@ -21,7 +21,7 @@ import threading
 import json
 import zipfile
 from dotenv import load_dotenv
-# from streamlit_marquee import streamlit_marquee # Can uncomment if marquee is used
+# from streamlit_marquee import streamlit_marquee # Import if needed
 from collections import defaultdict, Counter, deque
 from streamlit_js_eval import streamlit_js_eval # Correct import
 from PIL import Image
@@ -59,7 +59,7 @@ PLOT_DEPTH = 50.0
 WORLD_STATE_FILE_MD_PREFIX = "🌍_"
 MAX_ACTION_LOG_SIZE = 30
 
-# User/Chat Constants (Re-added)
+# User/Chat Constants
 FUN_USERNAMES = {
     "BuilderBot 🤖": "en-US-AriaNeural", "WorldWeaver 🕸️": "en-US-JennyNeural",
     "Terraformer 🌱": "en-GB-SoniaNeural", "SkyArchitect ☁️": "en-AU-NatashaNeural",
@@ -82,48 +82,69 @@ PRIMITIVE_MAP = {
 TOOLS_MAP = {"None": "🚫"}
 TOOLS_MAP.update({name: emoji for emoji, name in PRIMITIVE_MAP.items()})
 
-# --- Directories ---
+# --- Ensure Directories Exist ---
 for d in [CHAT_DIR, AUDIO_DIR, AUDIO_CACHE_DIR, SAVED_WORLDS_DIR]:
     os.makedirs(d, exist_ok=True)
 
 # --- API Keys (Placeholder) ---
 load_dotenv()
 
+# --- Lock for Action Log (Session State is generally per-session, but use if needed) ---
+# action_log_lock = threading.Lock() # Usually not needed for session_state modifications
+
 # ==============================================================================
 # Utility Functions
 # ==============================================================================
 
 def get_current_time_str(tz='UTC'):
+    """Gets formatted timestamp string in specified timezone (default UTC)."""
     try:
         timezone = pytz.timezone(tz)
         now_aware = datetime.now(timezone)
-    except Exception:
+    except pytz.UnknownTimeZoneError:
+        now_aware = datetime.now(pytz.utc)
+    except Exception as e:
+        print(f"Timezone error ({tz}), using UTC. Error: {e}")
         now_aware = datetime.now(pytz.utc)
     return now_aware.strftime('%Y%m%d_%H%M%S')
 
 def clean_filename_part(text, max_len=25):
+    """Cleans a string part for use in a filename."""
     if not isinstance(text, str): text = "invalid_name"
     text = re.sub(r'\s+', '_', text)
     text = re.sub(r'[^\w\-.]', '', text)
     return text[:max_len]
 
 def run_async(async_func, *args, **kwargs):
-    """Runs an async function safely from a sync context."""
+    """Runs an async function safely from a sync context using create_task or asyncio.run."""
+    # This helper attempts to schedule the async function as a background task.
+    # Note: Background tasks in Streamlit might have limitations accessing session state later.
     try:
         loop = asyncio.get_running_loop()
+        # Create task to run concurrently
         return loop.create_task(async_func(*args, **kwargs))
-    except RuntimeError:
-        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
+    except RuntimeError: # No running loop in this thread
+        # Fallback: Run in a new loop (blocks until completion)
+        # print(f"Warning: Running async func {async_func.__name__} in new event loop.")
+        try:
+            return asyncio.run(async_func(*args, **kwargs))
+        except Exception as e:
+            print(f"Error running async func {async_func.__name__} in new loop: {e}")
+            return None
+    except Exception as e:
+        print(f"Error scheduling async task {async_func.__name__}: {e}")
+        return None
 
-def ensure_dir(dir_path): os.makedirs(dir_path, exist_ok=True)
+def ensure_dir(dir_path):
+    """Creates directory if it doesn't exist."""
+    os.makedirs(dir_path, exist_ok=True)
 
 # ==============================================================================
 # World State File Handling (Markdown + JSON)
 # ==============================================================================
 
 def generate_world_save_filename(username="User", world_name="World"):
+    """Generates a filename for saving world state MD files."""
     timestamp = get_current_time_str()
     clean_user = clean_filename_part(username, 15)
     clean_world = clean_filename_part(world_name, 20)
@@ -131,6 +152,7 @@ def generate_world_save_filename(username="User", world_name="World"):
     return f"{WORLD_STATE_FILE_MD_PREFIX}{clean_world}_by_{clean_user}_{timestamp}_{rand_hash}.md"
 
 def parse_world_filename(filename):
+    """Extracts info from filename if possible, otherwise returns defaults."""
     basename = os.path.basename(filename)
     if basename.startswith(WORLD_STATE_FILE_MD_PREFIX) and basename.endswith(".md"):
         core = basename[len(WORLD_STATE_FILE_MD_PREFIX):-3]
@@ -142,7 +164,8 @@ def parse_world_filename(filename):
             dt_obj = None
             try:
                 dt_obj = pytz.utc.localize(datetime.strptime(timestamp_str, '%Y%m%d_%H%M%S'))
-            except Exception: dt_obj = None
+            except Exception:
+                dt_obj = None
             return {"name": world_name or "Untitled", "user": username, "timestamp": timestamp_str, "dt": dt_obj, "filename": filename}
 
     # Fallback
@@ -150,11 +173,13 @@ def parse_world_filename(filename):
     try:
         mtime = os.path.getmtime(filename)
         dt_fallback = datetime.fromtimestamp(mtime, tz=pytz.utc)
-    except Exception: pass
-    # Corrected indentation for this return statement
+    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."""
     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
@@ -169,34 +194,55 @@ def save_world_to_md(target_filename_base, world_data_dict):
 {json.dumps(world_data_dict, indent=2)}
 ```"""
     try:
-        ensure_dir(SAVED_WORLDS_DIR)
-        with open(save_path, 'w', encoding='utf-8') as f: f.write(md_content)
-        print(f"World state saved successfully to {target_filename_base}"); success = True
-    except Exception as e: print(f"Error saving world state to {save_path}: {e}")
+        ensure_dir(SAVED_WORLDS_DIR);
+        with open(save_path, 'w', encoding='utf-8') as f:
+            f.write(md_content)
+        print(f"World state saved successfully to {target_filename_base}")
+        success = True
+    except Exception as e:
+        print(f"Error saving world state to {save_path}: {e}")
     return success
 
+
 def load_world_from_md(filename_base):
+    """Loads world state dict from an MD file (basename), returns dict or None."""
     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
+    if not os.path.exists(load_path):
+        st.error(f"World file not found: {filename_base}")
+        return None
     try:
-        with open(load_path, 'r', encoding='utf-8') as f: content = f.read()
+        with open(load_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        # Find JSON block more robustly
         json_match = re.search(r"```json\s*(\{[\s\S]*?\})\s*```", content, re.IGNORECASE)
-        if not json_match: st.error(f"Could not find valid JSON block in {filename_base}"); return None
+        if not json_match:
+            st.error(f"Could not find valid JSON block in {filename_base}")
+            return None
         world_data_dict = json.loads(json_match.group(1))
         print(f"Parsed {len(world_data_dict)} objects from {filename_base}.")
         return world_data_dict # Return the dictionary
-    except json.JSONDecodeError as e: st.error(f"Invalid JSON found in {filename_base}: {e}"); return None
-    except Exception as e: st.error(f"Error loading world state from {filename_base}: {e}"); st.exception(e); return None
+    except json.JSONDecodeError as e:
+        st.error(f"Invalid JSON found in {filename_base}: {e}")
+        return None
+    except Exception as e:
+        st.error(f"Error loading world state from {filename_base}: {e}")
+        st.exception(e)
+        return None
 
 def get_saved_worlds():
+    """Scans the saved worlds directory for world MD files and parses them."""
     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 (newest first), handle None dt values
         parsed_worlds.sort(key=lambda x: x['dt'] if x['dt'] else datetime.min.replace(tzinfo=pytz.utc), reverse=True)
         return parsed_worlds
-    except Exception as e: print(f"Error scanning saved worlds: {e}"); st.error(f"Could not scan saved worlds: {e}"); return []
+    except Exception as e:
+        print(f"Error scanning saved worlds: {e}")
+        st.error(f"Could not scan saved worlds: {e}")
+        return []
 
 # ==============================================================================
 # User State & Session Init
@@ -214,6 +260,7 @@ def load_username():
     return None
 
 def init_session_state():
+    """Initializes Streamlit session state variables."""
     defaults = {
         'last_chat_update': 0, 'message_input': "", 'audio_cache': {},
         'tts_voice': DEFAULT_TTS_VOICE, 'chat_history': [], 'enable_audio': True,
@@ -228,9 +275,14 @@ def init_session_state():
     }
     for k, v in defaults.items():
         if k not in st.session_state:
-            if k == 'action_log': st.session_state[k] = deque(maxlen=MAX_ACTION_LOG_SIZE)
-            else: st.session_state[k] = v
-    # Ensure complex types initialized correctly
+            # Use copy for mutable defaults like deque to avoid shared reference issue
+            if isinstance(v, deque):
+                 st.session_state[k] = v.copy()
+            elif isinstance(v, (dict, list)): # Also copy dicts/lists if needed
+                 st.session_state[k] = v.copy()
+            else:
+                 st.session_state[k] = v
+    # Ensure complex types are correctly initialized if session reloads partially
     if not isinstance(st.session_state.chat_history, list): st.session_state.chat_history = []
     if not isinstance(st.session_state.audio_cache, dict): st.session_state.audio_cache = {}
     if not isinstance(st.session_state.download_link_cache, dict): st.session_state.download_link_cache = {}
@@ -240,32 +292,39 @@ def init_session_state():
 # Action Log Helper
 # ==============================================================================
 def add_action_log(message):
+    """Adds a message to the session's action log."""
     if 'action_log' not in st.session_state:
         st.session_state.action_log = deque(maxlen=MAX_ACTION_LOG_SIZE)
     timestamp = datetime.now().strftime("%H:%M:%S")
+    # Prepend so newest is at top
     st.session_state.action_log.appendleft(f"[{timestamp}] {message}")
 
 # ==============================================================================
 # JS Communication Handler Function
 # ==============================================================================
+# This function needs to be defined globally for streamlit_js_eval to find it by name
 def handle_js_object_placed(data):
     """Callback triggered by JS when an object is placed. Stores data in state."""
     print(f"Python received object placed event data: {type(data)}")
     processed_data = None
-    if isinstance(data, str):
+    # Logic assumes streamlit_js_eval passes the JS object directly as Python dict/list
+    if isinstance(data, dict):
+         processed_data = data
+    elif isinstance(data, str): # Fallback if it comes as JSON string
         try: processed_data = json.loads(data)
         except json.JSONDecodeError: print("Failed decode JSON from JS object place event."); return False
-    elif isinstance(data, dict): processed_data = data
     else: print(f"Received unexpected data type from JS place event: {type(data)}"); return False
 
     if processed_data and 'obj_id' in processed_data and 'type' in processed_data:
         st.session_state.js_object_placed_data = processed_data # Store for main loop processing
         add_action_log(f"Placed {processed_data.get('type', 'object')} ({processed_data.get('obj_id', 'N/A')[:6]}...)")
+        # Return value isn't used by the JS call, but good practice
+        return True
     else: print("Received invalid object placement data structure from JS."); return False
-    return True
+
 
 # ==============================================================================
-# Audio / TTS / Chat / File Handling Helpers
+# Audio / TTS / Chat / File Handling Helpers (Keep implementations)
 # ==============================================================================
 # --- Text & File Helpers ---
 def clean_text_for_tts(text):
@@ -391,28 +450,30 @@ def delete_files(file_patterns, exclude_files=None):
 # --- 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
+     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
-      paste_input_value = st.text_area("Paste Image Data Here", key="paste_input_area", height=50, value=st.session_state.get('paste_image_base64_input', ""))
+      # Simplified paste component logic
+      paste_input_value = st.text_area("Paste Image Data Here", key="paste_input_area", height=50)
       if st.button("Process Pasted Image 📋", key="process_paste_button"):
-           st.session_state.paste_image_base64_input = paste_input_value
            if paste_input_value and paste_input_value.startswith('data:image'):
                try:
                    mime_type = paste_input_value.split(';')[0].split(':')[1]; base64_str = paste_input_value.split(',')[1]; img_bytes = base64.b64decode(base64_str); pasted_img = Image.open(io.BytesIO(img_bytes)); img_type = mime_type.split('/')[1]
-                   st.image(pasted_img, caption=f"Pasted ({img_type.upper()})", width=150); st.session_state.paste_image_base64 = base64_str
-                   st.session_state.paste_image_base64_input = ""
-                   st.rerun()
-               except ImportError: st.error("Pillow library needed for image pasting.")
-               except Exception as e: st.error(f"Img decode err: {e}"); st.session_state.paste_image_base64 = ""; st.session_state.paste_image_base64_input = paste_input_value
-           else: st.warning("No valid image data pasted."); st.session_state.paste_image_base64 = ""; st.session_state.paste_image_base64_input = paste_input_value
-      processed_b64 = st.session_state.get('paste_image_base64', '')
-      if processed_b64:
-           try: img_bytes = base64.b64decode(processed_b64); return Image.open(io.BytesIO(img_bytes))
-           except Exception: return None
-      return None
+                   st.image(pasted_img, caption=f"Pasted ({img_type.upper()})", width=150); st.session_state.paste_image_base64 = base64_str # Store processed base64
+                   # Clear input area state for next run - using callback is better if possible
+                   # st.session_state.paste_input_area = "" # Direct modification fails
+                   st.rerun() # Rerun necessary to potentially process image
+               except ImportError: st.error("Pillow library needed.")
+               except Exception as e: st.error(f"Img decode err: {e}"); st.session_state.paste_image_base64 = ""
+           else: st.warning("No valid image data pasted."); st.session_state.paste_image_base64 = ""
+      # Return the image if successfully processed in *this* run after button press
+      # This is tricky due to rerun, might need state flag
+      return pasted_img
+
 
 # --- PDF Processing ---
 class AudioProcessor:
@@ -435,47 +496,83 @@ class AudioProcessor:
 
 def process_pdf_tab(pdf_file, max_pages, voice):
     st.subheader("PDF Processing Results")
-    if pdf_file is None: st.info("Upload a PDF file and click 'Process PDF' to begin."); return
+    if pdf_file is None:
+        st.info("Upload a PDF file and click 'Process PDF' to begin.")
+        return
     audio_processor = AudioProcessor()
     try:
-        reader=PdfReader(pdf_file);
-        if reader.is_encrypted: st.warning("PDF is encrypted."); return
-        total_pages_in_pdf = len(reader.pages); pages_to_process = min(total_pages_in_pdf, max_pages);
+        reader=PdfReader(pdf_file)
+        if reader.is_encrypted:
+            st.warning("PDF is encrypted.")
+            return
+        total_pages_in_pdf = len(reader.pages)
+        pages_to_process = min(total_pages_in_pdf, max_pages);
         st.write(f"Processing first {pages_to_process} of {total_pages_in_pdf} pages from '{pdf_file.name}'...")
         texts, audios={}, {}; page_threads = []; results_lock = threading.Lock()
 
         def process_page_sync(page_num, page_text):
             async def run_async_audio(): return await audio_processor.create_audio(page_text, voice)
             try:
-                 audio_path = asyncio.run(run_async_audio())
-                 if audio_path:
-                      with results_lock: audios[page_num] = audio_path
-            except Exception as page_e: print(f"Err process page {page_num+1}: {page_e}")
+                audio_path = asyncio.run(run_async_audio()) # asyncio.run is simpler here
+                if audio_path:
+                    with results_lock: audios[page_num] = audio_path
+            except Exception as page_e:
+                print(f"Err process page {page_num+1}: {page_e}")
 
+        # Start threads
         for i in range(pages_to_process):
-             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}")
+             try:
+                 page = reader.pages[i]
+                 text = page.extract_text()
+                 if text and text.strip():
+                     texts[i]=text
+                     thread = threading.Thread(target=process_page_sync, args=(i, text))
+                     page_threads.append(thread)
+                     thread.start()
+                 else:
+                     texts[i] = "[No text extracted or page empty]"
+                     print(f"Page {i+1}: No text extracted.")
+             except Exception as extract_e:
+                  texts[i] = f"[Error extracting text: {extract_e}]"
+                  print(f"Error page {i+1} extract: {extract_e}")
 
+        # Wait for threads and display progress
         progress_bar = st.progress(0.0, text="Processing pages...")
-        total_threads = len(page_threads); start_join_time = time.time()
+        total_threads = len(page_threads)
+        start_join_time = time.time()
         while any(t.is_alive() for t in page_threads):
-            completed_threads = total_threads - sum(t.is_alive() for t in page_threads); progress = completed_threads / total_threads if total_threads > 0 else 1.0
+            completed_threads = total_threads - sum(t.is_alive() for t in page_threads)
+            progress = completed_threads / total_threads if total_threads > 0 else 1.0
             progress_bar.progress(min(progress, 1.0), text=f"Processed {completed_threads}/{total_threads} pages...")
-            if time.time() - start_join_time > 600: print("PDF processing timed out."); break
-            time.sleep(0.5)
+            if time.time() - start_join_time > 600: # 10 min timeout
+                print("PDF processing timed out.")
+                st.warning("Processing timed out.")
+                break
+            time.sleep(0.5) # Avoid busy-waiting
         progress_bar.progress(1.0, text="Processing complete.")
 
+        # Display results
+        st.write("Displaying results:")
         for i in range(pages_to_process):
               with st.expander(f"Page {i+1}"):
                    st.markdown(texts.get(i, "[Error getting text]"))
-                   audio_file = audios.get(i)
-                   if audio_file: play_and_download_audio(audio_file)
-                   else: st.caption("Audio generation failed or was skipped.")
+                   audio_file = audios.get(i) # Get result from shared dict
+                   if audio_file:
+                        play_and_download_audio(audio_file)
+                   else:
+                        # Check if text existed to differentiate between skipped vs failed
+                        page_text = texts.get(i,"")
+                        if page_text.strip() and page_text != "[No text extracted or page empty]" and not page_text.startswith("[Error"):
+                             st.caption("Audio generation failed or timed out.")
+                        #else: # No text or error extracting text
+                        #     st.caption("No text to generate audio from.") # Implicit
+
+    except ImportError:
+         st.error("PyPDF2 library needed for PDF processing.")
+    except Exception as pdf_e:
+         st.error(f"Error reading PDF '{pdf_file.name}': {pdf_e}");
+         st.exception(pdf_e)
 
-    except ImportError: st.error("PyPDF2 library needed.")
-    except Exception as pdf_e: st.error(f"Err read PDF: {pdf_e}"); st.exception(pdf_e)
 
 # ==============================================================================
 # Streamlit UI Layout Functions
@@ -489,19 +586,22 @@ def render_sidebar():
         # --- World Save ---
         current_file = st.session_state.get('current_world_file')
         current_world_name = "Live State"
-        default_save_name = "MyWorld"
+        default_save_name = st.session_state.get('new_world_name', 'MyWorld')
         if current_file:
             parsed = parse_world_filename(os.path.join(SAVED_WORLDS_DIR, current_file))
             current_world_name = parsed.get("name", current_file)
             default_save_name = current_world_name # Default to overwriting current name
 
         world_save_name = st.text_input(
-            "World Name for Save:", key="world_save_name_input", value=default_save_name,
+            "World Name for Save:",
+            key="world_save_name_input",
+            value=default_save_name,
             help="Enter name to save as new, or keep current name to overwrite."
         )
 
         if st.button("💾 Save Current World View", key="sidebar_save_world"):
-            if not world_save_name.strip(): st.warning("Please enter a World Name.")
+            if not world_save_name.strip():
+                st.warning("Please enter a World Name.")
             else:
                 with st.spinner("Requesting world state & saving..."):
                     js_world_state_str = streamlit_js_eval("getWorldStateForSave();", key="get_world_state_sidebar_save", want_result=True)
@@ -509,19 +609,27 @@ def render_sidebar():
                         try:
                             world_data_dict = json.loads(js_world_state_str)
                             if isinstance(world_data_dict, dict):
-                                filename_to_save = ""; is_overwrite = False
+                                filename_to_save = ""
+                                is_overwrite = False
                                 if current_file:
                                      parsed_current = parse_world_filename(os.path.join(SAVED_WORLDS_DIR, current_file))
-                                     if world_save_name == parsed_current.get('name', ''): filename_to_save = current_file; is_overwrite = True
-                                if not filename_to_save: filename_to_save = generate_world_save_filename(st.session_state.username, world_save_name)
+                                     # Check if input name matches the name part of the current file
+                                     if world_save_name == parsed_current.get('name', ''):
+                                          filename_to_save = current_file # Use existing basename
+                                          is_overwrite = True
+
+                                if not filename_to_save: # Create new filename if not overwriting
+                                     filename_to_save = generate_world_save_filename(st.session_state.username, world_save_name)
 
                                 if save_world_to_md(filename_to_save, world_data_dict):
                                     action = "Overwritten" if is_overwrite else "Saved new"
-                                    st.success(f"World {action}: {filename_to_save}"); add_action_log(f"Saved world: {filename_to_save}")
+                                    st.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.rerun()
-                                else: st.error("Failed to save world state.")
-                            else: st.error("Invalid state format from client.")
+                                    st.session_state.new_world_name = "MyWorld" # Reset default
+                                    st.rerun() # Refresh sidebar list
+                                else: st.error("Failed to save world state to file.")
+                            else: st.error("Invalid state format received from client.")
                         except json.JSONDecodeError: st.error("Failed to decode state from client.")
                         except Exception as e: st.error(f"Save error: {e}")
                     else: st.warning("Did not receive world state from client.")
@@ -530,41 +638,38 @@ def render_sidebar():
         st.markdown("---")
         st.header("📂 Load World")
         saved_worlds = get_saved_worlds()
+
         if not saved_worlds: st.caption("No saved worlds found.")
         else:
-             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 i, world_info in enumerate(saved_worlds):
-                f_basename = os.path.basename(world_info['filename']); f_fullpath = os.path.join(SAVED_WORLDS_DIR, f_basename);
+            st.caption("Click button to load state.")
+            cols_header = st.columns([4, 1, 1]) # Adjusted column ratio
+            with cols_header[0]: st.write("**Name** (User, Time)")
+            with cols_header[1]: st.write("**Load**")
+            with cols_header[2]: st.write("**DL**")
+
+            # Simple list without expander for now
+            for world_info in saved_worlds:
+                f_basename = os.path.basename(world_info['filename'])
+                f_fullpath = os.path.join(SAVED_WORLDS_DIR, f_basename)
                 display_name = world_info.get('name', f_basename); user = world_info.get('user', 'N/A'); timestamp = world_info.get('timestamp', 'N/A')
                 display_text = f"{display_name} ({user}, {timestamp})"
-                is_last_displayed = i == display_limit -1; show_expander_trigger = len(saved_worlds) > display_limit and is_last_displayed
-                container = st
-                if displayed_count >= display_limit: container = st.expander(f"Show {len(saved_worlds)-display_limit} more...")
-                if displayed_count < display_limit or show_expander_trigger :
-                     with container:
-                          col1, col2, col3 = st.columns([3, 1, 1])
-                          with col1: st.write(f"<small>{display_text}</small>", unsafe_allow_html=True)
-                          with col2:
-                              is_current = (st.session_state.get('current_world_file') == f_basename)
-                              btn_load = st.button("Load", key=f"load_{f_basename}", help=f"Load {f_basename}", disabled=is_current)
-                          with col3: st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True)
-                          if btn_load:
-                              print(f"Load button clicked for: {f_basename}")
-                              world_dict = load_world_from_md(f_basename)
-                              if world_dict is not None:
-                                  st.session_state.world_to_load_data = world_dict
-                                  st.session_state.current_world_file = f_basename
-                                  add_action_log(f"Loading world: {f_basename}")
-                                  st.rerun()
-                              else: st.error(f"Failed to parse world file: {f_basename}")
-                     if show_expander_trigger: # If this was the trigger, stop outer loop
-                          break
-                displayed_count += 1
+
+                col1, col2, col3 = st.columns([4, 1, 1])
+                with col1: st.write(f"<small>{display_text}</small>", unsafe_allow_html=True)
+                with col2:
+                    is_current = (st.session_state.get('current_world_file') == f_basename)
+                    btn_load = st.button("Load", key=f"load_{f_basename}", help=f"Load {f_basename}", disabled=is_current)
+                with col3: st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True)
+
+                if btn_load: # Handle click if not disabled
+                    print(f"Load button clicked for: {f_basename}")
+                    world_dict = load_world_from_md(f_basename)
+                    if world_dict is not None:
+                        st.session_state.world_to_load_data = world_dict # Queue data for JS
+                        st.session_state.current_world_file = f_basename
+                        add_action_log(f"Loading world: {f_basename}")
+                        st.rerun() # Trigger rerun to send data via injection/call
+                    else: st.error(f"Failed to parse world file: {f_basename}")
 
 
         # --- Build Tools ---
@@ -576,24 +681,22 @@ def render_sidebar():
         try: tool_index = tool_options.index(current_tool_name)
         except ValueError: tool_index = 0
 
+        # Use columns for horizontal layout feel for Radio buttons
+        cols_tools = st.columns(len(tool_options))
         selected_tool = st.radio(
             "Select Tool:", options=tool_options, index=tool_index,
             format_func=lambda name: f"{TOOLS_MAP.get(name, '')} {name}",
-            key="tool_selector_radio", horizontal=True
+            key="tool_selector_radio", horizontal=True, label_visibility="collapsed" # Hide label, use header
         )
+
         if selected_tool != current_tool_name:
             st.session_state.selected_object = selected_tool
             add_action_log(f"Selected tool: {selected_tool}")
-            # Update JS using synchronous call if needed immediately, or rely on injection
-            try:
+            try: # Use streamlit_js_eval, not sync
                 streamlit_js_eval(js_code=f"updateSelectedObjectType({json.dumps(selected_tool)});", key=f"update_tool_js_{selected_tool}")
-            except Exception as e:
-                 print(f"JS tool update error: {e}")
-            # Rerun might still be useful to ensure radio button visual updates correctly,
-            # although state change should handle it. Let's keep it for now.
+            except Exception as e: print(f"JS tool update error: {e}")
             st.rerun()
 
-
         # --- Action Log ---
         st.markdown("---")
         st.header("📝 Action Log")
@@ -603,7 +706,6 @@ def render_sidebar():
             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")
@@ -624,27 +726,25 @@ def render_main_content():
     """Renders the main content area with tabs."""
     st.title(f"{Site_Name} - User: {st.session_state.username}")
 
-    # Check if world data needs to be sent to JS (loaded via sidebar button)
+    # 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...")
         try:
-            # Call JS function loadWorldState, pass data as JSON
             streamlit_js_eval(js_code=f"loadWorldState({json.dumps(world_data_to_load)});", key="load_world_js")
             st.toast("World loaded in 3D view.", icon="🔄")
         except Exception as e:
             st.error(f"Failed to send loaded world state to JS: {e}")
 
     # Set up the mechanism for JS to call Python when an object is placed
+    # This defines the JS function `window.sendPlacedObjectToPython`
     streamlit_js_eval(
         js_code="""
-            // Ensure function exists and avoid re-defining listener if possible
             if (!window.sendPlacedObjectToPython) {
                 console.log('Defining sendPlacedObjectToPython for JS->Python comms...');
                 window.sendPlacedObjectToPython = (objectData) => {
                     console.log('JS sending placed object:', objectData);
-                    // Call Python function 'handle_js_object_placed' via its unique key
-                    // Pass data directly as object - streamlit_js_eval handles serialization
+                    // Call Python function handle_js_object_placed, passing data directly
                     streamlit_js_eval(python_code='handle_js_object_placed(data=' + JSON.stringify(objectData) + ')', key='js_place_event_handler');
                 }
             }
@@ -652,13 +752,17 @@ def render_main_content():
         key="setup_js_place_event_handler" # Key for the setup code itself
     )
 
-    # Check if the Python handler function was triggered and stored data
-    placed_data = st.session_state.pop('js_object_placed_data', None) # Use pop to consume
-    if placed_data:
-        print(f"Python processed stored placed object data: {placed_data.get('obj_id')}")
-        # Action log already added in handle_js_object_placed.
-        # The object exists client-side. No server-side dict to update in this model.
-        pass # No further action needed in main loop for placement event
+    # Check if the Python handler function was triggered in the previous interaction
+    if 'js_place_event_handler' in st.session_state:
+        # The handle_js_object_placed function should have stored data in this key
+        placed_data = st.session_state.pop('js_object_placed_data', None)
+        if placed_data:
+            print(f"Python processed stored placed object data: {placed_data.get('obj_id')}")
+            # Action log already added in handle_js_object_placed.
+            # No server-side dict to update, client manages its state until save.
+            pass
+        # Remove the trigger key itself to prevent re-processing
+        del st.session_state['js_place_event_handler']
 
 
     # Define Tabs
@@ -672,32 +776,28 @@ def render_main_content():
         if current_file_basename:
              full_path = os.path.join(SAVED_WORLDS_DIR, current_file_basename)
              if os.path.exists(full_path): parsed = parse_world_filename(full_path); st.info(f"Current World: **{parsed['name']}** (`{current_file_basename}`)")
-             else: st.warning(f"Loaded file '{current_file_basename}' missing."); st.session_state.current_world_file = None # Clear if missing
-        else: st.info("Live State Active (Save to persist changes)")
+             else: st.warning(f"Loaded file '{current_file_basename}' missing."); st.session_state.current_world_file = None
+        else: st.info("Live State Active (Save to persist)")
 
         # Embed HTML Component
         html_file_path = 'index.html'
         try:
             with open(html_file_path, 'r', encoding='utf-8') as f: html_template = f.read()
-            # Inject state needed by JS (Tool, Constants)
-            # The initial world state is loaded via explicit JS call if world_to_load_data exists,
-            # OR on first load if nothing else triggered a load. We need to send *something* initially.
-            initial_world_data = {} # Default to empty
-            if 'world_to_load_data' in st.session_state and st.session_state.world_to_load_data is not None:
-                # This should have been popped and sent via JS call, but as fallback:
-                initial_world_data = st.session_state.world_to_load_data
-                print("Warning: Sending world data via injection as fallback.")
-            elif st.session_state.get('current_world_file'):
-                # If a file is loaded but data wasn't popped, try loading it again for injection
-                loaded_dict = load_world_from_md(st.session_state.current_world_file)
-                if loaded_dict: initial_world_data = loaded_dict
+            # Inject state needed by JS
+            # Load initial data for injection *only if* no specific load is pending
+            initial_world_data = {}
+            if world_data_to_load is None: # Check if data was *not* popped above
+                 if st.session_state.get('current_world_file'):
+                      loaded_dict = load_world_from_md(st.session_state.current_world_file)
+                      if loaded_dict: initial_world_data = loaded_dict
+                 # If current_world_file is None AND world_data_to_load is None, initial_world_data remains {}
 
             js_injection_script = f"""<script>
     window.USERNAME = {json.dumps(st.session_state.username)};
     window.SELECTED_OBJECT_TYPE = {json.dumps(st.session_state.selected_object)};
     window.PLOT_WIDTH = {json.dumps(PLOT_WIDTH)};
     window.PLOT_DEPTH = {json.dumps(PLOT_DEPTH)};
-    // Send current state for initial draw IF NOT handled by explicit loadWorldState call
+    // Send current state ONLY if not handled by explicit loadWorldState call
     window.INITIAL_WORLD_OBJECTS = {json.dumps(initial_world_data)};
     console.log("Streamlit State Injected:", {{ username: window.USERNAME, selectedObject: window.SELECTED_OBJECT_TYPE, initialObjects: {len(initial_world_data)} }});
 </script>"""
@@ -716,23 +816,18 @@ def render_main_content():
              if chat_history_list: st.markdown("----\n".join(reversed(chat_history_list[-50:])))
              else: st.caption("No chat messages yet.")
 
-        # Define callback for chat input clear
-        def clear_chat_input_callback():
-            st.session_state.message_input = ""
-
+        def clear_chat_input_callback(): st.session_state.message_input = ""
         message_value = st.text_input("Your Message:", key="message_input", label_visibility="collapsed")
         send_button_clicked = st.button("Send Chat", key="send_chat_button", on_click=clear_chat_input_callback)
 
-        if send_button_clicked: # Process only on button click
+        if send_button_clicked:
             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)
-                # Use run_async for background tasks
                 run_async(save_chat_entry, st.session_state.username, message_to_send, voice)
                 # Rerun is handled implicitly by button click + callback
             elif send_button_clicked: st.toast("Message empty or same as last.")
-        # Removed autosend checkbox for simplicity
 
     # --- PDF Tab ---
     with tab_pdf:
@@ -750,7 +845,6 @@ 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}'"
@@ -771,7 +865,6 @@ def render_main_content():
                           else: st.warning("Did not receive world state from client.")
         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"):
@@ -794,7 +887,7 @@ def render_main_content():
                       else: st.warning("Did not receive world state from client.")
              else: st.warning("Please enter a name.")
 
-        # --- Removed Server Status Section ---
+        # Removed Server Status Section
 
         st.subheader("🗑️ Delete Files")
         st.warning("Deletion is permanent!", icon="⚠️")
@@ -804,6 +897,7 @@ def render_main_content():
         with col_del2:
             if st.button("🗑️ Audio", key="del_audio_mp3"): delete_files([os.path.join(AUDIO_DIR, "*.mp3"), os.path.join(AUDIO_CACHE_DIR, "*.mp3")]); st.session_state.audio_cache = {}; st.rerun()
         with col_del3:
+            # Corrected delete pattern using prefix
             if st.button("🗑️ Worlds", key="del_worlds_md"): delete_files([os.path.join(SAVED_WORLDS_DIR, f"{WORLD_STATE_FILE_MD_PREFIX}*.md")]); st.session_state.current_world_file = None; st.rerun()
         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()
@@ -822,7 +916,8 @@ def render_main_content():
             st.caption("Existing Zip Files:")
             for zip_file in zip_files: st.markdown(get_download_link(zip_file, "zip"), unsafe_allow_html=True)
         else:
-            st.caption("No zip archives found.") # Correct indentation
+            # Correct indentation confirmed here
+            st.caption("No zip archives found.")
 
 
 # ==============================================================================
@@ -850,7 +945,7 @@ def initialize_app():
                  if world_dict is not None:
                       st.session_state.world_to_load_data = world_dict # Queue data to be sent to JS
                       st.session_state.current_world_file = latest_world_file_basename # Set as current
-                 else: print("Failed to load most recent world for initial state.")
+                 else: print("Failed to load most recent world.")
             else:
                  print("No saved worlds found, starting empty.");
                  st.session_state.world_to_load_data = {} # Send empty state to JS initially