Update app.py

app.py

@@ -1,440 +1,133 @@
 # app.py
 import streamlit as st
-
-# --- Must be the first Streamlit command ---
+# st.set_page_config MUST be the first Streamlit command
 st.set_page_config(page_title="Infinite World Builder", layout="wide")
 
 import streamlit.components.v1 as components
-import os
-import json
-import pandas as pd
-import uuid
-import math
-import time
+import os, json, time, uuid, math
 from datetime import datetime
 
-# Import our GameState class from gamestate.py
-from gamestate import GameState
-
-# --- Constants ---
-SAVE_DIR = "saved_worlds"
-GLOBAL_SAVES_DIR = "global_saves"  # Folder for global game saves
-PLOT_WIDTH = 50.0  # Width of each plot in 3D space
-PLOT_DEPTH = 50.0  # Depth of each plot
-CSV_COLUMNS = ['obj_id', 'type', 'pos_x', 'pos_y', 'pos_z', 'rot_x', 'rot_y', 'rot_z', 'rot_order']
-
-# --- Ensure Required Directories Exist ---
-os.makedirs(SAVE_DIR, exist_ok=True)
-os.makedirs(GLOBAL_SAVES_DIR, exist_ok=True)
-
-# --- Helper Functions for Global Save Management ---
-
-def load_latest_global_save():
-    """
-    Load the JSON file with the most recent timestamp from GLOBAL_SAVES_DIR.
-    Returns None if no global save exists.
-    """
-    json_files = [f for f in os.listdir(GLOBAL_SAVES_DIR) if f.endswith(".json")]
-    if not json_files:
-        return None
-    json_files.sort(reverse=True)
-    latest_file = json_files[0]
-    with open(os.path.join(GLOBAL_SAVES_DIR, latest_file), "r", encoding="utf-8") as f:
-        return json.load(f)
-
-def consolidate_global_saves():
-    """
-    Merge all JSON files in GLOBAL_SAVES_DIR into one consolidated file and delete older ones.
-    The union of game objects (using unique 'obj_id's) is computed.
-    Returns the consolidated state.
-    """
-    json_files = [f for f in os.listdir(GLOBAL_SAVES_DIR) if f.endswith(".json")]
-    if not json_files:
-        return None
-    merged_state = {"timestamp": "", "game_state": [], "player_position": {"x": 0, "y": 0, "z": 0}}
-    obj_dict = {}
-    latest_timestamp = None
-    latest_player_position = {"x": 0, "y": 0, "z": 0}
-    for f in json_files:
-        with open(os.path.join(GLOBAL_SAVES_DIR, f), "r", encoding="utf-8") as file:
-            data = json.load(file)
-            for obj in data.get("game_state", []):
-                obj_id = obj.get("obj_id")
-                if obj_id:
-                    obj_dict[obj_id] = obj
-            file_timestamp = data.get("timestamp")
-            if not latest_timestamp or file_timestamp > latest_timestamp:
-                latest_timestamp = file_timestamp
-                latest_player_position = data.get("player_position", {"x": 0, "y": 0, "z": 0})
-    merged_state["timestamp"] = latest_timestamp if latest_timestamp else time.strftime("%Y-%m-%d %H:%M:%S")
-    merged_state["game_state"] = list(obj_dict.values())
-    merged_state["player_position"] = latest_player_position
-    consolidated_filename = f"consolidated_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-    consolidated_path = os.path.join(GLOBAL_SAVES_DIR, consolidated_filename)
-    with open(consolidated_path, "w", encoding="utf-8") as f:
-        json.dump(merged_state, f, indent=2)
-    # Delete all old JSON files except the newly consolidated one.
-    for f in json_files:
-        try:
-            os.remove(os.path.join(GLOBAL_SAVES_DIR, f))
-        except Exception as e:
-            st.error(f"Error deleting old global save {f}: {e}")
-    return merged_state
+# --- Global State File ---
+GLOBAL_STATE_FILE = "global_state.json"
 
