Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py (Re-integrated WebSockets for 3D Sync - Cleaned)
+# app.py (Full Code - Corrected Multi-statement/Indentation Errors)
 import streamlit as st
 import asyncio
 import websockets # Re-added
@@ -22,9 +22,9 @@ import threading
 import json
 import zipfile
 from dotenv import load_dotenv
-# from streamlit_marquee import streamlit_marquee
+# from streamlit_marquee import streamlit_marquee # Import if needed
 from collections import defaultdict, Counter, deque
-from streamlit_js_eval import streamlit_js_eval # Keep for UI interaction if needed
+from streamlit_js_eval import streamlit_js_eval # Correct import
 from PIL import Image
 
 # ==============================================================================
@@ -149,11 +149,21 @@ def parse_world_filename(filename): # Define this before get_saved_worlds uses i
             try: dt_obj = pytz.utc.localize(datetime.strptime(timestamp_str, '%Y%m%d_%H%M%S'))
             except Exception: dt_obj = None
             return {"name": world_name or "Untitled", "user": username, "timestamp": timestamp_str, "dt": dt_obj, "filename": filename}
-    # Fallback
-    dt_fallback = None; try: mtime = os.path.getmtime(filename); dt_fallback = datetime.fromtimestamp(mtime, tz=pytz.utc)
-    except Exception: pass
+
+    # Fallback for unknown format or failed parse
+    # print(f"Using fallback parsing for filename: {basename}") # Debug log
+    dt_fallback = None # Initialize on its own line
+    try: # Start try block on its own line
+        # Indented block under try
+        mtime = os.path.getmtime(filename)
+        dt_fallback = datetime.fromtimestamp(mtime, tz=pytz.utc)
+    except Exception: # Statement aligned with try
+        # Indented block under except
+        pass # Statement on its own line
+    # Return statement aligned with the start of the fallback logic block
     return {"name": basename.replace('.md','').replace(WORLD_STATE_FILE_MD_PREFIX, ''), "user": "Unknown", "timestamp": "Unknown", "dt": dt_fallback, "filename": filename}
 
+
 def load_initial_world_from_file():
     """Loads the state from the most recent MD file found."""
     print(f"[{time.time():.1f}] ⏳ Attempting to load initial world state from files...")
@@ -190,7 +200,15 @@ def get_world_state_manager():
         "lock": threading.Lock(),
         "state": load_initial_world_from_file() # Load initial state here
     }
-    # Initial current_world_file is now handled after init_session_state in main logic
+    # Set initial current_world_file if state was loaded successfully
+    if manager["state"]:
+         saved_worlds = get_saved_worlds()
+         if saved_worlds:
+              latest_world_file_basename = os.path.basename(saved_worlds[0]['filename'])
+              if 'current_world_file' not in st.session_state: # Initialize only if not set
+                   st.session_state.current_world_file = latest_world_file_basename
+                   print(f"🐍 Set initial current_world_file state to: {latest_world_file_basename}")
+
     return manager
 
 def get_current_world_state_copy():
@@ -210,12 +228,12 @@ def generate_world_save_filename(username="User", world_name="World"):
 
 def save_world_state_to_md(target_filename_base):
     """Saves the current cached world state to a specific MD file."""
-    manager = get_world_state_manager()
+    manager = get_world_state_manager() # Get resource
     save_path = os.path.join(SAVED_WORLDS_DIR, target_filename_base)
     print(f"💾 Acquiring lock to save world state to: {save_path}...")
     success = False
-    with manager["lock"]:
-        world_data_dict = dict(manager["state"])
+    with manager["lock"]: # Use resource's lock
+        world_data_dict = dict(manager["state"]) # Get copy from resource state
         print(f"💾 Saving {len(world_data_dict)} objects...")
         parsed_info = parse_world_filename(save_path)
         timestamp_save = get_current_time_str()
@@ -237,7 +255,7 @@ def save_world_state_to_md(target_filename_base):
 
 def load_world_state_from_md(filename_base):
     """Loads world state from MD, updates cached state, returns success bool."""
-    manager = get_world_state_manager()
+    manager = get_world_state_manager() # Get resource
     load_path = os.path.join(SAVED_WORLDS_DIR, filename_base)
     print(f"📜 Loading world state from MD file: {load_path}...")
     if not os.path.exists(load_path): st.error(f"World file not found: {filename_base}"); return False
@@ -248,9 +266,9 @@ def load_world_state_from_md(filename_base):
         world_data_dict = json.loads(json_match.group(1))
 
         print(f"⚙️ Acquiring lock to update cached world state from {filename_base}...")
-        with manager["lock"]:
-             manager["state"].clear()
-             for k, v in world_data_dict.items(): manager["state"][str(k)] = v
+        with manager["lock"]: # Use resource's lock
+             manager["state"].clear() # Clear the existing cached state dict
+             for k, v in world_data_dict.items(): manager["state"][str(k)] = v # Update with loaded data
              loaded_count = len(manager["state"])
         print(f"✅ Loaded {loaded_count} objects into cached state. Lock released.")
         st.session_state.current_world_file = filename_base # Track loaded file
@@ -284,11 +302,10 @@ def init_session_state():
         'download_link_cache': {}, 'username': None, 'autosend': False,
         'last_message': "",
         'selected_object': 'None',
-        # 'initial_world_state_loaded' flag removed, cache resource handles init
         'current_world_file': None, # Track loaded world filename (basename)
         'new_world_name': "MyDreamscape",
         'action_log': deque(maxlen=MAX_ACTION_LOG_SIZE),
-        # State related to JS interaction moved or removed if WS handles it
+        # Removed temporary state holders 'world_to_load_data', 'js_object_placed_data'
     }
     for k, v in defaults.items():
         if k not in st.session_state:
@@ -314,18 +331,17 @@ def add_action_log(message, emoji="➡️"):
 # ==============================================================================
 # 7. 🎧 Audio / TTS / Chat / File Handling Helpers
 # ==============================================================================