-def perform_global_save():
-    """
-    Immediately save the current game state (with player position) to a new JSON file,
-    then consolidate all global saves and update session state.
-    """
-    global_save_data = {
-         "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
-         "game_state": game_state.get_state(),
-         "player_position": st.session_state.get("player_position", {"x": 0, "y": 0, "z": 0})
+# If the global state file does not exist, create it with an empty state.
+if not os.path.exists(GLOBAL_STATE_FILE):
+    empty_state = {
+        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "game_state": [],  # List of object records
+        "player_position": {"x": 0, "y": 0, "z": 0}
     }
-    default_save_name = f"save_{time.strftime('%Y%m%d_%H%M%S')}.json"
-    save_file_path = os.path.join(GLOBAL_SAVES_DIR, default_save_name)
-    with open(save_file_path, "w", encoding="utf-8") as f:
-         json.dump(global_save_data, f, indent=2)
-    # Consolidate all global saves into one file and update session state.
-    consolidated_state = consolidate_global_saves()
-    if consolidated_state is not None:
-         st.session_state.loaded_global_state = consolidated_state
+    with open(GLOBAL_STATE_FILE, "w", encoding="utf-8") as f:
+        json.dump(empty_state, f, indent=2)
 
-def reload_global_state():
-    """
-    Reload all global save files, consolidate them, and update the game state.
-    """
-    consolidated_state = consolidate_global_saves()
-    if consolidated_state is not None:
-         with game_state.lock:
-             game_state.world_state = consolidated_state.get("game_state", [])
-         st.session_state.player_position = consolidated_state.get("player_position", {"x": 0, "y": 0, "z": 0})
-         st.session_state.loaded_global_state = consolidated_state
-         st.success("Global state reloaded!")
-    else:
-         st.warning("No global save found to reload.")
-
-@st.cache_data(ttl=3600)
-def load_plot_metadata():
-    """Scans SAVE_DIR for plot files and returns metadata."""
-    plots = []
+def load_global_state():
     try:
-        plot_files = [f for f in os.listdir(SAVE_DIR) if f.endswith(".csv") and f.startswith("plot_X")]
-    except FileNotFoundError:
-        st.error(f"Save directory '{SAVE_DIR}' not found.")
-        return []
+        with open(GLOBAL_STATE_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
     except Exception as e:
-        st.error(f"Error listing save directory '{SAVE_DIR}': {e}")
-        return []
+        st.error(f"Error loading global state: {e}")
+        return {"timestamp": time.strftime("%Y-%m-%d %H:%M:%S"), "game_state": [], "player_position": {"x":0, "y":0, "z":0}}
 
-    parsed_plots = []
-    for filename in plot_files:
-        try:
-            parts = filename[:-4].split('_')
-            grid_x = int(parts[1][1:])
-            grid_z = int(parts[2][1:])
-            plot_name = " ".join(parts[3:]) if len(parts) > 3 else f"Plot ({grid_x},{grid_z})"
-            parsed_plots.append({
-                'id': filename[:-4],
-                'filename': filename,
-                'grid_x': grid_x,
-                'grid_z': grid_z,
-                'name': plot_name,
-                'x_offset': grid_x * PLOT_WIDTH,
-                'z_offset': grid_z * PLOT_DEPTH
-            })
-        except (IndexError, ValueError):
-            st.warning(f"Could not parse grid coordinates from filename: {filename}. Skipping.")
-            continue
-
-    parsed_plots.sort(key=lambda p: (p['grid_x'], p['grid_z']))
-    return parsed_plots
-
-def load_plot_objects(filename, x_offset, z_offset):
-    """Loads objects from a CSV file and applies world offsets."""
-    file_path = os.path.join(SAVE_DIR, filename)
-    objects = []
+def save_global_state(state):
     try:
-        df = pd.read_csv(file_path)
-        if not all(col in df.columns for col in ['type', 'pos_x', 'pos_y', 'pos_z']):
-            st.warning(f"CSV '{filename}' missing essential columns. Skipping.")
-            return []
-        df['obj_id'] = df.get('obj_id', pd.Series([str(uuid.uuid4()) for _ in range(len(df))]))
-        for col, default in [('rot_x', 0.0), ('rot_y', 0.0), ('rot_z', 0.0), ('rot_order', 'XYZ')]:
-            if col not in df.columns:
-                df[col] = default
-
-        for _, row in df.iterrows():
-            obj_data = row.to_dict()
-            obj_data['pos_x'] += x_offset
-            obj_data['pos_z'] += z_offset
-            objects.append(obj_data)
-        return objects
-    except FileNotFoundError:
-        st.error(f"File not found during object load: {filename}")
-        return []
-    except pd.errors.EmptyDataError:
-        return []
+        with open(GLOBAL_STATE_FILE, "w", encoding="utf-8") as f:
+            json.dump(state, f, indent=2)
     except Exception as e:
-        st.error(f"Error loading objects from {filename}: {e}")
-        return []
+        st.error(f"Error saving global state: {e}")
 
-def save_plot_data(filename, objects_data_list, plot_x_offset, plot_z_offset):
-    """Saves object data list to a CSV file, making positions relative to the plot origin."""
-    file_path = os.path.join(SAVE_DIR, filename)
-    relative_objects = []
-    if not isinstance(objects_data_list, list):
-        st.error("Invalid data format received for saving (expected a list).")
-        return False
+# --- Initialize global state in session_state ---
+if "global_state" not in st.session_state:
+    st.session_state["global_state"] = load_global_state()
 
-    for obj in objects_data_list:
-        pos = obj.get('position', {})
-        rot = obj.get('rotation', {})
-        obj_type = obj.get('type', 'Unknown')
-        obj_id = obj.get('obj_id', str(uuid.uuid4()))
-
-        if not all(k in pos for k in ['x', 'y', 'z']) or obj_type == 'Unknown':
-            print(f"Skipping malformed object during save prep: {obj}")
-            continue
-
-        relative_obj = {
-            'obj_id': obj_id,
-            'type': obj_type,
-            'pos_x': pos.get('x', 0.0) - plot_x_offset,
-            'pos_y': pos.get('y', 0.0),
-            'pos_z': pos.get('z', 0.0) - plot_z_offset,
-            'rot_x': rot.get('_x', 0.0),
-            'rot_y': rot.get('_y', 0.0),
-            'rot_z': rot.get('_z', 0.0),
-            'rot_order': rot.get('_order', 'XYZ')
-        }
-        relative_objects.append(relative_obj)
-
-    try:
-        df = pd.DataFrame(relative_objects, columns=CSV_COLUMNS)
-        df.to_csv(file_path, index=False)
-        st.success(f"Saved {len(relative_objects)} objects to {filename}")
-        return True
-    except Exception as e:
-        st.error(f"Failed to save plot data to {filename}: {e}")
-        return False
-
-# --- Initialize GameState Singleton ---
-@st.cache_resource
-def get_game_state():
-    return GameState(save_dir=SAVE_DIR, csv_filename="world_state.csv")
-
-game_state = get_game_state()
-
-# --- Session State Initialization ---
-if 'selected_object' not in st.session_state:
-    st.session_state.selected_object = 'None'
-if 'new_plot_name' not in st.session_state:
-    st.session_state.new_plot_name = ""
-if 'js_save_data_result' not in st.session_state:
-    st.session_state.js_save_data_result = None
-if 'player_position' not in st.session_state:
-    st.session_state.player_position = {"x": 0, "y": 0, "z": 0}
-if 'loaded_global_state' not in st.session_state:
-    st.session_state.loaded_global_state = None
-
-# --- On Client Start: Load Latest Global Save if Available ---
-latest_global_save = load_latest_global_save()
-if latest_global_save is not None:
-    with game_state.lock:
-        game_state.world_state = latest_global_save.get("game_state", [])
-    st.session_state.player_position = latest_global_save.get("player_position", {"x": 0, "y": 0, "z": 0})
-    st.session_state.loaded_global_state = latest_global_save
-
-plots_metadata = load_plot_metadata()
-all_initial_objects = []
-for plot in plots_metadata:
-    all_initial_objects.extend(load_plot_objects(plot['filename'], plot['x_offset'], plot['z_offset']))
-
-# If GameState is empty, update it with initial objects.
-if not game_state.get_state():
-    game_state.update_state(all_initial_objects)
-
-# --- Sidebar ---
+# --- Utility: Update Global State with New Objects ---
+def add_objects_to_global(new_objects, player_position):
+    """
+    Merge new object records into the global state.
+    Each object is expected to have a unique 'obj_id'. If not, one is generated.
+    """
+    state = st.session_state["global_state"]
+    # Create dictionary of existing objects by obj_id
+    existing = {obj["obj_id"]: obj for obj in state.get("game_state", []) if "obj_id" in obj}
+    for obj in new_objects:
+        obj_id = obj.get("obj_id", str(uuid.uuid4()))
+        obj["obj_id"] = obj_id
+        existing[obj_id] = obj
+    state["game_state"] = list(existing.values())
+    # Update player position and timestamp (for simplicity, overwrite with latest)
+    state["player_position"] = player_position
+    state["timestamp"] = time.strftime("%Y-%m-%d %H:%M:%S")
+    st.session_state["global_state"] = state
+    save_global_state(state)
+
+# --- Sidebar Controls ---
 with st.sidebar:
     st.title("🏗️ World Controls")
-    st.header("Navigation (Plots)")
-    st.caption("Click to teleport player to a plot.")
-    max_cols = 2
-    cols = st.columns(max_cols)
-    col_idx = 0
-    sorted_plots_for_nav = sorted(plots_metadata, key=lambda p: (p['grid_x'], p['grid_z']))
-    for plot in sorted_plots_for_nav:
-        button_label = f"➡️ {plot.get('name', plot['id'])} ({plot['grid_x']},{plot['grid_z']})"
-        if cols[col_idx].button(button_label, key=f"nav_{plot['id']}"):
-            target_x = plot['x_offset']
-            target_z = plot['z_offset']
-            try:
-                from streamlit_js_eval import streamlit_js_eval
-                js_code = f"teleportPlayer({target_x + PLOT_WIDTH/2}, {target_z + PLOT_DEPTH/2});"
-                streamlit_js_eval(js_code=js_code, key=f"teleport_{plot['id']}")
-            except Exception as e:
-                st.error(f"Failed to send teleport command: {e}")
-        col_idx = (col_idx + 1) % max_cols
-
-    st.markdown("---")
-    st.header("Place Objects")
-    object_types = ["None", "Simple House", "Tree", "Rock", "Fence Post"]
-    current_object_index = object_types.index(st.session_state.selected_object) if st.session_state.selected_object in object_types else 0
-    selected_object_type_widget = st.selectbox("Select Object:", options=object_types, index=current_object_index, key="selected_object_widget")
-    if selected_object_type_widget != st.session_state.selected_object:
-         st.session_state.selected_object = selected_object_type_widget
-
-    st.markdown("---")
-    st.header("Save Work (Per Plot)")
-    st.caption("Saves newly placed objects to the current plot.")
-    if st.button("💾 Save Current Work", key="save_button"):
-        from streamlit_js_eval import streamlit_js_eval
-        js_get_data_code = "getSaveDataAndPosition();"
-        streamlit_js_eval(js_code=js_get_data_code, key="js_save_processor")
-        st.rerun()
-
-    st.markdown("---")
-    st.header("Global Save & Load")
-    if st.button("💾 Global Save"):
-        global_save_data = {
-             "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
-             "game_state": game_state.get_state(),
-             "player_position": st.session_state.get("player_position", {"x": 0, "y": 0, "z": 0})
-        }
-        default_save_name = f"save_{time.strftime('%Y%m%d_%H%M%S')}.json"
-        save_file_path = os.path.join(GLOBAL_SAVES_DIR, default_save_name)
-        with open(save_file_path, "w", encoding="utf-8") as f:
-             json.dump(global_save_data, f, indent=2)
-        st.success(f"Global state saved to {default_save_name}")
-        st.session_state.loaded_global_state = global_save_data
-        perform_global_save()
-
+    # Button to force reload global state from file.
     if st.button("🔄 Reload Global State"):
-        reload_global_state()
-
-    st.subheader("📂 Global Saves")
-    save_files = sorted([f for f in os.listdir(GLOBAL_SAVES_DIR) if f.endswith(".json")])
-    for file in save_files:
-        if st.button(f"Load {file}", key=file):
-            file_path = os.path.join(GLOBAL_SAVES_DIR, file)
-            with open(file_path, "r", encoding="utf-8") as f:
-                loaded_save = json.load(f)
-            with game_state.lock:
-                game_state.world_state = loaded_save.get("game_state", [])
-            st.session_state.player_position = loaded_save.get("player_position", {"x": 0, "y": 0, "z": 0})
-            st.session_state.loaded_global_state = loaded_save
-            st.success(f"Global state loaded from {file}")
+        st.session_state["global_state"] = load_global_state()
+        st.success("Global state reloaded.")
+    # Button to clear the global state.
+    if st.button("🗑️ Clear Global State"):
+        empty = {
+            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+            "game_state": [],
+            "player_position": {"x": 0, "y": 0, "z": 0}
+        }
+        st.session_state["global_state"] = empty
+        save_global_state(empty)
+        st.success("Global state cleared.")
 
     st.markdown("---")
     st.header("Download Global Save as Markdown")
-    current_save = st.session_state.get("loaded_global_state")
-    if current_save is None:
-        current_save = {"timestamp": "N/A", "game_state": [], "player_position": {"x": 0, "y": 0, "z": 0}}
-    default_md_name = current_save.get("timestamp", "save").replace(":", "").replace(" ", "_") + ".md"
+    state = st.session_state["global_state"]
+    default_md_name = state.get("timestamp", "save").replace(":", "").replace(" ", "_") + ".md"
     download_name = st.text_input("Override File Name", value=default_md_name)
-    if st.button("Generate Markdown & Download"):
-        md_outline = f"""# Global Save: {download_name}
-- ⏰ **Timestamp:** {current_save.get("timestamp", "N/A")}
-- 🎮 **Number of Game Objects:** {len(current_save.get("game_state", []))}
-- 🧭 **Player Position:** {current_save.get("player_position", {"x": 0, "y": 0, "z": 0})}
+    md_outline = f"""# Global Save: {download_name}
+- ⏰ **Timestamp:** {state.get("timestamp", "N/A")}
+- 🎮 **Number of Game Objects:** {len(state.get("game_state", []))}
+- 🧭 **Player Position:** {state.get("player_position", {"x":0, "y":0, "z":0})}
 
 ## Game Objects:
 """
-        for i, obj in enumerate(current_save.get("game_state", []), start=1):
-            obj_type = obj.get("type", "Unknown")
-            pos = (obj.get("pos_x", 0), obj.get("pos_y", 0), obj.get("pos_z", 0))
-            md_outline += f"- {i}. ✨ **{obj_type}** at {pos}\n"
-        st.download_button("Download Markdown Save", data=md_outline, file_name=download_name, mime="text/markdown")
-
-# --- Process Save Data from JS (Per Plot Save) ---
-save_data_from_js = st.session_state.get("js_save_processor", None)
-if save_data_from_js is not None:
-    st.info("Received save data from client...")
-    save_processed_successfully = False
+    for i, obj in enumerate(state.get("game_state", []), start=1):
+        obj_type = obj.get("type", "Unknown")
+        pos = (obj.get("x", 0), obj.get("y", 0), obj.get("z", 0))
+        md_outline += f"- {i}. ✨ **{obj_type}** at {pos}\n"
+    st.download_button("Download Markdown Save", data=md_outline, file_name=download_name, mime="text/markdown")
+
+# --- Process Save Data from JavaScript ---
+# The JS component will set st.session_state["js_save_data"] to a JSON string when an object is placed.
+save_data_from_js = st.session_state.get("js_save_data", None)
+if save_data_from_js:
     try:
         payload = json.loads(save_data_from_js) if isinstance(save_data_from_js, str) else save_data_from_js
-        if isinstance(payload, dict) and 'playerPosition' in payload and 'objectsToSave' in payload:
-            player_pos = payload['playerPosition']
-            objects_to_save = payload['objectsToSave']
-            if isinstance(objects_to_save, list):
-                target_grid_x = math.floor(player_pos.get('x', 0.0) / PLOT_WIDTH)
-                target_grid_z = math.floor(player_pos.get('z', 0.0) / PLOT_DEPTH)
-                target_filename = f"plot_X{target_grid_x}_Z{target_grid_z}.csv"
-                target_plot_x_offset = target_grid_x * PLOT_WIDTH
-                target_plot_z_offset = target_grid_z * PLOT_DEPTH
-                st.write(f"Attempting to save plot: {target_filename} (Player at: x={player_pos.get('x', 0):.1f}, z={player_pos.get('z', 0):.1f})")
-                is_new_plot_file = not os.path.exists(os.path.join(SAVE_DIR, target_filename))
-                save_ok = save_plot_data(target_filename, objects_to_save, target_plot_x_offset, target_plot_z_offset)
-                if save_ok:
-                    load_plot_metadata.clear()  # Clear cache so metadata reloads
-                    try:
-                        from streamlit_js_eval import streamlit_js_eval
-                        streamlit_js_eval(js_code="resetNewlyPlacedObjects();", key="reset_js_state")
-                    except Exception as js_e:
-                        st.warning(f"Could not reset JS state after save: {js_e}")
-                    if is_new_plot_file:
-                        st.success(f"New plot created and saved: {target_filename}")
-                    else:
-                        st.success(f"Updated existing plot: {target_filename}")
-                    game_state.update_state(objects_to_save)
-                    save_processed_successfully = True
-                    perform_global_save()
-                else:
-                    st.error(f"Failed to save plot data to file: {target_filename}")
-            else:
-                st.error("Invalid 'objectsToSave' format received (expected list).")
-        else:
-            st.error("Invalid save payload structure received from client.")
-    except json.JSONDecodeError:
-        st.error("Failed to decode save data from client.")
+        if isinstance(payload, dict) and "playerPosition" in payload and "objectsToSave" in payload:
+            player_pos = payload["playerPosition"]
+            objects = payload["objectsToSave"]
+            add_objects_to_global(objects, player_pos)
+            st.success("Global state updated with new objects.")
+            st.session_state["js_save_data"] = None
+            st.experimental_rerun()
     except Exception as e:
-        st.error(f"Error processing save: {e}")
-    st.session_state.js_save_processor = None
-    if save_processed_successfully:
-        st.rerun()
-
-# --- Main Area ---
-st.header("Infinite Shared 3D World")
-st.caption("Move to empty areas to expand the world. Use the sidebar 'Save' controls to store your work.")
+        st.error(f"Error processing JS save data: {e}")
+        st.session_state["js_save_data"] = None
 
-# Inject state into JS—including the shared GAME_STATE from our GameState singleton.
+# --- Inject Global State into JavaScript ---
 injected_state = {
-    "ALL_INITIAL_OBJECTS": all_initial_objects,
-    "PLOTS_METADATA": plots_metadata,
-    "SELECTED_OBJECT_TYPE": st.session_state.selected_object,
-    "PLOT_WIDTH": PLOT_WIDTH,
-    "PLOT_DEPTH": PLOT_DEPTH,
-    "GAME_STATE": game_state.get_state()
+    "GLOBAL_STATE": st.session_state["global_state"]
 }
-
-html_file_path = 'index.html'
-html_content_with_state = None
-
+html_file_path = "index.html"
 try:
-    with open(html_file_path, 'r', encoding='utf-8') as f:
+    with open(html_file_path, "r", encoding="utf-8") as f:
         html_template = f.read()
     js_injection_script = f"""
 <script>
-    window.ALL_INITIAL_OBJECTS = {json.dumps(injected_state["ALL_INITIAL_OBJECTS"])};
-    window.PLOTS_METADATA = {json.dumps(injected_state["PLOTS_METADATA"])};
-    window.SELECTED_OBJECT_TYPE = {json.dumps(injected_state["SELECTED_OBJECT_TYPE"])};
-    window.PLOT_WIDTH = {json.dumps(injected_state["PLOT_WIDTH"])};
-    window.PLOT_DEPTH = {json.dumps(injected_state["PLOT_DEPTH"])};
-    window.GAME_STATE = {json.dumps(injected_state["GAME_STATE"])};
-    console.log("Streamlit State Injected:", {{
-        selectedObject: window.SELECTED_OBJECT_TYPE,
-        initialObjectsCount: window.ALL_INITIAL_OBJECTS ? window.ALL_INITIAL_OBJECTS.length : 0,
-        plotCount: window.PLOTS_METADATA ? window.PLOTS_METADATA.length : 0,
-        gameStateObjects: window.GAME_STATE ? window.GAME_STATE.length : 0
-    }});
+    // Inject the global state from Streamlit into the web app.
+    window.GLOBAL_STATE = {json.dumps(injected_state["GLOBAL_STATE"])};
+    console.log("Injected Global State:", window.GLOBAL_STATE);
 </script>
 """
-    html_content_with_state = html_template.replace('</head>', js_injection_script + '\n</head>', 1)
-    components.html(html_content_with_state, height=750, scrolling=False)
-except FileNotFoundError:
-    st.error(f"CRITICAL ERROR: Could not find the file '{html_file_path}'.")
-    st.warning(f"Make sure `{html_file_path}` is in the same directory as `app.py` and `{SAVE_DIR}` exists.")
+    html_content = html_template.replace("</head>", js_injection_script + "\n</head>", 1)
+    components.html(html_content, height=750, scrolling=True)
 except Exception as e:
-    st.error(f"An critical error occurred during HTML preparation or component rendering: {e}")
-    st.exception(e)
+    st.error(f"Error loading index.html: {e}")