-# (Keep implementations from previous correct version - Placeholder for brevity)
-def clean_text_for_tts(text): # ... implementation ...
+def clean_text_for_tts(text):
     if not isinstance(text, str): return "No text"
     text = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', text); text = re.sub(r'[#*_`!]', '', text)
     text = ' '.join(text.split()); return text[:250] or "No text"
-def create_file(content, username, file_type="md", save_path=None): # ... implementation ...
+def create_file(content, username, file_type="md", save_path=None):
     if not save_path: filename = generate_filename(content, username, file_type); save_path = os.path.join(MEDIA_DIR, filename)
     ensure_dir(os.path.dirname(save_path))
     try:
         with open(save_path, 'w', encoding='utf-8') as f: f.write(content); return save_path
     except Exception as e: print(f"❌ Error creating file {save_path}: {e}"); return None
-def get_download_link(file_path, file_type="md"): # ... implementation ...
+def get_download_link(file_path, file_type="md"):
     if not file_path or not os.path.exists(file_path): basename = os.path.basename(file_path) if file_path else "N/A"; return f"<small>Not found: {basename}</small>"
     try: mtime = os.path.getmtime(file_path)
     except OSError: mtime = 0
@@ -340,7 +356,7 @@ def get_download_link(file_path, file_type="md"): # ... implementation ...
             st.session_state.download_link_cache[cache_key] = link_html
         except Exception as e: print(f"❌ Error generating DL link for {file_path}: {e}"); return f"<small>Err</small>"
     return st.session_state.download_link_cache.get(cache_key, "<small>CacheErr</small>")
-async def async_edge_tts_generate(text, voice, username): # ... implementation ...
+async def async_edge_tts_generate(text, voice, username):
     if not text: return None
     cache_key = hashlib.md5(f"{text[:150]}_{voice}".encode()).hexdigest();
     if 'audio_cache' not in st.session_state: st.session_state.audio_cache = {}
@@ -355,21 +371,27 @@ async def async_edge_tts_generate(text, voice, username): # ... implementation .
         if os.path.exists(save_path) and os.path.getsize(save_path) > 0: st.session_state.audio_cache[cache_key] = save_path; return save_path
         else: print(f"❌ Audio file {save_path} failed generation."); return None
     except Exception as e: print(f"❌ Edge TTS Error: {e}"); return None
-def play_and_download_audio(file_path): # ... implementation ...
+def play_and_download_audio(file_path):
     if file_path and os.path.exists(file_path):
-        try: st.audio(file_path); file_type = file_path.split('.')[-1]; st.markdown(get_download_link(file_path, file_type), unsafe_allow_html=True)
+        try:
+             st.audio(file_path)
+             file_type = file_path.split('.')[-1]
+             st.markdown(get_download_link(file_path, file_type), unsafe_allow_html=True)
         except Exception as e: st.error(f"❌ Audio display error for {os.path.basename(file_path)}: {e}")
-async def save_chat_entry(username, message, voice, is_markdown=False): # ... implementation ...
+async def save_chat_entry(username, message, voice, is_markdown=False):
     if not message.strip(): return None, None
-    timestamp_str = get_current_time_str(); entry = f"[{timestamp_str}] {username} ({voice}): {message}" if not is_markdown else f"[{timestamp_str}] {username} ({voice}):\n```markdown\n{message}\n```"
+    timestamp_str = get_current_time_str();
+    entry = f"[{timestamp_str}] {username} ({voice}): {message}" if not is_markdown else f"[{timestamp_str}] {username} ({voice}):\n```markdown\n{message}\n```"
     md_filename_base = generate_filename(message, username, "md"); md_file_path = os.path.join(CHAT_DIR, md_filename_base);
     md_file = create_file(entry, username, "md", save_path=md_file_path)
     if 'chat_history' not in st.session_state: st.session_state.chat_history = [];
     st.session_state.chat_history.append(entry)
     audio_file = None;
-    if st.session_state.get('enable_audio', True): tts_message = message ; audio_file = await async_edge_tts_generate(tts_message, voice, username)
+    if st.session_state.get('enable_audio', True):
+         tts_message = message
+         audio_file = await async_edge_tts_generate(tts_message, voice, username)
     return md_file, audio_file
-async def load_chat_history(): # ... implementation ...
+async def load_chat_history():
      if 'chat_history' not in st.session_state: st.session_state.chat_history = []
      if not st.session_state.chat_history:
           ensure_dir(CHAT_DIR); print("📜 Loading chat history from files...")
@@ -382,7 +404,7 @@ async def load_chat_history(): # ... implementation ...
           st.session_state.chat_history = temp_history
           print(f"✅ Loaded {loaded_count} chat entries from files.")
      return st.session_state.chat_history
-def create_zip_of_files(files_to_zip, prefix="Archive"): # ... implementation ...
+def create_zip_of_files(files_to_zip, prefix="Archive"):
     if not files_to_zip: st.warning("💨 Nothing to gather into an archive."); return None
     timestamp = format_timestamp_prefix(f"Zip_{prefix}"); zip_name = f"{prefix}_{timestamp}.zip"
     try:
@@ -393,7 +415,7 @@ def create_zip_of_files(files_to_zip, prefix="Archive"): # ... implementation ..
                  else: print(f"💨 Skip zip missing file: {f}")
         print("✅ Zip archive created successfully."); st.success(f"Created {zip_name}"); return zip_name
     except Exception as e: print(f"❌ Zip creation failed: {e}"); st.error(f"Zip creation failed: {e}"); return None
-def delete_files(file_patterns, exclude_files=None): # ... implementation ...
+def delete_files(file_patterns, exclude_files=None):
     protected = [STATE_FILE, "app.py", "index.html", "requirements.txt", "README.md"]
     current_world_base = st.session_state.get('current_world_file')
     if current_world_base: protected.append(current_world_base)
@@ -410,18 +432,18 @@ def delete_files(file_patterns, exclude_files=None): # ... implementation ...
                    if os.path.isfile(f_path) and basename not in protected:
                         try: os.remove(f_path); print(f"🗑️ Deleted: {f_path}"); deleted_count += 1
                         except Exception as e: print(f"❌ Failed delete {f_path}: {e}"); errors += 1
-                   #else: print(f"🚫 Skipping protected/directory: {f_path}") # Debugging
+                   #else: print(f"🚫 Skipping protected/directory: {f_path}")
          except Exception as glob_e: print(f"❌ Error matching pattern {pattern}: {glob_e}"); errors += 1
     msg = f"✅ Successfully deleted {deleted_count} files." if errors == 0 and deleted_count > 0 else f"Deleted {deleted_count} files."
     if errors > 0: msg += f" Encountered {errors} errors."; st.warning(msg)
     elif deleted_count > 0: st.success(msg)
     else: st.info("💨 No matching unprotected files found to delete.")
     st.session_state['download_link_cache'] = {}; st.session_state['audio_cache'] = {}
-async def save_pasted_image(image, username): # ... implementation ...
+async def save_pasted_image(image, username):
      if not image: return None
      try: img_hash = hashlib.md5(image.tobytes()).hexdigest()[:8]; timestamp = format_timestamp_prefix(username); filename = f"{timestamp}_pasted_{img_hash}.png"; filepath = os.path.join(MEDIA_DIR, filename); image.save(filepath, "PNG"); print(f"🖼️ Pasted image saved: {filepath}"); return filepath
      except Exception as e: print(f"❌ Failed image save: {e}"); return None
-def paste_image_component(): # ... implementation ...
+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', ""), help="Paste image data directly (e.g., from clipboard)")
       if st.button("🖼️ Process Pasted Image", key="process_paste_button"):
@@ -440,7 +462,8 @@ def paste_image_component(): # ... implementation ...
            try: img_bytes = base64.b64decode(processed_b64); return Image.open(io.BytesIO(img_bytes))
            except Exception: return None
       return None
-class AudioProcessor: # ... implementation ...
+# --- PDF Processing ---
+class AudioProcessor:
       def __init__(self): self.cache_dir=AUDIO_CACHE_DIR; ensure_dir(self.cache_dir); self.metadata=json.load(open(f"{self.cache_dir}/metadata.json", 'r')) if os.path.exists(f"{self.cache_dir}/metadata.json") else {}
       def _save_metadata(self):
             try:
@@ -458,7 +481,7 @@ class AudioProcessor: # ... implementation ...
                  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 ...
+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
     audio_processor = AudioProcessor()
@@ -471,12 +494,12 @@ def process_pdf_tab(pdf_file, max_pages, voice): # ... implementation ...
 
         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()) # Use asyncio.run in thread
+            try: audio_path = asyncio.run(run_async_audio()) # Use asyncio.run in thread
                  if audio_path:
                       with results_lock: audios[page_num] = audio_path
             except Exception as page_e: print(f"❌ Err process page {page_num+1}: {page_e}")
 
+        # Start threads
         for i in range(pages_to_process):
              try: # Start try block for page processing
                  page = reader.pages[i]
@@ -488,12 +511,12 @@ def process_pdf_tab(pdf_file, max_pages, voice): # ... implementation ...
                      thread.start() # Start thread
                  else: # Handle empty extraction
                      texts[i] = "[📄 No text extracted or page empty]"
-                     # print(f"Page {i+1}: No text extracted.") # Verbose
              # Correctly indented except block
              except Exception as extract_e:
                   texts[i] = f"[❌ Error extract: {extract_e}]" # Store error message
                   print(f"Error page {i+1} extract: {extract_e}") # Log error
 
+        # Wait for threads and display progress
         progress_bar = st.progress(0.0, text="✨ Transmuting pages to sound...")
         total_threads = len(page_threads); start_join_time = time.time()
         while any(t.is_alive() for t in page_threads):
@@ -503,6 +526,7 @@ def process_pdf_tab(pdf_file, max_pages, voice): # ... implementation ...
             time.sleep(0.5)
         progress_bar.progress(1.0, text="✅ Processing complete.")
 
+        # Display results
         st.write("🎶 Results:")
         for i in range(pages_to_process):
               with st.expander(f"Page {i+1}"):
@@ -512,19 +536,19 @@ def process_pdf_tab(pdf_file, max_pages, voice): # ... implementation ...
                    else:
                         page_text = texts.get(i,"")
                         if page_text.strip() and not page_text.startswith("["): st.caption("🔇 Audio generation failed or timed out.")
-                        # else: st.caption("🔇 No text to generate audio from.") # Implicit
 
     except ImportError: st.error("⚠️ PyPDF2 library needed.")
     except Exception as pdf_e: st.error(f"❌ Error reading PDF '{pdf_file.name}': {pdf_e}"); st.exception(pdf_e)
 
+
 # ==============================================================================
-# 8. 🕸️ WebSocket Server Logic (Re-added for Chat/Presence)
+# 8. 🕸️ WebSocket Server Logic
 # ==============================================================================
 
 async def register_client(websocket):
     """Adds client to tracking structures, ensuring thread safety."""
     client_id = str(websocket.id);
-    with clients_lock:
+    with clients_lock: # Use the dedicated lock for client structures
         connected_clients.add(client_id);
         if 'active_connections' not in st.session_state: st.session_state.active_connections = defaultdict(dict);
         st.session_state.active_connections[client_id] = websocket;
@@ -540,49 +564,56 @@ async def unregister_client(websocket):
 
 async def send_safely(websocket, message, client_id):
      """Wrapper to send message and handle potential connection errors."""
-     try: await websocket.send(message)
-     except websockets.ConnectionClosed: print(f"❌ WS Send failed (Closed) client {client_id}"); raise # Raise to be caught by gather
-     except RuntimeError as e: print(f"❌ WS Send failed (Runtime {e}) client {client_id}"); raise
-     except Exception as e: print(f"❌ WS Send failed (Other {e}) client {client_id}"); raise
+     try:
+         await websocket.send(message)
+     except websockets.ConnectionClosed:
+         print(f"❌ WS Send failed (Closed) client {client_id}")
+         raise # Re-raise to be caught by gather
+     except RuntimeError as e:
+         print(f"❌ WS Send failed (Runtime {e}) client {client_id}")
+         raise
+     except Exception as e:
+         print(f"❌ WS Send failed (Other {e}) client {client_id}")
+         raise
 
 async def broadcast_message(message, exclude_id=None):
     """Sends a message to all connected clients except the excluded one."""
     # Create local copies under lock for thread safety
     with clients_lock:
-        if not connected_clients: return
+        if not connected_clients:
+             return
         current_client_ids = list(connected_clients)
         # Ensure active_connections exists and make a copy
         if 'active_connections' in st.session_state:
             active_connections_copy = st.session_state.active_connections.copy()
         else:
-            active_connections_copy = {} # Should not happen if init_session_state is correct
+             active_connections_copy = {} # Should not happen if init runs first
 
     tasks = []
     for client_id in current_client_ids:
-        if client_id == exclude_id: continue
+        if client_id == exclude_id:
+            continue
         websocket = active_connections_copy.get(client_id) # Use copy
         if websocket:
             tasks.append(asyncio.create_task(send_safely(websocket, message, client_id)))
 
     if tasks:
-        results = await asyncio.gather(*tasks, return_exceptions=True)
-        # Optional: Check results for exceptions if specific error handling per client is needed
-
+        await asyncio.gather(*tasks, return_exceptions=True) # Wait and ignore errors here
 
 async def broadcast_world_update():
     """Broadcasts the current world state (from cache) to all clients."""
-    # Uses the cached state manager
-    world_state_copy = get_current_world_state_copy()
+    world_state_copy = get_current_world_state_copy() # Safely get a copy
     update_msg = json.dumps({"type": "initial_state", "payload": world_state_copy})
     print(f"📡 Broadcasting full world update ({len(world_state_copy)} objects)...")
-    await broadcast_message(update_msg)
+    await broadcast_message(update_msg) # Send to all connected clients
 
 async def websocket_handler(websocket, path):
-    """Handles WebSocket connections and messages (primarily for Chat & 3D Sync)."""
+    """Handles WebSocket connections and messages using cached world state."""
     await register_client(websocket); client_id = str(websocket.id);
+    # Use username from main session state - might require adjustments if session state isn't thread-safe across contexts
     username = st.session_state.get('username', f"User_{client_id[:4]}")
 
-    try: # Send initial world state
+    try: # Send initial state
         initial_state_payload = get_current_world_state_copy() # Get state using cached helper
         initial_state_msg = json.dumps({"type": "initial_state", "payload": initial_state_payload});
         await websocket.send(initial_state_msg)
@@ -595,7 +626,7 @@ async def websocket_handler(websocket, path):
         async for message in websocket:
             try:
                 data = json.loads(message); msg_type = data.get("type"); payload = data.get("payload", {});
-                sender_username = payload.get("username", username) # Get username from payload
+                sender_username = payload.get("username", username) # Username sent from client
 
                 # --- Handle Different Message Types ---
                 manager = get_world_state_manager() # Get state manager for world updates
@@ -614,7 +645,8 @@ async def websocket_handler(websocket, path):
                         # Broadcast placement to others
                         broadcast_payload = json.dumps({"type": "object_placed", "payload": {"object_data": obj_data, "username": sender_username}});
                         await broadcast_message(broadcast_payload, exclude_id=client_id)
-                        run_async(lambda: add_action_log(f"Placed {obj_data['type']} ({obj_data['obj_id'][:6]}) by {sender_username}", TOOLS_MAP.get(obj_data['type'], '❓')))
+                        # Use run_async for session state update if needed from thread
+                        # run_async(lambda: add_action_log(f"Placed {obj_data['type']} ({obj_data['obj_id'][:6]}) by {sender_username}", TOOLS_MAP.get(obj_data['type'], '❓')))
                     else: print(f"⚠️ WS Invalid place_object payload: {payload}")
 
                 elif msg_type == "delete_object":
@@ -626,7 +658,7 @@ async def websocket_handler(websocket, path):
                           if removed:
                                broadcast_payload = json.dumps({"type": "object_deleted", "payload": {"obj_id": obj_id, "username": sender_username}});
                                await broadcast_message(broadcast_payload, exclude_id=client_id)
-                               run_async(lambda: add_action_log(f"Deleted obj ({obj_id[:6]}) by {sender_username}", "🗑️"))
+                               # run_async(lambda: add_action_log(f"Deleted obj ({obj_id[:6]}) by {sender_username}", "🗑️"))
                      else: print(f"⚠️ WS Invalid delete_object payload: {payload}")
 
                 elif msg_type == "player_position":
@@ -644,7 +676,7 @@ async def websocket_handler(websocket, path):
     except Exception as e: print(f"❌ WS Unexpected handler error {client_id}: {e}")
     finally:
          await broadcast_message(json.dumps({"type": "user_leave", "payload": {"username": username, "id": client_id}}), exclude_id=client_id);
-         await unregister_client(websocket)
+         await unregister_client(websocket) # Cleanup
 
 
 async def run_websocket_server():
@@ -685,7 +717,6 @@ def start_websocket_server_thread():
     st.session_state.server_task = threading.Thread(target=run_loop, daemon=True); st.session_state.server_task.start(); time.sleep(1.5)
     if not st.session_state.server_task.is_alive(): print("### ❌ Server thread failed to stay alive!")
 
-
 # ==============================================================================
 # 9. 🎨 Streamlit UI Layout Functions
 # ==============================================================================
@@ -699,32 +730,37 @@ def render_sidebar():
 
         # World Save Button
         current_file = st.session_state.get('current_world_file')
-        save_name_value = st.session_state.get('world_save_name_input', "MyDreamscape" if not current_file else parse_world_filename(os.path.join(SAVED_WORLDS_DIR, current_file)).get("name", current_file))
-        world_save_name = st.text_input("World Name:", key="world_save_name_input", value=save_name_value, help="Enter name to save.")
+        current_world_name = "Live State"
+        default_save_name = st.session_state.get('new_world_name', 'MyDreamscape')
+        if current_file:
+            try: parsed = parse_world_filename(os.path.join(SAVED_WORLDS_DIR, current_file)); current_world_name = parsed.get("name", current_file)
+            except Exception: pass
+            default_save_name = current_world_name
+
+        world_save_name = st.text_input("World Name:", key="world_save_name_input", value=default_save_name, help="Enter name to save.")
 
         if st.button("💾 Save Current World View", key="sidebar_save_world"):
-            if not world_save_name.strip(): st.warning("⚠️ Please enter a World Name.")
+            if not world_save_name.strip():
+                st.warning("⚠️ Please enter a World Name.")
             else:
-                # Save current state (which is managed by cache resource, updated by WS)
                 filename_to_save = ""; is_overwrite = False
                 if current_file:
-                     try: # Check if name matches current loaded file's parsed name
+                     try:
                           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
-                     except Exception: pass # Fallback to new save if parsing fails
-
+                     except Exception: pass
                 if not filename_to_save: filename_to_save = generate_world_save_filename(st.session_state.username, world_save_name)
 
                 op_text = f"Overwriting {filename_to_save}..." if is_overwrite else f"Saving as {filename_to_save}..."
                 with st.spinner(op_text):
-                    if save_world_state_to_md(filename_to_save): # Saves state from cached resource
+                    # Save uses the current state from the cached resource
+                    if save_world_state_to_md(filename_to_save):
                         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}", emoji="💾")
                         st.session_state.current_world_file = filename_to_save # Track saved file
                         st.rerun()
                     else: st.error("❌ Failed to save world state.")
 
-
         # --- World Load ---
         st.markdown("---")
         st.header("2. 📂 Load World")
@@ -754,12 +790,12 @@ def render_sidebar():
                     if btn_load:
                         print(f"🖱️ Load button clicked for: {f_basename}")
                         with st.spinner(f"Loading {f_basename}..."):
-                            # load_world_state_from_md now updates the cached resource directly
+                            # load_world_state_from_md updates the cached resource
                             if load_world_state_from_md(f_basename):
                                 run_async(broadcast_world_update) # Broadcast the newly loaded state
                                 add_action_log(f"Loading world: {f_basename}", emoji="📂")
                                 st.toast("World loaded!", icon="✅")
-                                st.rerun() # Rerun to update UI and ensure clients get state via WS
+                                st.rerun() # Rerun to update UI
                             else: st.error(f"❌ Failed to load world file: {f_basename}")
 
         # --- Build Tools ---
@@ -780,7 +816,8 @@ def render_sidebar():
             st.session_state.selected_object = selected_tool
             tool_emoji = TOOLS_MAP.get(selected_tool, '❓')
             add_action_log(f"Tool selected: {selected_tool}", emoji=tool_emoji)
-            try: streamlit_js_eval(js_code=f"updateSelectedObjectType({json.dumps(selected_tool)});", key=f"update_tool_js_{selected_tool}")
+            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}")
             st.rerun()
 
@@ -803,7 +840,8 @@ def render_sidebar():
         current_username = st.session_state.get('username', "DefaultUser")
         username_options = list(FUN_USERNAMES.keys()) if FUN_USERNAMES else [current_username]
         current_index = 0;
-        try: # Safely find index
+        # Corrected try-except for finding index
+        try:
             if current_username in username_options: current_index = username_options.index(current_username)
         except ValueError: pass # Keep index 0
 
@@ -822,10 +860,8 @@ def render_main_content():
     """Renders the main content area with tabs."""
     st.title(f"{Site_Name} - User: {st.session_state.username}")
 
-    # NOTE: No longer need to check/send 'world_to_load_data' here.
-    # The load button triggers load_world_state_from_md which updates the cache,
-    # then triggers broadcast_world_update (via run_async), and reruns.
-    # The WS handler sends initial state from the cache on new connections.
+    # NOTE: World loading is handled by button click -> load_world_state_from_md -> broadcast -> rerun
+    # Initial world state is sent by WS handler on connect
 
     # Define Tabs
     tab_world, tab_chat, tab_pdf, tab_files = st.tabs(["🏗️ World Builder", "🗣️ Chat", "📚 PDF Tools", "📂 Files & Settings"])
@@ -849,19 +885,19 @@ def render_main_content():
             try: # Get WS URL (Best effort)
                  from streamlit.web.server.server import Server
                  session_info = Server.get_current()._get_session_info(st.runtime.scriptrunner.get_script_run_ctx().session_id)
-                 host_attr = getattr(session_info.ws.stream.request, 'host', None) or getattr(getattr(session_info, 'client', None), 'request', None)
+                 host_attr = getattr(session_info.ws.stream.request, 'host', getattr(getattr(session_info, 'client', None), 'request', None))
                  if host_attr: server_host = host_attr.host.split(':')[0]; ws_url = f"ws://{server_host}:8765"
                  else: raise AttributeError("Host attribute not found")
             except Exception as e: print(f"⚠️ WS URL detection failed ({e}), using localhost.")
 
-            # Inject only necessary state for JS init
+            # Initial world state sent via WS, only need constants/UI state here
             js_injection_script = f"""<script>
     window.USERNAME = {json.dumps(st.session_state.username)};
     window.WEBSOCKET_URL = {json.dumps(ws_url)}; // Needed by JS to connect
     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 state is sent via WebSocket 'initial_state' message now
+    // window.INITIAL_WORLD_OBJECTS not needed here, comes via WebSocket
     console.log("🐍 Streamlit State Injected:", {{ username: window.USERNAME, websocketUrl: window.WEBSOCKET_URL, selectedObject: window.SELECTED_OBJECT_TYPE }});
 </script>"""
             html_content_with_state = html_template.replace('</head>', js_injection_script + '\n</head>', 1)
@@ -889,7 +925,6 @@ def render_main_content():
                 st.session_state.last_message = message_to_send
                 voice = st.session_state.get('tts_voice', DEFAULT_TTS_VOICE)
                 ws_message = json.dumps({"type": "chat_message", "payload": {"username": st.session_state.username, "message": message_to_send, "voice": voice}})
-                # Use run_async for background tasks
                 run_async(broadcast_message, ws_message) # Broadcast Chat via WS
                 run_async(save_chat_entry, st.session_state.username, message_to_send, voice) # Save async
                 add_action_log(f"Sent chat: {message_to_send[:20]}...", emoji="💬")
@@ -915,7 +950,7 @@ def render_main_content():
         st.subheader("💾 World Scroll Management")
         current_file_basename = st.session_state.get('current_world_file', None)
 
-        # Save Current Version Button
+        # Button to save changes to the currently loaded file
         if current_file_basename:
             full_path = os.path.join(SAVED_WORLDS_DIR, current_file_basename)
             save_label = f"Save Changes to '{current_file_basename}'"
@@ -924,25 +959,24 @@ def render_main_content():
                  if not os.path.exists(full_path): st.error(f"❌ Cannot save, file missing.")
                  else:
                      with st.spinner(f"Saving changes to {current_file_basename}..."):
-                         # Save the current state from the cached resource
+                         # Save the state currently held in the cached resource
                          if save_world_state_to_md(current_file_basename):
                              st.success("✅ Current world saved!"); add_action_log(f"Saved world: {current_file_basename}", emoji="💾")
                          else: st.error("❌ Failed to save world state.")
         else: st.info("➡️ Load a world from the sidebar to enable 'Save Changes'.")
 
-        # Save As New Version Section
         st.subheader("✨ Save As New Scroll")
         new_name_files = st.text_input("New Scroll Name:", key="new_world_name_files_tab", value=st.session_state.get('new_world_name', 'MyDreamscape'))
         if st.button("💾 Save Current View as New Scroll", key="save_new_version_files"):
              if new_name_files.strip():
                  with st.spinner(f"Saving new version '{new_name_files}'..."):
                     new_filename_base = generate_world_save_filename(st.session_state.username, new_name_files)
-                    # Save the current state from the cached resource to a NEW file
+                    # Save the state currently held in the cached resource to a NEW file
                     if save_world_state_to_md(new_filename_base):
                          st.success(f"✅ Saved as {new_filename_base}")
                          st.session_state.current_world_file = new_filename_base; st.session_state.new_world_name = "MyDreamscape";
                          add_action_log(f"Saved new world: {new_filename_base}", emoji="✨")
-                         st.rerun()
+                         st.rerun() # Rerun to update sidebar list
                     else: st.error("❌ Failed to save new version.")
              else: st.warning("⚠️ Please enter a name.")
 
@@ -987,9 +1021,8 @@ def render_main_content():
         else:
             st.caption("🌬️ No archives found.")
 
-
 # ==============================================================================
-# Main Execution Logic
+# 10. 🚀 Main Execution Logic
 # ==============================================================================
 
 def initialize_app():
@@ -1001,21 +1034,20 @@ def initialize_app():
         if loaded_user and loaded_user in FUN_USERNAMES: st.session_state.username = loaded_user; st.session_state.tts_voice = FUN_USERNAMES[loaded_user]
         else: st.session_state.username = random.choice(list(FUN_USERNAMES.keys())) if FUN_USERNAMES else "User"; st.session_state.tts_voice = FUN_USERNAMES.get(st.session_state.username, DEFAULT_TTS_VOICE); save_username(st.session_state.username)
 
-    # Ensure WebSocket server thread is running
+    # Start WebSocket server thread if needed
     server_thread = st.session_state.get('server_task'); server_alive = server_thread is not None and server_thread.is_alive()
     if not st.session_state.get('server_running_flag', False) and not server_alive: start_websocket_server_thread()
     elif server_alive and not st.session_state.get('server_running_flag', False): st.session_state.server_running_flag = True
 
     # Trigger the cached resource initialization/retrieval
+    # This ensures the initial state is loaded from file if the resource is created now
     try:
-        manager = get_world_state_manager()
-        # Set initial current_world_file if needed (based on what cache loaded)
-        if st.session_state.get('current_world_file') is None:
-            if manager["state"]: # If the cache loaded state from a file
-                saved_worlds = get_saved_worlds()
-                if saved_worlds:
-                    st.session_state.current_world_file = os.path.basename(saved_worlds[0]['filename'])
-                    print(f"🐍 Set initial session 'current_world_file' to: {st.session_state.current_world_file}")
+        get_world_state_manager()
+        # Set initial current_world_file state if needed (based on what cache loaded)
+        if st.session_state.get('current_world_file') is None and '_initial_world_file_loaded' in st.session_state:
+             st.session_state.current_world_file = st.session_state.pop('_initial_world_file_loaded') # Use and remove temp flag
+             print(f"🐍 Set initial session 'current_world_file' to: {st.session_state.current_world_file}")
+
     except Exception as e:
         st.error(f"❌ Fatal error initializing world state manager: {e}"); st.exception(e); st.stop()