diff --git "a/app.py" "b/app.py"
--- "a/app.py"
+++ "b/app.py"
@@ -1,28 +1,26 @@
+
 import os
 import hmac
 import hashlib
 import json
-import shutil
-import threading
-import time
-import uuid
-import logging
-from datetime import datetime
-from io import BytesIO
 from urllib.parse import unquote, parse_qsl, urlencode
-from typing import Union, Optional
-
-import requests
 from flask import Flask, request, jsonify, Response, send_file
 from flask_caching import Cache
+import logging
+import threading
+import time
+from datetime import datetime
 from huggingface_hub import HfApi, hf_hub_download, utils as hf_utils
 from werkzeug.utils import secure_filename
+import requests
+from io import BytesIO
+import uuid
+from typing import Union, Optional, Dict, Any, List, Tuple
 
 app = Flask(__name__)
 app.secret_key = os.getenv("FLASK_SECRET_KEY", "supersecretkey_mini_app_unique_v2")
 BOT_TOKEN = os.getenv('TELEGRAM_BOT_TOKEN', '6750208873:AAE2hvPlJ99dBdhGa_Brre0IIpUdOvXxHt4')
-DATA_FILE = 'cloudeng_mini_app_data.json'
-DATA_FILE_BACKUP = DATA_FILE + '.bak'
+DATA_FILE = 'cloudeng_mini_app_data_v2.json'
 REPO_ID = "Eluza133/Z1e1u"
 HF_TOKEN_WRITE = os.getenv("HF_TOKEN")
 HF_TOKEN_READ = os.getenv("HF_TOKEN_READ") or HF_TOKEN_WRITE
@@ -33,9 +31,10 @@ cache = Cache(app, config={'CACHE_TYPE': 'simple'})
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 AUTH_DATA_LIFETIME = 3600
-data_lock = threading.Lock()
 
-def find_node_by_id(filesystem, node_id):
+# --- Filesystem Utilities ---
+
+def find_node_by_id(filesystem: Dict[str, Any], node_id: str) -> Tuple[Optional[Dict[str, Any]], Optional[Dict[str, Any]]]:
     if not filesystem or not isinstance(filesystem, dict):
         return None, None
     if filesystem.get('id') == node_id:
@@ -46,41 +45,65 @@ def find_node_by_id(filesystem, node_id):
 
     while queue:
         current_node, parent = queue.pop(0)
-        if current_node.get('type') == 'folder' and 'children' in current_node:
-            for child in current_node.get('children', []):
+        node_type = current_node.get('type')
+        children = current_node.get('children')
+
+        if node_type == 'folder' and isinstance(children, list):
+            for child in children:
+                if not isinstance(child, dict): continue
                 child_id = child.get('id')
                 if not child_id: continue
 
                 if child_id == node_id:
                     return child, current_node
-                if child_id not in visited and isinstance(child, dict) and child.get('type') == 'folder':
+
+                if child.get('type') == 'folder' and child_id not in visited:
                     visited.add(child_id)
                     queue.append((child, current_node))
     return None, None
 
-def add_node(filesystem, parent_id, node_data):
+def add_node(filesystem: Dict[str, Any], parent_id: str, node_data: Dict[str, Any]) -> bool:
     parent_node, _ = find_node_by_id(filesystem, parent_id)
     if parent_node and parent_node.get('type') == 'folder':
         if 'children' not in parent_node or not isinstance(parent_node['children'], list):
             parent_node['children'] = []
+
         existing_ids = {child.get('id') for child in parent_node['children'] if isinstance(child, dict)}
-        if node_data.get('id') not in existing_ids:
+        new_node_id = node_data.get('id')
+        if new_node_id and new_node_id not in existing_ids:
             parent_node['children'].append(node_data)
             return True
+        elif not new_node_id:
+             logging.error(f"Attempted to add node without ID to parent {parent_id}")
+        else:
+             logging.warning(f"Node with ID {new_node_id} already exists under parent {parent_id}")
+
+    elif not parent_node:
+        logging.error(f"Parent node {parent_id} not found for adding node.")
+    elif parent_node.get('type') != 'folder':
+        logging.error(f"Cannot add node to non-folder parent {parent_id} (type: {parent_node.get('type')}).")
+
     return False
 
-def remove_node(filesystem, node_id):
+def remove_node(filesystem: Dict[str, Any], node_id: str) -> bool:
+    if node_id == filesystem.get('id'):
+        logging.error("Attempted to remove root node.")
+        return False
+
     node_to_remove, parent_node = find_node_by_id(filesystem, node_id)
-    if node_to_remove and parent_node and 'children' in parent_node and isinstance(parent_node['children'], list):
+
+    if node_to_remove and parent_node and isinstance(parent_node.get('children'), list):
         original_length = len(parent_node['children'])
         parent_node['children'] = [child for child in parent_node['children'] if not isinstance(child, dict) or child.get('id') != node_id]
         return len(parent_node['children']) < original_length
-    if node_to_remove and node_id == filesystem.get('id'):
-        logging.warning("Attempted to remove root node directly.")
-        return False
+    elif node_to_remove and not parent_node:
+         logging.error(f"Found node {node_id} but it has no parent (should not happen except for root).")
+    elif not node_to_remove:
+         logging.warning(f"Node {node_id} not found for removal.")
+
     return False
 
-def get_node_path_list(filesystem, node_id):
+def get_node_path_list(filesystem: Dict[str, Any], node_id: str) -> List[Dict[str, str]]:
     path_list = []
     current_id = node_id
     processed_ids = set()
@@ -91,14 +114,14 @@ def get_node_path_list(filesystem, node_id):
         processed_ids.add(current_id)
         depth += 1
         node, parent = find_node_by_id(filesystem, current_id)
-        if not node or not isinstance(node, dict):
-            logging.warning(f"Path traversal stopped: Node not found or invalid for ID {current_id}")
+        if not node:
+            logging.warning(f"Path traversal broken: Node {current_id} not found.")
             break
-        path_list.append({
-            'id': node.get('id'),
-            'name': node.get('name', node.get('original_filename', 'Unknown'))
-        })
-        if not parent or not isinstance(parent, dict):
+
+        node_name = node.get('name', node.get('original_filename', 'Unknown'))
+        path_list.append({'id': node.get('id'), 'name': node_name})
+
+        if not parent:
              break
         parent_id = parent.get('id')
         if parent_id == current_id:
@@ -106,142 +129,150 @@ def get_node_path_list(filesystem, node_id):
              break
         current_id = parent_id
 
-    if not any(p['id'] == 'root' for p in path_list) and filesystem and filesystem.get('id') == 'root':
-         path_list.append({'id': 'root', 'name': filesystem.get('name','Root')})
+    if depth >= max_depth:
+        logging.error(f"Max path depth reached for node {node_id}. Returning partial path.")
+
+    # Ensure root is always present if not found during traversal
+    if not any(p['id'] == 'root' for p in path_list):
+         # Check if filesystem itself is the root
+         root_node, _ = find_node_by_id(filesystem, 'root')
+         if root_node:
+            path_list.append({'id': 'root', 'name': root_node.get('name', 'Root')})
+         else:
+             # Fallback if even the root node lookup fails
+             path_list.append({'id': 'root', 'name': 'Root'})
+
 
     final_path = []
     seen_ids = set()
     for item in reversed(path_list):
-         if item['id'] not in seen_ids:
+         item_id = item.get('id')
+         if item_id and item_id not in seen_ids:
               final_path.append(item)
-              seen_ids.add(item['id'])
-    if not final_path or final_path[0]['id'] != 'root':
-        final_path.insert(0, {'id': 'root', 'name': filesystem.get('name','Root') if filesystem else 'Root'})
+              seen_ids.add(item_id)
 
-    return final_path
+    # If the final path is empty or doesn't start with root, force root at the beginning
+    if not final_path or final_path[0].get('id') != 'root':
+        root_node, _ = find_node_by_id(filesystem, 'root')
+        root_name = root_node.get('name', 'Root') if root_node else 'Root'
+        final_path.insert(0, {'id': 'root', 'name': root_name})
+        # Remove potential duplicate roots further down
+        final_path = [p for i, p in enumerate(final_path) if p.get('id') != 'root' or i == 0]
 
 
-def initialize_user_filesystem(user_data):
-    if 'filesystem' not in user_data or not isinstance(user_data.get('filesystem'), dict) or not user_data['filesystem'].get('id') == 'root':
-        logging.warning(f"Initializing/Resetting filesystem for user.")
+    return final_path
+
+def initialize_user_filesystem(user_data: Dict[str, Any]):
+    if 'filesystem' not in user_data or not isinstance(user_data['filesystem'], dict) or user_data['filesystem'].get('id') != 'root':
         user_data['filesystem'] = {
             "type": "folder",
             "id": "root",
             "name": "Root",
             "children": []
         }
-    elif 'children' not in user_data['filesystem'] or not isinstance(user_data['filesystem']['children'], list):
-         user_data['filesystem']['children'] = []
 
+# --- Data Loading/Saving ---
 
-def load_data_from_file(filepath):
+@cache.memoize(timeout=60)
+def load_data() -> Dict[str, Any]:
     try:
-        with open(filepath, 'r', encoding='utf-8') as file:
+        download_db_from_hf()
+        if not os.path.exists(DATA_FILE) or os.path.getsize(DATA_FILE) == 0:
+             logging.warning(f"{DATA_FILE} is missing or empty after download attempt. Initializing.")
+             return {'users': {}}
+
+        with open(DATA_FILE, 'r', encoding='utf-8') as file:
             data = json.load(file)
             if not isinstance(data, dict):
-                logging.warning(f"Data file {filepath} is not a dict, treating as invalid.")
-                return None
+                logging.error(f"Data file {DATA_FILE} is not a dict. Initializing empty.")
+                return {'users': {}}
+
             data.setdefault('users', {})
-            for user_id, user_data in data['users'].items():
-                 if isinstance(user_data, dict):
-                    initialize_user_filesystem(user_data)
-                 else:
-                    logging.warning(f"Invalid user_data structure for user {user_id} in {filepath}, skipping.")
-            logging.info(f"Data loaded successfully from {filepath}.")
+            if not isinstance(data['users'], dict):
+                 logging.error(f"'users' key in {DATA_FILE} is not a dict. Resetting.")
+                 data['users'] = {}
+
+            for user_id, user_data in list(data['users'].items()): # Use list to allow modification
+                if not isinstance(user_data, dict):
+                    logging.warning(f"Invalid data type for user {user_id}. Removing entry.")
+                    del data['users'][user_id]
+                    continue
+                initialize_user_filesystem(user_data)
+
+            logging.info(f"Data loaded successfully from {DATA_FILE}.")
             return data
     except FileNotFoundError:
-        logging.info(f"{filepath} not found locally.")
-        return None
-    except json.JSONDecodeError:
-        logging.error(f"Error decoding JSON from {filepath}.")
-        return None
+        logging.warning(f"{DATA_FILE} not found locally. Initializing empty data.")
+        return {'users': {}}
+    except json.JSONDecodeError as e:
+        logging.error(f"Error decoding JSON from {DATA_FILE}: {e}. Returning empty data.")
+        # Potentially try to recover from backup or previous version here if needed
+        return {'users': {}}
     except Exception as e:
-        logging.error(f"Error loading data from {filepath}: {e}")
-        return None
-
-@cache.memoize(timeout=60)
-def load_data():
-    with data_lock:
-        data = None
-        primary_exists = os.path.exists(DATA_FILE)
-        backup_exists = os.path.exists(DATA_FILE_BACKUP)
-
-        if primary_exists:
-            data = load_data_from_file(DATA_FILE)
-
-        if data is None and backup_exists:
-            logging.warning(f"Primary data file {DATA_FILE} failed to load or missing, attempting backup.")
-            data = load_data_from_file(DATA_FILE_BACKUP)
-            if data:
-                logging.info("Loaded data from backup. Attempting to restore primary file.")
-                try:
-                    shutil.copy2(DATA_FILE_BACKUP, DATA_FILE)
-                except Exception as e:
-                    logging.error(f"Failed to restore primary file from backup: {e}")
-
-        if data is None:
-            logging.warning("Both primary and backup data files failed to load or missing. Attempting download from HF.")
-            download_success = download_db_from_hf()
-            if download_success:
-                 data = load_data_from_file(DATA_FILE)
-
-        if data is None:
-            logging.critical("CRITICAL: Could not load data from local files or HF. Initializing empty data structure.")
-            data = {'users': {}}
+        logging.error(f"Unexpected error loading data: {e}", exc_info=True)
+        return {'users': {}}
 
-        return data
-
-
-def save_data(data):
-    with data_lock:
-        try:
-            if os.path.exists(DATA_FILE):
-                try:
-                    shutil.copy2(DATA_FILE, DATA_FILE_BACKUP)
-                    logging.info(f"Created backup: {DATA_FILE_BACKUP}")
-                except Exception as backup_err:
-                     logging.error(f"Failed to create backup file {DATA_FILE_BACKUP}: {backup_err}")
-
-            with open(DATA_FILE, 'w', encoding='utf-8') as file:
-                json.dump(data, file, ensure_ascii=False, indent=2) # Use indent=2 for smaller file size
-
-            logging.info(f"Data saved locally to {DATA_FILE}")
-            cache.clear()
-            upload_db_to_hf()
-            return True
-
-        except Exception as e:
-            logging.error(f"CRITICAL: Error saving data to {DATA_FILE}: {e}")
-            return False
+def save_data(data: Dict[str, Any]):
+    temp_file = DATA_FILE + ".tmp"
+    try:
+        with open(temp_file, 'w', encoding='utf-8') as file:
+            json.dump(data, file, ensure_ascii=False, indent=4)
+        os.replace(temp_file, DATA_FILE)
+        cache.clear()
+        logging.info(f"Data saved successfully to {DATA_FILE}.")
+        # Trigger async upload AFTER successful local save
+        upload_db_to_hf_async()
+    except Exception as e:
+        logging.error(f"Error saving data to {DATA_FILE}: {e}", exc_info=True)
+        if os.path.exists(temp_file):
+            try:
+                os.remove(temp_file)
+            except OSError as rm_err:
+                logging.error(f"Failed to remove temporary save file {temp_file}: {rm_err}")
+        # Re-raise the exception to signal failure to the caller
+        raise RuntimeError(f"Failed to save data: {e}") from e
 
-def upload_db_to_hf():
+def upload_db_to_hf_async():
     if not HF_TOKEN_WRITE:
         logging.warning("HF_TOKEN_WRITE not set, skipping database upload.")
         return
-    if not os.path.exists(DATA_FILE):
-         logging.warning(f"Local data file {DATA_FILE} not found for upload.")
-         return
-    try:
-        api = HfApi()
-        api.upload_file(
-            path_or_fileobj=DATA_FILE,
-            path_in_repo=DATA_FILE,
-            repo_id=REPO_ID,
-            repo_type="dataset",
-            token=HF_TOKEN_WRITE,
-            commit_message=f"Backup MiniApp {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
-            run_as_future=True
-        )
-        logging.info("Database upload to Hugging Face scheduled.")
-    except Exception as e:
-        logging.error(f"Error scheduling database upload: {e}")
+    thread = threading.Thread(target=upload_db_to_hf_sync, daemon=True)
+    thread.start()
+    logging.info("Database upload to Hugging Face initiated in background.")
 
+def upload_db_to_hf_sync():
+    retries = 3
+    for attempt in range(retries):
+        try:
+            api = HfApi()
+            api.upload_file(
+                path_or_fileobj=DATA_FILE,
+                path_in_repo=DATA_FILE,
+                repo_id=REPO_ID,
+                repo_type="dataset",
+                token=HF_TOKEN_WRITE,
+                commit_message=f"Backup MiniApp {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+            )
+            logging.info(f"Database upload to Hugging Face completed (attempt {attempt + 1}).")
+            return
+        except Exception as e:
+            logging.error(f"Error during database upload (attempt {attempt + 1}/{retries}): {e}")
+            if attempt < retries - 1:
+                time.sleep(5 * (attempt + 1)) # Exponential backoff
+            else:
+                logging.error("Database upload failed after multiple retries.")
 
 def download_db_from_hf():
     if not HF_TOKEN_READ:
-        logging.warning("HF_TOKEN_READ not set, skipping database download.")
-        return False
+        logging.warning("HF_TOKEN_READ not set, skipping database download. Using local version if available.")
+        if not os.path.exists(DATA_FILE):
+             logging.info(f"Local {DATA_FILE} not found. Creating empty database.")
+             with open(DATA_FILE, 'w', encoding='utf-8') as f:
+                 json.dump({'users': {}}, f)
+        return
+
     try:
+        logging.info(f"Attempting to download {DATA_FILE} from {REPO_ID}...")
         hf_hub_download(
             repo_id=REPO_ID,
             filename=DATA_FILE,
@@ -249,46 +280,50 @@ def download_db_from_hf():
             token=HF_TOKEN_READ,
             local_dir=".",
             local_dir_use_symlinks=False,
-            force_download=True,
-            etag_timeout=10
+            force_download=True, # Ensure we get the latest version
+            etag_timeout=15 # Increase timeout slightly
         )
-        logging.info(f"Database downloaded from Hugging Face to {DATA_FILE}")
-        return True
+        logging.info("Database downloaded successfully from Hugging Face.")
     except hf_utils.RepositoryNotFoundError:
-         logging.error(f"Repository {REPO_ID} not found on Hugging Face.")
-         return False
+         logging.error(f"Hugging Face repository {REPO_ID} not found. Using local data.")
+         if not os.path.exists(DATA_FILE):
+             with open(DATA_FILE, 'w', encoding='utf-8') as f: json.dump({'users': {}}, f)
     except hf_utils.EntryNotFoundError:
-        logging.warning(f"{DATA_FILE} not found in repo {REPO_ID}. No file downloaded.")
-        return False
+        logging.warning(f"{DATA_FILE} not found in repo {REPO_ID}. Using/creating local file.")
+        if not os.path.exists(DATA_FILE):
+            with open(DATA_FILE, 'w', encoding='utf-8') as f: json.dump({'users': {}}, f)
     except requests.exceptions.ConnectionError as e:
          logging.error(f"Connection error downloading DB from HF: {e}. Using local version if available.")
-         return False
+    except requests.exceptions.Timeout:
+        logging.error("Timeout occurred while downloading DB from HF. Using local version.")
     except Exception as e:
-        logging.error(f"Generic error downloading database from HF: {e}")
-        return False
+        logging.error(f"Unexpected error downloading database from HF: {e}", exc_info=True)
+        if not os.path.exists(DATA_FILE):
+             logging.warning(f"Creating empty local {DATA_FILE} due to download error.")
+             with open(DATA_FILE, 'w', encoding='utf-8') as f: json.dump({'users': {}}, f)
 
-
-def get_file_type(filename):
+# --- File Type Helper ---
+def get_file_type(filename: Optional[str]) -> str:
     if not filename or '.' not in filename: return 'other'
     ext = filename.lower().split('.')[-1]
-    if ext in ['mp4', 'mov', 'avi', 'webm', 'mkv', 'm4v', 'wmv', 'flv']: return 'video'
-    if ext in ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp', 'svg', 'heic', 'heif']: return 'image'
+    if ext in ['mp4', 'mov', 'avi', 'webm', 'mkv', 'wmv', 'flv']: return 'video'
+    if ext in ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp', 'svg', 'heic', 'avif']: return 'image'
     if ext == 'pdf': return 'pdf'
-    if ext in ['txt', 'md', 'log', 'csv', 'json', 'xml', 'html', 'css', 'js', 'py', 'java', 'c', 'cpp', 'go', 'rs']: return 'text'
-    if ext in ['mp3', 'wav', 'ogg', 'flac', 'aac', 'm4a']: return 'audio'
+    if ext in ['txt', 'md', 'log', 'csv', 'json', 'xml', 'html', 'css', 'js', 'py', 'c', 'cpp', 'java']: return 'text'
+    if ext in ['mp3', 'wav', 'ogg', 'aac', 'flac', 'm4a']: return 'audio'
     if ext in ['zip', 'rar', '7z', 'tar', 'gz']: return 'archive'
-    if ext in ['doc', 'docx', 'ppt', 'pptx', 'xls', 'xlsx', 'odt', 'odp', 'ods']: return 'document'
+    if ext in ['doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx']: return 'document'
     return 'other'
 
-
-def check_telegram_authorization(auth_data: str, bot_token: str) -> Optional[dict]:
+# --- Telegram Validation ---
+def check_telegram_authorization(auth_data: str, bot_token: str) -> Optional[Dict[str, Any]]:
     if not auth_data or not bot_token or bot_token == 'YOUR_BOT_TOKEN':
-        logging.warning("Validation skipped: Missing auth_data or valid BOT_TOKEN.")
-        return None
+        logging.debug("Validation skipped: Missing auth_data or valid BOT_TOKEN.")
+        return None # Return None, not False
     try:
         parsed_data = dict(parse_qsl(unquote(auth_data)))
         if "hash" not in parsed_data:
-            logging.error("Hash not found in auth data")
+            logging.warning("Hash not found in auth data")
             return None
 
         telegram_hash = parsed_data.pop('hash')
@@ -296,22 +331,24 @@ def check_telegram_authorization(auth_data: str, bot_token: str) -> Optional[dic
         current_ts = int(time.time())
 
         if abs(current_ts - auth_date_ts) > AUTH_DATA_LIFETIME:
-             logging.warning(f"Auth data expired (Auth: {auth_date_ts}, Now: {current_ts}, Diff: {current_ts - auth_date_ts})")
+             logging.warning(f"Auth data expired (Auth: {auth_date_ts}, Now: {current_ts}, Diff: {current_ts - auth_date_ts}, Lifetime: {AUTH_DATA_LIFETIME})")
              return None
 
         data_check_string = "\n".join(sorted([f"{k}={v}" for k, v in parsed_data.items()]))
         secret_key = hmac.new("WebAppData".encode(), bot_token.encode(), hashlib.sha256).digest()
         calculated_hash = hmac.new(secret_key, data_check_string.encode(), hashlib.sha256).hexdigest()
 
-        if calculated_hash == telegram_hash:
+        if hmac.compare_digest(calculated_hash, telegram_hash):
             user_data_str = parsed_data.get('user')
             if user_data_str:
                 try:
                     user_info = json.loads(user_data_str)
-                    if 'id' not in user_info:
-                         logging.error("Validated user data missing 'id'")
+                    if isinstance(user_info, dict) and 'id' in user_info:
+                        logging.info(f"Telegram auth successful for user ID: {user_info['id']}")
+                        return user_info
+                    else:
+                         logging.error(f"Validated user data is not a dict or missing 'id': {user_data_str}")
                          return None
-                    return user_info
                 except json.JSONDecodeError:
                     logging.error("Failed to decode user JSON from auth data")
                     return None
@@ -319,13 +356,13 @@ def check_telegram_authorization(auth_data: str, bot_token: str) -> Optional[dic
                 logging.warning("No 'user' field in validated auth data")
                 return None
         else:
-            logging.warning("Hash mismatch during validation")
+            logging.warning(f"Hash mismatch during validation. Received: {telegram_hash}, Calculated: {calculated_hash}")
             return None
     except Exception as e:
-        logging.error(f"Exception during validation: {e}")
+        logging.error(f"Exception during Telegram validation: {e}", exc_info=True)
         return None
 
-
+# --- HTML, CSS, JS Template ---
 HTML_TEMPLATE = """
 <!DOCTYPE html>
 <html lang="ru">
@@ -334,205 +371,467 @@ HTML_TEMPLATE = """
     <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover">
     <title>Zeus Cloud</title>
     <script src="https://telegram.org/js/telegram-web-app.js"></script>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=SF+Pro+Display:wght@400;600;700&display=swap" rel="stylesheet">
     <style>
         :root {
-            --tg-theme-bg-color: var(--tg-bg-color, #ffffff);
+            --tg-theme-bg-color: var(--tg-bg-color, #f0f0f0);
             --tg-theme-text-color: var(--tg-text-color, #000000);
-            --tg-theme-hint-color: var(--tg-hint-color, #999999);
+            --tg-theme-hint-color: var(--tg-hint-color, #aaaaaa);
             --tg-theme-link-color: var(--tg-link-color, #007aff);
             --tg-theme-button-color: var(--tg-button-color, #007aff);
             --tg-theme-button-text-color: var(--tg-button-text-color, #ffffff);
-            --tg-theme-secondary-bg-color: var(--tg-secondary-bg-color, #f0f0f0);
-            --tg-theme-header-bg-color: var(--tg-header-bg-color, #ffffff);
+            --tg-theme-secondary-bg-color: var(--tg-secondary-bg-color, #ffffff);
             --tg-viewport-height: var(--tg-viewport-stable-height, 100vh);
-            --border-color: rgba(60, 60, 67, 0.29);
-            --destructive-color: #ff3b30;
+            --border-radius-s: 8px;
+            --border-radius-m: 12px;
+            --border-radius-l: 16px;
+            --system-red: #ff3b30;
             --system-blue: #007aff;
+            --system-green: #34c759;
+            --system-yellow: #ffcc00;
             --system-gray: #8e8e93;
-            --system-gray-2: #aeaeb2;
-            --system-gray-4: #d1d1d6;
-            --system-gray-5: #e5e5ea;
-            --system-gray-6: #f2f2f7;
+            --system-gray-light: #c7c7cc;
+            --system-gray-ultralight: #f2f2f7; /* approx */
+            --padding-base: 16px;
+        }
+        html {
+            box-sizing: border-box;
+            -webkit-text-size-adjust: 100%;
+        }
+        *, *:before, *:after {
+            box-sizing: inherit;
+            -webkit-tap-highlight-color: transparent;
         }
-        @supports (background: -webkit-canvas(squares)) { :root { --tg-theme-bg-color: #ffffff; } }
-        @supports (background: -webkit-canvas(squares)) { :root[style*="color-scheme: dark"] { --tg-theme-bg-color: #000000; } }
-
-        html { box-sizing: border-box; -webkit-text-size-adjust: none; }
-        *, *:before, *:after { box-sizing: inherit; }
-
         body {
-            font-family: -apple-system, BlinkMacSystemFont, 'Helvetica Neue', Inter, sans-serif;
+            font-family: 'SF Pro Display', -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
             background-color: var(--tg-theme-bg-color);
             color: var(--tg-theme-text-color);
             line-height: 1.4;
             margin: 0;
-            padding: 0;
+            padding: 0; /* Remove default padding, rely on container */
             min-height: var(--tg-viewport-height);
             display: flex;
             flex-direction: column;
+            font-size: 16px;
             -webkit-font-smoothing: antialiased;
             -moz-osx-font-smoothing: grayscale;
-            overscroll-behavior-y: none;
-            padding-bottom: env(safe-area-inset-bottom);
+            overscroll-behavior-y: none; /* Prevent pull-to-refresh */
+        }
+        .app-container {
+            width: 100%;
+            flex-grow: 1;
+            display: flex;
+            flex-direction: column;
+            padding: 0 var(--padding-base) var(--padding-base);
         }
-        .container {
-             width: 100%;
-             flex-grow: 1;
-             display: flex;
-             flex-direction: column;
-             padding: 16px;
-             padding-top: 0;
+        #loading, #error-view {
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            flex-direction: column;
+            text-align: center;
+            padding: 40px var(--padding-base);
+            flex-grow: 1;
+            color: var(--tg-theme-hint-color);
+            font-size: 1.1em;
         }
-        #loading, #error-view { padding: 40px 16px; text-align: center; font-size: 17px; color: var(--tg-theme-hint-color); }
-        #error-view h2 { color: var(--tg-theme-text-color); font-size: 20px; font-weight: 600; margin-bottom: 10px;}
-        #app-content { display: none; flex-grow: 1; flex-direction: column; }
+         #error-view h2 { color: var(--tg-theme-text-color); margin-bottom: 10px;}
+         #error-view p { margin-bottom: 20px; }
 
-        h1 { font-size: 28px; font-weight: 700; text-align: center; margin: 16px 0; color: var(--tg-theme-text-color);}
-        h2 { font-size: 22px; font-weight: 600; margin-top: 24px; margin-bottom: 12px; color: var(--tg-theme-text-color); padding: 0 16px; }
+        #app-content { display: none; flex-grow: 1; flex-direction: column; width: 100%; }
+
+        h1.app-title {
+            font-size: 28px; /* iOS Large Title approx */
+            font-weight: 700;
+            text-align: left;
+            margin: 20px 0 15px 0; /* Adjust spacing */
+            padding: 0;
+            color: var(--tg-theme-text-color);
+        }
+        h2.section-title {
+            font-size: 18px;
+            font-weight: 600;
+            margin: 25px 0 10px 0;
+            color: var(--tg-theme-text-color);
+            border-bottom: 1px solid var(--tg-theme-secondary-bg-color); /* Subtle separator */
+            padding-bottom: 8px;
+        }
+        p { margin-bottom: 1em; }
 
-        input[type=text], input[type=file], select {
+        input[type=text], input[type=file] {
+            display: block;
             width: 100%;
-            padding: 11px 15px;
-            margin: 8px 0;
-            border: 0.5px solid var(--border-color);
-            border-radius: 10px;
+            padding: 12px 15px;
+            margin-bottom: 12px;
+            border: 1px solid var(--tg-theme-hint-color); /* Use hint color for border */
+            border-radius: var(--border-radius-m);
             background-color: var(--tg-theme-secondary-bg-color);
             color: var(--tg-theme-text-color);
-            font-size: 17px;
-            line-height: 22px;
+            font-size: 1em;
+            line-height: 1.4;
             appearance: none; -webkit-appearance: none;
+            transition: border-color 0.2s ease, box-shadow 0.2s ease;
+        }
+        input[type=text]:focus {
+            outline: none;
+            border-color: var(--tg-theme-button-color);
+            box-shadow: 0 0 0 2px rgba(0, 122, 255, 0.3); /* Subtle focus ring */
+        }
+        input[type=file] {
+            padding: 10px;
+            border: 1px dashed var(--tg-theme-hint-color);
+            background-color: transparent; /* Make file input area distinct */
+            cursor: pointer;
+        }
+        input[type=file]::file-selector-button { /* Style the button part */
+            padding: 8px 15px;
+            border: none;
+            background-color: var(--tg-theme-hint-color);
+            color: var(--tg-theme-text-color);
+            border-radius: var(--border-radius-s);
+            cursor: pointer;
+            margin-right: 10px;
+            transition: background-color 0.2s ease;
+        }
+        input[type=file]::file-selector-button:hover {
+             background-color: var(--system-gray);
         }
-        input[type=text]:focus { outline: none; border-color: var(--tg-theme-link-color); }
-        input[type=file] { background-color: transparent; border: none; padding: 10px 0; }
+
 
         .btn {
             display: inline-block;
-            width: 100%;
-            padding: 14px 20px;
-            background: var(--tg-theme-button-color);
+            padding: 12px 20px;
+            background-color: var(--tg-theme-button-color);
             color: var(--tg-theme-button-text-color);
             border: none;
-            border-radius: 12px;
+            border-radius: var(--border-radius-m);
             cursor: pointer;
-            font-size: 17px;
+            font-size: 1em;
             font-weight: 600;
             text-align: center;
             text-decoration: none;
-            margin-top: 10px;
-            transition: opacity 0.2s ease-out;
-            -webkit-tap-highlight-color: transparent;
+            transition: opacity 0.15s ease-out, transform 0.1s ease-out;
+            margin: 5px 5px 5px 0; /* Consistent margin */
+            -webkit-user-select: none; user-select: none;
         }
         .btn:hover { opacity: 0.85; }
-        .btn:active { opacity: 0.7; }
-        .btn[disabled] { background-color: var(--system-gray-4); color: var(--system-gray); cursor: default; opacity: 1; }
-        .btn.secondary { background-color: var(--tg-theme-secondary-bg-color); color: var(--tg-theme-link-color); }
-        .btn.destructive { background-color: var(--destructive-color); color: white; }
-        .btn.icon-btn { width: auto; padding: 8px; line-height: 0; background: none; color: var(--tg-theme-link-color); font-size: 24px; margin: 0; }
-
-        .flash { color: var(--tg-theme-button-text-color); text-align: center; margin-bottom: 16px; padding: 12px 16px; border-radius: 10px; font-weight: 500; font-size: 15px; }
-        .flash.success { background: #34c759; }
-        .flash.error { background: var(--destructive-color); }
-
-        .file-list { list-style: none; padding: 0; margin: 0; }
-        .list-item {
-            display: flex; align-items: center; padding: 11px 16px;
+        .btn:active { transform: scale(0.97); opacity: 0.7; }
+        .btn[disabled] {
+            background-color: var(--system-gray-light);
+            color: var(--system-gray);
+            cursor: not-allowed;
+            opacity: 0.8;
+        }
+        .btn.secondary {
+             background-color: var(--tg-theme-secondary-bg-color);
+             color: var(--tg-theme-link-color);
+             border: 1px solid var(--tg-theme-hint-color);
+        }
+        .btn.destructive { background-color: var(--system-red); color: white; }
+        .btn.warning { background-color: var(--system-yellow); color: black; }
+
+
+        .flash-message {
+            color: white;
+            text-align: center;
+            margin-bottom: 15px;
+            padding: 12px var(--padding-base);
+            border-radius: var(--border-radius-m);
+            font-weight: 500;
+            box-shadow: 0 2px 6px rgba(0,0,0,0.1);
+            animation: fadeInDown 0.3s ease-out;
+        }
+        .flash-message.success { background-color: var(--system-green); }
+        .flash-message.error { background-color: var(--system-red); }
+        .flash-message.warning { background-color: var(--system-yellow); color: black; }
+
+        @keyframes fadeInDown { from { opacity: 0; transform: translateY(-10px); } to { opacity: 1; transform: translateY(0); } }
+
+        .file-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(140px, 1fr));
+            gap: 15px;
+            margin-top: 15px;
+            padding-bottom: 20px; /* Space at the bottom */
+        }
+
+        .item-card {
+            background-color: var(--tg-theme-secondary-bg-color);
+            border-radius: var(--border-radius-l);
+            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+            text-align: center;
+            transition: transform 0.15s ease-out, box-shadow 0.15s ease-out;
+            display: flex;
+            flex-direction: column;
+            overflow: hidden; /* Ensure content respects border radius */
+            position: relative; /* For potential absolute elements inside */
+        }
+        .item-card:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+        }
+        .item-preview-container {
+            width: 100%;
+            height: 100px; /* Slightly shorter preview */
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background-color: var(--system-gray-ultralight); /* Placeholder background */
+            cursor: pointer;
+            overflow: hidden;
+        }
+        .item-preview {
+            width: 100%;
+            height: 100%;
+            object-fit: cover; /* Cover for images/videos */
+            display: block;
+        }
+        .item-icon { /* For non-previewable files/folders */
+            font-size: 48px; /* Larger icon */
+            line-height: 1;
+            color: var(--tg-theme-link-color); /* Use link color for icons */
+        }
+        .item-icon.folder { color: var(--system-yellow); }
+        .item-icon.video { color: var(--system-blue); }
+        .item-icon.audio { color: #ff9500; } /* systemOrange */
+        .item-icon.pdf { color: var(--system-red); }
+        .item-icon.text { color: var(--system-gray); }
+        .item-icon.archive { color: #5856d6; } /* systemIndigo */
+        .item-icon.document { color: var(--system-blue); }
+        .item-icon.other { color: var(--system-gray-light); }
+
+        .item-info { padding: 10px; text-align: left; flex-grow: 1; }
+        .item-name {
+            font-size: 0.9em;
+            font-weight: 600;
+            margin: 0 0 4px 0;
+            word-break: break-all; /* Allow long names to wrap */
+            line-height: 1.3;
+            max-height: 2.6em; /* Limit to 2 lines */
+            overflow: hidden;
+            text-overflow: ellipsis;
+            display: -webkit-box;
+            -webkit-line-clamp: 2;
+            -webkit-box-orient: vertical;
+            color: var(--tg-theme-text-color);
+        }
+        .item-details {
+            font-size: 0.75em;
+            color: var(--tg-theme-hint-color);
+            margin: 0;
+        }
+        .item-actions {
+            padding: 5px 10px 10px;
+            display: flex;
+            flex-wrap: wrap;
+            gap: 5px;
+            justify-content: flex-start; /* Align buttons left */
+            border-top: 1px solid var(--tg-theme-bg-color); /* Separator */
+            margin-top: 5px;
+        }
+        .item-actions .btn {
+            font-size: 0.8em;
+            padding: 5px 10px;
+            border-radius: var(--border-radius-s);
+        }
+
+        .modal-overlay {
+            display: none;
+            position: fixed;
+            inset: 0;
+            background-color: rgba(0, 0, 0, 0.7);
+            z-index: 1000;
+            justify-content: center;
+            align-items: center;
+            padding: 10px;
+            backdrop-filter: blur(5px); /* iOS style blur */
+            -webkit-backdrop-filter: blur(5px);
+        }
+        .modal-content {
+            width: 100%;
+            height: 100%;
+            max-width: 95vw; /* Limit width */
+            max-height: 90vh; /* Limit height */
+            background-color: var(--tg-theme-secondary-bg-color);
+            border-radius: var(--border-radius-l);
+            overflow: hidden;
+            position: relative;
+            display: flex;
+            flex-direction: column;
+            box-shadow: 0 10px 30px rgba(0,0,0,0.2);
+        }
+        .modal-body {
+            flex-grow: 1;
+            overflow: auto;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            padding: 10px;
+        }
+        .modal-body img, .modal-body video, .modal-body iframe, .modal-body pre {
+            max-width: 100%;
+            max-height: 100%;
+            display: block;
+            margin: auto;
+            border-radius: var(--border-radius-m);
+        }
+        .modal-body iframe { width: 100%; height: 100%; border: none; }
+        .modal-body pre {
             background-color: var(--tg-theme-bg-color);
-            border-bottom: 0.5px solid var(--border-color);
+            color: var(--tg-theme-text-color);
+            padding: 15px;
+            border-radius: var(--border-radius-m);
+            white-space: pre-wrap;
+            word-wrap: break-word;
+            text-align: left;
+            width: 100%;
+            height: 100%; /* Allow pre to fill */
+            overflow-y: auto;
+            font-family: Menlo, Monaco, Consolas, 'Courier New', monospace;
+        }
+        .modal-close-btn {
+            position: absolute;
+            top: 10px;
+            right: 10px;
+            font-size: 28px;
+            font-weight: 300;
+            color: var(--tg-theme-hint-color);
             cursor: pointer;
-            transition: background-color 0.1s ease-out;
+            background-color: rgba(128, 128, 128, 0.2);
+            border-radius: 50%;
+            width: 32px;
+            height: 32px;
+            line-height: 30px;
+            text-align: center;
+            z-index: 1001;
+            transition: background-color 0.2s ease;
+        }
+         .modal-close-btn:hover { background-color: rgba(128, 128, 128, 0.4); }
+
+        #progress-container {
+            width: 100%;
+            background-color: var(--system-gray-light);
+            border-radius: var(--border-radius-s);
+            margin: 15px 0;
+            display: none; /* Hidden by default */
+            height: 8px; /* Slimmer progress bar */
+            overflow: hidden;
+        }
+        #progress-bar {
+            width: 0%;
+            height: 100%;
+            background-color: var(--tg-theme-button-color);
+            border-radius: var(--border-radius-s);
+            transition: width 0.2s ease-out;
+        }
+        #progress-text {
+             display: block; /* Show text below bar */
+             text-align: center;
+             margin-top: 5px;
+             font-size: 0.85em;
+             color: var(--tg-theme-hint-color);
+             font-weight: 500;
+             display: none; /* Initially hide text too */
         }
-        .list-item:first-child { border-top: 0.5px solid var(--border-color); }
-        .list-item:active { background-color: var(--system-gray-5); }
-        .item-icon { font-size: 28px; margin-right: 16px; width: 30px; text-align: center; flex-shrink: 0; }
-        .item-icon img { width: 30px; height: 30px; object-fit: cover; border-radius: 6px; display: block; }
-        .item-details { flex-grow: 1; overflow: hidden; }
-        .item-name { font-size: 17px; font-weight: 400; color: var(--tg-theme-text-color); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
-        .item-subtitle { font-size: 13px; color: var(--tg-theme-hint-color); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; margin-top: 2px;}
-        .item-actions { margin-left: auto; display: flex; align-items: center; gap: 5px; }
-
-        .modal { display: none; position: fixed; inset: 0; background: rgba(0, 0, 0, 0.6); backdrop-filter: blur(5px); -webkit-backdrop-filter: blur(5px); z-index: 2000; justify-content: center; align-items: center; padding: 10px;}
-        .modal-content { width: calc(100% - 20px); max-width: 600px; max-height: calc(100% - 20px); background: var(--tg-theme-secondary-bg-color); border-radius: 14px; overflow: hidden; position: relative; display: flex; flex-direction: column; box-shadow: 0 10px 30px rgba(0,0,0,0.2); }
-        .modal-body { flex-grow: 1; overflow: auto; display: flex; justify-content: center; align-items: center; padding: 10px; }
-        .modal img, .modal video, .modal iframe, .modal pre { max-width: 100%; max-height: 100%; display: block; margin: auto; border-radius: 8px; }
-        .modal iframe { width: 100%; height: 100%; border: none; background: white; }
-        .modal pre { background: var(--tg-theme-bg-color); color: var(--tg-theme-text-color); padding: 15px; border-radius: 8px; white-space: pre-wrap; word-wrap: break-word; text-align: left; max-height: 100%; overflow-y: auto; width: 100%; font-family: monospace; font-size: 13px;}
-        .modal-close-btn { position: absolute; top: 10px; right: 10px; font-size: 22px; color: var(--tg-theme-hint-color); cursor: pointer; background: rgba(120, 120, 128, 0.2); border-radius: 50%; width: 28px; height: 28px; line-height: 28px; text-align: center; z-index: 2001;}
-
-        #progress-container { width: calc(100% - 32px); margin: 16px auto; background: var(--system-gray-5); border-radius: 8px; display: none; position: relative; height: 8px; overflow: hidden; }
-        #progress-bar { width: 0%; height: 100%; background: var(--tg-theme-link-color); border-radius: 8px; transition: width 0.3s ease; }
-        #progress-text { display: none; }
 
         .breadcrumbs {
-            padding: 10px 16px;
-            font-size: 15px;
-            background: var(--tg-theme-secondary-bg-color);
-            color: var(--tg-theme-hint-color);
+            margin: 10px 0 20px;
+            font-size: 0.95em;
+            background-color: var(--tg-theme-secondary-bg-color);
+            padding: 10px var(--padding-base);
+            border-radius: var(--border-radius-m);
+            box-shadow: 0 1px 3px rgba(0,0,0,0.05);
+            overflow-x: auto; /* Allow scrolling if path is long */
             white-space: nowrap;
-            overflow-x: auto;
-            -webkit-overflow-scrolling: touch;
-            border-bottom: 0.5px solid var(--border-color);
         }
-        .breadcrumbs a { color: var(--tg-theme-link-color); text-decoration: none; font-weight: 400; }
+        .breadcrumbs a {
+            color: var(--tg-theme-link-color);
+            text-decoration: none;
+            font-weight: 500;
+        }
         .breadcrumbs a:hover { text-decoration: underline; }
-        .breadcrumbs span { margin: 0 4px; }
-        .breadcrumbs span.current-folder { font-weight: 600; color: var(--tg-theme-text-color);}
-
-        .action-section { padding: 0 16px 16px 16px; background-color: var(--tg-theme-bg-color); border-top: 0.5px solid var(--border-color); }
-        .action-section-grouped { display: flex; gap: 10px; align-items: center; margin-top: 10px; }
-        .action-section-grouped input[type=text] { margin: 0; flex-grow: 1; }
-        .action-section-grouped .btn { margin: 0; width: auto; padding: 11px 15px; font-size: 15px; flex-shrink: 0; }
-
-        #user-info-header { padding: 8px 16px; font-size: 13px; color: var(--tg-theme-hint-color); text-align: center; border-bottom: 0.5px solid var(--border-color); background-color: var(--tg-theme-secondary-bg-color); }
-
-        /* Specific Icons */
-        .icon-folder::before { content: '📁'; }
-        .icon-video::before { content: '🎬'; }
-        .icon-image::before { content: '🖼️'; }
-        .icon-pdf::before { content: '📄'; }
-        .icon-text::before { content: '📝'; }
-        .icon-audio::before { content: '🎵'; }
-        .icon-archive::before { content: '📦'; }
-        .icon-document::before { content: '📑'; }
-        .icon-other::before { content: '❔'; }
-
-        /* Hide scrollbar for Chrome, Safari and Opera */
-        .breadcrumbs::-webkit-scrollbar { display: none; }
-        /* Hide scrollbar for IE, Edge and Firefox */
-        .breadcrumbs { -ms-overflow-style: none; scrollbar-width: none; }
-
-        .context-menu-button::before { content: '⋯'; display: inline-block; font-weight: bold; font-size: 20px; line-height: 1; padding: 5px; }
+        .breadcrumbs span.separator { margin: 0 6px; color: var(--tg-theme-hint-color); }
+        .breadcrumbs span.current-folder { font-weight: 600; color: var(--tg-theme-text-color); }
+
+        .actions-container {
+            background-color: var(--tg-theme-secondary-bg-color);
+            padding: var(--padding-base);
+            border-radius: var(--border-radius-l);
+            margin-bottom: 20px;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.08);
+        }
+        .folder-actions { display: flex; gap: 10px; align-items: center; margin-bottom: 15px; }
+        .folder-actions input[type=text] { margin-bottom: 0; flex-grow: 1; }
+        .folder-actions .btn { margin: 0; flex-shrink: 0; }
+
+        #upload-form { margin-top: 0; }
+        #upload-form .btn { width: 100%; margin-top: 10px; }
+
 
+        #user-info-header {
+            text-align: center;
+            margin: 5px 0 15px;
+            font-size: 0.8em;
+            color: var(--tg-theme-hint-color);
+            padding: 5px;
+            background: rgba(128,128,128, 0.05);
+            border-radius: var(--border-radius-s);
+        }
+
+        /* Responsive adjustments */
+        @media (max-width: 480px) {
+            body { font-size: 15px; }
+             .app-container { padding: 0 10px 10px; }
+             h1.app-title { font-size: 24px; margin-top: 15px; }
+             h2.section-title { font-size: 17px; }
+             .file-grid { grid-template-columns: repeat(auto-fill, minmax(120px, 1fr)); gap: 10px; }
+             .item-preview-container { height: 90px; }
+             .item-icon { font-size: 40px; }
+             .item-name { font-size: 0.85em; }
+             .btn { padding: 10px 16px; }
+             .item-actions .btn { padding: 4px 8px; }
+             .breadcrumbs { padding: 8px 10px; font-size: 0.9em; }
+             .folder-actions { flex-wrap: wrap; } /* Allow wrapping on small screens */
+             .modal-content { max-width: 100%; max-height: 95vh; border-radius: var(--border-radius-m); }
+        }
     </style>
 </head>
 <body>
-    <div id="loading">Loading...</div>
+    <div id="loading"><div class="spinner"></div>Загрузка данных...</div>
     <div id="error-view" style="display: none;"></div>
-    <div id="app-content">
+
+    <div id="app-content" class="app-container">
+        <h1 class="app-title">Zeus Cloud</h1>
         <div id="user-info-header"></div>
+        <div id="flash-container"></div>
+
         <div class="breadcrumbs" id="breadcrumbs-container"></div>
-        <div id="flash-container" style="padding: 0 16px;"></div>
 
-        <div class="container">
-            <h2 id="current-folder-title" style="margin-top: 10px;">Files</h2>
-            <ul class="file-list" id="file-list-container"></ul>
+        <div class="actions-container">
+            <div class="folder-actions">
+                <input type="text" id="new-folder-name" placeholder="Имя новой папки" required>
+                <button id="create-folder-btn" class="btn">Создать</button>
+            </div>
+
+            <form id="upload-form">
+                <input type="file" name="files" id="file-input" multiple required>
+                <div id="progress-container"><div id="progress-bar"></div></div>
+                <div id="progress-text"></div>
+                <button type="submit" class="btn" id="upload-btn">Загрузить файлы</button>
+            </form>
         </div>
 
-        <div class="action-section">
-             <div class="action-section-grouped">
-                 <input type="text" id="new-folder-name" placeholder="New Folder Name" required>
-                 <button id="create-folder-btn" class="btn secondary">Create</button>
-             </div>
-             <form id="upload-form" style="margin-top: 10px;">
-                 <input type="file" name="files" id="file-input" multiple required>
-                 <button type="submit" class="btn" id="upload-btn">Upload Files</button>
-             </form>
-             <div id="progress-container"><div id="progress-bar"></div><div id="progress-text"></div></div>
+        <h2 class="section-title" id="current-folder-title">Содержимое папки</h2>
+        <div class="file-grid" id="file-grid-container">
+            <p style="color: var(--tg-theme-hint-color); grid-column: 1 / -1;">Папка пуста.</p>
         </div>
     </div>
 
-    <div class="modal" id="mediaModal" onclick="closeModal(event)">
+    <div class="modal-overlay" id="mediaModal" onclick="closeModalOnClickOutside(event)">
         <div class="modal-content">
-             <span onclick="closeModalManual()" class="modal-close-btn">×</span>
+             <span onclick="closeModalManual()" class="modal-close-btn">&times;</span>
              <div class="modal-body" id="modalContent"></div>
         </div>
     </div>
@@ -545,61 +844,86 @@ HTML_TEMPLATE = """
         const userInfoHeaderEl = document.getElementById('user-info-header');
         const flashContainerEl = document.getElementById('flash-container');
         const breadcrumbsContainerEl = document.getElementById('breadcrumbs-container');
-        const fileListContainerEl = document.getElementById('file-list-container');
+        const fileGridContainerEl = document.getElementById('file-grid-container');
         const currentFolderTitleEl = document.getElementById('current-folder-title');
         const uploadForm = document.getElementById('upload-form');
         const fileInput = document.getElementById('file-input');
         const uploadBtn = document.getElementById('upload-btn');
         const progressContainer = document.getElementById('progress-container');
         const progressBar = document.getElementById('progress-bar');
-        const progressText = document.getElementById('progress-text');
+        const progressTextEl = document.getElementById('progress-text');
         const newFolderInput = document.getElementById('new-folder-name');
         const createFolderBtn = document.getElementById('create-folder-btn');
+        const mediaModal = document.getElementById('mediaModal');
+        const modalContent = document.getElementById('modalContent');
 
         let currentFolderId = 'root';
         let validatedInitData = null;
         let currentUser = null;
         let currentItems = [];
+        let flashTimeout = null;
 
-        async function apiCall(endpoint, method = 'POST', body = {}) {
-            if (!validatedInitData) {
-                showError("Authentication data is missing.");
+        // --- API Communication ---
+        async function apiCall(endpoint, method = 'POST', body = {}, isFormData = false) {
+            if (!validatedInitData && !isFormData) {
+                showError("Ошибка: Данные авторизации отсутствуют.");
                 throw new Error("Not authenticated");
             }
-            body.initData = validatedInitData;
+
+            const headers = {};
+            let requestBody;
+
+            if (isFormData) {
+                requestBody = body; // body is already a FormData object
+            } else {
+                headers['Content-Type'] = 'application/json';
+                body.initData = validatedInitData; // Add initData for JSON requests
+                requestBody = JSON.stringify(body);
+            }
 
             try {
-                const response = await fetch(endpoint, {
-                    method: method,
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(body)
-                });
+                console.log(`API Call: ${method} ${endpoint}`, isFormData ? '[FormData]' : body);
+                const response = await fetch(endpoint, { method, headers, body: requestBody });
+
                 if (!response.ok) {
-                    let errorMsg = `Server error: ${response.status}`;
+                    let errorMsg = `Ошибка сервера: ${response.status}`;
+                    let errorDetails = '';
                     try {
                         const errData = await response.json();
                         errorMsg = errData.message || errorMsg;
-                    } catch (e) { /* Ignore */ }
-                    throw new Error(errorMsg);
+                        errorDetails = errData.details || '';
+                        console.error("API Error Response:", errData);
+                    } catch (e) {
+                         errorDetails = await response.text();
+                         console.error("API Error Response (non-JSON):", errorDetails);
+                    }
+                    throw new Error(`${errorMsg}${errorDetails ? ` (${errorDetails})` : ''}`);
                 }
-                return await response.json();
+
+                const responseData = await response.json();
+                console.log(`API Response from ${endpoint}:`, responseData);
+                return responseData;
+
             } catch (error) {
                 console.error(`API call to ${endpoint} failed:`, error);
-                showFlash(`Network or server error: ${error.message}`, 'error');
-                throw error;
+                showFlash(`Ошибка: ${error.message}`, 'error');
+                throw error; // Re-throw to be caught by caller if needed
             }
         }
 
-        function showLoadingScreen() {
-            loadingEl.style.display = 'block';
+        // --- UI Rendering ---
+        function showLoadingScreen(message = "Загрузка данных...") {
+            loadingEl.innerHTML = `<div class="spinner"></div>${message}`;
+            loadingEl.style.display = 'flex';
             errorViewEl.style.display = 'none';
             appContentEl.style.display = 'none';
         }
 
-        function showError(message) {
+        function showError(message, showReload = true) {
             loadingEl.style.display = 'none';
-            errorViewEl.innerHTML = `<h2>Error</h2><p>${message}</p><button class='btn' onclick='window.location.reload()'>Reload</button>`;
-            errorViewEl.style.display = 'block';
+            let reloadButton = showReload ? `<button class='btn' onclick='window.location.reload()'>Перезагрузить</button>` : '';
+            errorViewEl.innerHTML = `<h2>Ошибка</h2><p>${message}</p>${reloadButton}`;
+            errorViewEl.style.display = 'flex';
             appContentEl.style.display = 'none';
             if (tg.HapticFeedback) tg.HapticFeedback.notificationOccurred('error');
         }
@@ -610,29 +934,38 @@ HTML_TEMPLATE = """
             appContentEl.style.display = 'flex';
         }
 
-        function showFlash(message, type = 'success') {
+        function showFlash(message, type = 'success', duration = 5000) {
+             if (flashTimeout) clearTimeout(flashTimeout);
+             flashContainerEl.innerHTML = ''; // Clear previous
+
              const flashDiv = document.createElement('div');
-             flashDiv.className = `flash ${type}`;
+             flashDiv.className = `flash-message ${type}`;
              flashDiv.textContent = message;
-             flashContainerEl.innerHTML = '';
              flashContainerEl.appendChild(flashDiv);
+
+             flashTimeout = setTimeout(() => {
+                 flashDiv.style.opacity = '0';
+                 flashDiv.style.transition = 'opacity 0.3s ease-out';
+                 setTimeout(() => {
+                     if (flashDiv.parentNode === flashContainerEl) {
+                          flashContainerEl.removeChild(flashDiv);
+                     }
+                 }, 300);
+             }, duration);
+
              if (tg.HapticFeedback) tg.HapticFeedback.notificationOccurred(type);
-             setTimeout(() => {
-                 if (flashDiv.parentNode === flashContainerEl) {
-                    flashDiv.style.opacity = '0';
-                    flashDiv.style.transition = 'opacity 0.5s ease-out';
-                    setTimeout(() => flashContainerEl.removeChild(flashDiv), 500);
-                 }
-             }, 4500);
         }
 
         function renderBreadcrumbs(breadcrumbs) {
             breadcrumbsContainerEl.innerHTML = '';
+            if (!breadcrumbs || breadcrumbs.length === 0) {
+                 breadcrumbs.push({'id': 'root', 'name': 'Root'});
+            }
             breadcrumbs.forEach((crumb, index) => {
                 if (index > 0) {
                     const separator = document.createElement('span');
-                    separator.textContent = ' / ';
-                    separator.style.color = 'var(--tg-theme-hint-color)';
+                    separator.className = 'separator';
+                    separator.textContent = '/';
                     breadcrumbsContainerEl.appendChild(separator);
                 }
                 if (index === breadcrumbs.length - 1) {
@@ -640,7 +973,7 @@ HTML_TEMPLATE = """
                      span.className = 'current-folder';
                      span.textContent = crumb.name;
                      breadcrumbsContainerEl.appendChild(span);
-                     currentFolderTitleEl.textContent = crumb.name;
+                     currentFolderTitleEl.textContent = `Содержимое: ${crumb.name}`;
                 } else {
                     const link = document.createElement('a');
                     link.href = '#';
@@ -649,244 +982,211 @@ HTML_TEMPLATE = """
                     breadcrumbsContainerEl.appendChild(link);
                 }
             });
-            // Scroll to the end of breadcrumbs
-             setTimeout(() => { breadcrumbsContainerEl.scrollLeft = breadcrumbsContainerEl.scrollWidth; }, 0);
+        }
+
+        function getItemIcon(item) {
+             if (item.type === 'folder') return '<span class="item-icon folder">📁</span>'; // Standard folder icon
+
+             const fileType = item.file_type || 'other';
+             switch (fileType) {
+                 case 'image': return '<span class="item-icon image">🖼️</span>';
+                 case 'video': return '<span class="item-icon video">🎬</span>';
+                 case 'audio': return '<span class="item-icon audio">🎵</span>';
+                 case 'pdf': return '<span class="item-icon pdf">📄</span>';
+                 case 'text': return '<span class="item-icon text">📝</span>';
+                 case 'archive': return '<span class="item-icon archive">📦</span>';
+                 case 'document': return '<span class="item-icon document">📑</span>';
+                 default: return '<span class="item-icon other">❓</span>';
+             }
         }
 
         function renderItems(items) {
-            fileListContainerEl.innerHTML = '';
+            fileGridContainerEl.innerHTML = ''; // Clear previous items
             if (!items || items.length === 0) {
-                 const emptyMsg = document.createElement('li');
-                 emptyMsg.textContent = 'This folder is empty.';
-                 emptyMsg.style.padding = '20px 16px';
-                 emptyMsg.style.textAlign = 'center';
-                 emptyMsg.style.color = 'var(--tg-theme-hint-color)';
-                 fileListContainerEl.appendChild(emptyMsg);
+                 fileGridContainerEl.innerHTML = '<p style="color: var(--tg-theme-hint-color); grid-column: 1 / -1; text-align: center; margin-top: 20px;">Папка пуста.</p>';
                  return;
             }
-            items.forEach(item => {
-                const listItem = document.createElement('li');
-                listItem.className = 'list-item';
-                listItem.setAttribute('data-id', item.id);
-                listItem.setAttribute('data-type', item.type);
-                listItem.setAttribute('data-name', item.name || item.original_filename);
-
-                const iconDiv = document.createElement('div');
-                iconDiv.className = 'item-icon';
 
-                const detailsDiv = document.createElement('div');
-                detailsDiv.className = 'item-details';
-
-                const nameP = document.createElement('p');
-                nameP.className = 'item-name';
-                nameP.textContent = item.name || item.original_filename || 'Unnamed';
+             // Sort: folders first, then by name
+             items.sort((a, b) => {
+                if (a.type === 'folder' && b.type !== 'folder') return -1;
+                if (a.type !== 'folder' && b.type === 'folder') return 1;
+                const nameA = a.name || a.original_filename || '';
+                const nameB = b.name || b.original_filename || '';
+                return nameA.localeCompare(nameB, undefined, { numeric: true, sensitivity: 'base' });
+             });
 
-                const subtitleP = document.createElement('p');
-                subtitleP.className = 'item-subtitle';
 
-                detailsDiv.appendChild(nameP);
-                detailsDiv.appendChild(subtitleP);
+            items.forEach(item => {
+                const itemDiv = document.createElement('div');
+                itemDiv.className = `item-card ${item.type}`;
 
-                const actionsDiv = document.createElement('div');
-                actionsDiv.className = 'item-actions';
+                let previewHtml = '';
+                let actionsHtml = '';
+                let filenameDisplay = item.original_filename || item.name || 'Unnamed Item';
+                const uploadDate = item.upload_date ? item.upload_date.split(' ')[0] : ''; // Just the date part
 
                 if (item.type === 'folder') {
-                    iconDiv.classList.add('icon-folder');
-                    subtitleP.textContent = `${(item.children || []).length} items`;
-                    listItem.onclick = () => loadFolderContent(item.id);
-                    // Add context menu button for folder actions (like delete)
-                    const menuBtn = createContextMenuButton(item);
-                    actionsDiv.appendChild(menuBtn);
-
-                } else if (item.type === 'file') {
+                     previewHtml = `<div class="item-preview-container" title="Открыть папку ${item.name}" onclick="loadFolderContent('${item.id}')">${getItemIcon(item)}</div>`;
+                     actionsHtml = `
+                         <button class="btn" onclick="loadFolderContent('${item.id}')">Открыть</button>
+                         <button class="btn destructive" onclick="deleteFolder('${item.id}', '${item.name}')">Удалить</button>
+                     `;
+                     filenameDisplay = item.name;
+                 } else if (item.type === 'file') {
+                    const previewable = ['image', 'video', 'pdf', 'text', 'audio'].includes(item.file_type);
                     const dlUrl = `/download/${item.id}`;
-                    let canPreview = false;
-                    let previewAction = null;
-
-                     if (item.file_type === 'image') {
-                         iconDiv.innerHTML = `<img src="/preview_thumb/${item.id}" alt="" loading="lazy" onerror="this.parentElement.classList.add('icon-image'); this.remove();">`;
-                         previewAction = () => openModal(dlUrl, 'image', item.id);
-                         canPreview = true;
-                     } else if (item.file_type === 'video') {
-                         iconDiv.classList.add('icon-video');
-                         previewAction = () => openModal(dlUrl, 'video', item.id);
-                         canPreview = true;
-                     } else if (item.file_type === 'pdf') {
-                         iconDiv.classList.add('icon-pdf');
-                         previewAction = () => openModal(dlUrl, 'pdf', item.id);
-                         canPreview = true;
-                     } else if (item.file_type === 'text') {
-                         iconDiv.classList.add('icon-text');
-                         previewAction = () => openModal(`/get_text_content/${item.id}`, 'text', item.id);
-                         canPreview = true;
-                     } else if (item.file_type === 'audio') {
-                         iconDiv.classList.add('icon-audio');
-                         // Simple preview for audio might just open it directly
-                         // previewAction = () => window.open(dlUrl, '_blank');
-                         // canPreview = true; // Or add modal player
-                    } else if (item.file_type === 'archive') {
-                         iconDiv.classList.add('icon-archive');
-                    } else if (item.file_type === 'document') {
-                         iconDiv.classList.add('icon-document');
-                    } else {
-                        iconDiv.classList.add('icon-other');
+                    let viewFuncCall = '';
+                    let previewContent = getItemIcon(item); // Default icon
+
+                    if (item.file_type === 'image') {
+                         // Use thumb for preview, full for modal
+                         previewContent = `<img class="item-preview" src="/preview_thumb/${item.id}" alt="${filenameDisplay}" loading="lazy" onerror="this.parentElement.innerHTML = '${getItemIcon(item)}';">`;
+                         viewFuncCall = `openModal('/download/${item.id}', 'image', '${item.id}')`;
+                    } else if (item.file_type === 'video') {
+                         viewFuncCall = `openModal('/download/${item.id}', 'video', '${item.id}')`;
+                    } else if (item.file_type === 'audio') {
+                         viewFuncCall = `openModal('/download/${item.id}', 'audio', '${item.id}')`;
+                    } else if (item.file_type === 'pdf') {
+                         viewFuncCall = `openModal('/download/${item.id}', 'pdf', '${item.id}')`;
+                    } else if (item.file_type === 'text') {
+                         viewFuncCall = `openModal('/get_text_content/${item.id}', 'text', '${item.id}')`;
                     }
+                    // No specific preview needed for non-image, icon shown by default
 
-                    subtitleP.textContent = item.upload_date ? item.upload_date.split(' ')[0] : 'File';
-                    if(canPreview && previewAction) {
-                        listItem.onclick = previewAction;
-                    } else {
-                        listItem.onclick = () => tg.openLink(dlUrl); // Fallback to download/open link
-                    }
+                     previewHtml = `<div class="item-preview-container" ${previewable ? `onclick="${viewFuncCall}"` : ''} title="${previewable ? 'Нажмите для просмотра' : ''}">${previewContent}</div>`;
 
-                    const menuBtn = createContextMenuButton(item);
-                    actionsDiv.appendChild(menuBtn);
+                    actionsHtml = `<a href="${dlUrl}" class="btn secondary" target="_blank" rel="noopener noreferrer" download="${item.original_filename || item.id}">Скачать</a>`;
+                    if (previewable) {
+                        actionsHtml += `<button class="btn" onclick="${viewFuncCall}">Просмотр</button>`;
+                    }
+                    actionsHtml += `<button class="btn destructive" onclick="deleteFile('${item.id}', '${filenameDisplay}')">Удалить</button>`;
                 }
 
-                listItem.appendChild(iconDiv);
-                listItem.appendChild(detailsDiv);
-                listItem.appendChild(actionsDiv);
-                fileListContainerEl.appendChild(listItem);
-            });
-        }
-
-        function createContextMenuButton(item) {
-            const button = document.createElement('button');
-            button.className = 'btn icon-btn context-menu-button';
-            button.setAttribute('aria-label', 'Actions');
-            button.onclick = (e) => {
-                e.stopPropagation(); // Prevent li click
-                showItemActions(item, button);
-            };
-            return button;
-        }
-
-        function showItemActions(item, anchorElement) {
-            let actions = [];
-            const itemName = item.name || item.original_filename;
-
-            if (item.type === 'folder') {
-                actions.push({ text: "Open", action: () => loadFolderContent(item.id) });
-                actions.push({ text: "Delete", style: "destructive", action: () => deleteFolder(item.id, itemName) });
-            } else { // File
-                const dlUrl = `/download/${item.id}`;
-                if (['image', 'video', 'pdf', 'text'].includes(item.file_type)) {
-                    let previewUrl = item.file_type === 'text' ? `/get_text_content/${item.id}` : dlUrl;
-                    actions.push({ text: "Preview", action: () => openModal(previewUrl, item.file_type, item.id) });
-                }
-                actions.push({ text: "Download", action: () => tg.openLink(dlUrl, {try_instant_view: false}) });
-                actions.push({ text: "Delete", style: "destructive", action: () => deleteFile(item.id, itemName) });
-            }
-             actions.push({ text: "Cancel", style: "cancel" });
-
-            const popupParams = {
-                title: itemName,
-                message: `Type: ${item.type === 'folder' ? 'Folder' : item.file_type || 'File'}`,
-                buttons: actions.map(a => ({
-                    type: a.style || 'default', // 'default', 'ok', 'close', 'cancel', 'destructive'
-                    text: a.text,
-                    id: a.text.toLowerCase().replace(/ /g, '_') // Generate an ID for the callback
-                }))
-            };
-
-            tg.showPopup(popupParams, (buttonId) => {
-                 const selectedAction = actions.find(a => a.text.toLowerCase().replace(/ /g, '_') === buttonId);
-                 if (selectedAction && selectedAction.action) {
-                    selectedAction.action();
-                 }
+                itemDiv.innerHTML = `
+                    ${previewHtml}
+                    <div class="item-info">
+                        <p class="item-name" title="${filenameDisplay}">${filenameDisplay}</p>
+                        ${uploadDate ? `<p class="item-details">${uploadDate}</p>` : ''}
+                    </div>
+                    <div class="item-actions">${actionsHtml}</div>
+                `;
+                fileGridContainerEl.appendChild(itemDiv);
             });
         }
 
+        // --- Modal Logic ---
         async function openModal(srcOrUrl, type, itemId) {
-            const modal = document.getElementById('mediaModal');
-            const modalContent = document.getElementById('modalContent');
-            modalContent.innerHTML = '<p style="color: var(--tg-theme-hint-color);">Loading...</p>';
-            modal.style.display = 'flex';
+            modalContent.innerHTML = '<div class="spinner"></div> Загрузка просмотра...';
+            mediaModal.style.display = 'flex'; // Use flex for centering
 
             try {
+                 // Special handling for relative URLs vs external URLs
+                let resolvedSrc = srcOrUrl.startsWith('http') ? srcOrUrl : window.location.origin + srcOrUrl;
+                console.log(`Opening modal: type=${type}, src=${resolvedSrc}`);
+
                 if (type === 'pdf') {
-                     if (tg.platform === "ios" || tg.platform === "android") {
-                         tg.openLink(window.location.origin + srcOrUrl, {try_instant_view: true});
-                         closeModalManual();
-                         return;
-                     } else {
-                         modalContent.innerHTML = `<iframe src="https://docs.google.com/gview?url=${encodeURIComponent(window.location.origin + srcOrUrl)}&embedded=true" title="PDF Viewer"></iframe>`;
-                     }
+                     // Try embedding PDF directly first, fallback to Google viewer maybe
+                     // Note: Embedding PDFs in iframes can be blocked by security policies
+                     // Consider using tg.openLink for PDFs if embedding fails often
+                     modalContent.innerHTML = `<iframe src="${resolvedSrc}" title="Просмотр PDF"></iframe>`;
+                     // Fallback option:
+                     // modalContent.innerHTML = `<iframe src="https://docs.google.com/gview?url=${encodeURIComponent(resolvedSrc)}&embedded=true" title="Просмотр PDF"></iframe>`;
                 } else if (type === 'image') {
-                    modalContent.innerHTML = `<img src="${srcOrUrl}" alt="Image Preview" style="object-fit: contain;">`;
+                    modalContent.innerHTML = `<img src="${resolvedSrc}" alt="Просмотр изображения" style="object-fit: contain;">`;
                 } else if (type === 'video') {
-                    modalContent.innerHTML = `<video controls autoplay style='max-width: 100%; max-height: 100%;'><source src="${srcOrUrl}">Your browser does not support the video tag.</video>`;
+                    modalContent.innerHTML = `<video controls autoplay style='max-width: 100%; max-height: 100%; background: #000;'><source src="${resolvedSrc}">Ваш браузер не поддерживает это видео.</video>`;
+                } else if (type === 'audio') {
+                    modalContent.innerHTML = `<div style="padding: 20px; text-align: center;">🎵<br><audio controls autoplay style="width: 90%; margin-top: 15px;"><source src="${resolvedSrc}">Ваш браузер не поддерживает это аудио.</audio></div>`;
                 } else if (type === 'text') {
-                    const response = await fetch(srcOrUrl);
-                    if (!response.ok) throw new Error(`Failed to load text: ${response.statusText}`);
-                    const text = await response.text();
-                    const pre = document.createElement('pre');
-                    pre.textContent = text;
-                    modalContent.innerHTML = '';
-                    modalContent.appendChild(pre);
-                } else {
-                    modalContent.innerHTML = '<p>Preview not supported for this file type.</p>';
+                     // Use the dedicated text route which should return plain text
+                     const response = await fetch(srcOrUrl); // Fetch from the relative path '/get_text_content/...'
+                     if (!response.ok) {
+                         const errorText = await response.text();
+                         throw new Error(`Ошибка ${response.status}: ${errorText || response.statusText}`);
+                     }
+                     const text = await response.text();
+                     // Basic escaping for HTML display in pre tag
+                     const escapedText = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+                     modalContent.innerHTML = `<pre>${escapedText}</pre>`;
+                 } else {
+                    modalContent.innerHTML = '<p style="padding: 20px; text-align: center;">Предпросмотр для этого типа файла не поддерживается.</p>';
                 }
             } catch (error) {
                 console.error("Error loading modal content:", error);
-                modalContent.innerHTML = `<p style="color: var(--destructive-color);">Could not load preview. ${error.message}</p>`;
-                if (tg.HapticFeedback) tg.HapticFeedback.notificationOccurred('error');
+                modalContent.innerHTML = `<p style="padding: 20px; text-align: center; color: var(--system-red);">Не удалось загрузить содержимое для предпросмотра.<br><small>${error.message}</small></p>`;
+                 if (tg.HapticFeedback) tg.HapticFeedback.notificationOccurred('error');
             }
         }
 
-        function closeModal(event) {
-            const modal = document.getElementById('mediaModal');
-            if (event.target === modal) {
-                closeModalManual();
-            }
-        }
+         function closeModalOnClickOutside(event) {
+             if (event.target === mediaModal) {
+                 closeModalManual();
+             }
+         }
 
         function closeModalManual() {
-            const modal = document.getElementById('mediaModal');
-            modal.style.display = 'none';
-            const video = modal.querySelector('video');
-            if (video) { video.pause(); video.src = ''; }
-            const iframe = modal.querySelector('iframe');
+            mediaModal.style.display = 'none';
+            // Stop media playback
+            const video = mediaModal.querySelector('video');
+            if (video) { video.pause(); video.src = ''; video.removeAttribute('src'); }
+            const audio = mediaModal.querySelector('audio');
+            if (audio) { audio.pause(); audio.src = ''; audio.removeAttribute('src'); }
+            const iframe = mediaModal.querySelector('iframe');
             if (iframe) iframe.src = 'about:blank';
-            document.getElementById('modalContent').innerHTML = '';
+            // Clear content to free memory
+            modalContent.innerHTML = '';
         }
 
+        // --- Folder Operations ---
         async function loadFolderContent(folderId) {
             currentFolderId = folderId;
-            console.log(`Loading folder: ${folderId}`);
-            tg.BackButton.isVisible = (folderId !== 'root');
+            console.log(`Navigating to folder: ${folderId}`);
+            showLoadingScreen(`Загрузка папки...`); // Show loading specific message
+
             try {
                 const data = await apiCall('/get_dashboard_data', 'POST', { folder_id: folderId });
                 if (data.status === 'ok') {
                      currentItems = data.items || [];
                      renderBreadcrumbs(data.breadcrumbs || [{'id': 'root', 'name': 'Root'}]);
-                     renderItems(currentItems.sort((a, b) => (a.type !== 'folder') - (b.type !== 'folder') || (a.name || a.original_filename || '').localeCompare(b.name || b.original_filename || '')));
+                     renderItems(currentItems);
+                     // Update back button visibility
+                     // tg.BackButton.isVisible = (data.breadcrumbs && data.breadcrumbs.length > 1);
+                     showAppContent(); // Ensure app is visible after loading
                 } else {
-                    showFlash(data.message || 'Failed to load folder content.', 'error');
+                    showError(data.message || 'Не удалось загрузить содержимое папки.');
                 }
             } catch (error) {
-                // Error handled by apiCall
+                 showError(`Не удалось загрузить данные: ${error.message}`);
+            } finally {
+                 // Hide general loading screen if it was shown by this function
+                 if (loadingEl.textContent.includes('Загрузка папки')) {
+                     loadingEl.style.display = 'none';
+                 }
             }
         }
 
         async function handleCreateFolder() {
             const folderName = newFolderInput.value.trim();
             if (!folderName) {
-                showFlash('Please enter a folder name.', 'error');
+                showFlash('Введите имя папки.', 'warning');
                 newFolderInput.focus();
                 return;
             }
+             // Allow more characters, but disallow path separators
+             if (folderName.includes('/') || folderName.includes('\\')) {
+                 showFlash('Имя папки не должно содержать / или \\.', 'error');
+                 return;
+             }
              if (folderName.length > 100) {
-                showFlash('Folder name is too long (max 100 chars).', 'error');
-                return;
+                  showFlash('Имя папки слишком длинное (макс. 100 симв.).', 'error');
+                  return;
              }
-              if (/[\\/:*?"<>|]/.test(folderName)) {
-                 showFlash('Folder name contains invalid characters.', 'error');
-                 return;
-              }
+
 
             createFolderBtn.disabled = true;
-            createFolderBtn.textContent = 'Creating...';
+            createFolderBtn.textContent = 'Создание...';
+            if (tg.HapticFeedback) tg.HapticFeedback.impactOccurred('light');
 
             try {
                 const data = await apiCall('/create_folder', 'POST', {
@@ -894,862 +1194,1098 @@ HTML_TEMPLATE = """
                     folder_name: folderName
                 });
                 if (data.status === 'ok') {
-                    showFlash(`Folder "${folderName}" created.`, 'success');
+                    showFlash(`Папка "${folderName}" создана.`, 'success');
                     newFolderInput.value = '';
-                    loadFolderContent(currentFolderId);
+                    loadFolderContent(currentFolderId); // Refresh content
                 } else {
-                    showFlash(data.message || 'Failed to create folder.', 'error');
+                    // Error already shown by apiCall's catch block
+                    // showFlash(data.message || 'Не удалось создать папку.', 'error');
                 }
             } catch (error) {
-                 // Error handled by apiCall
+                 // Error flash shown by apiCall
+                 console.error("Folder creation failed:", error);
             } finally {
                  createFolderBtn.disabled = false;
-                 createFolderBtn.textContent = 'Create';
+                 createFolderBtn.textContent = 'Создать';
             }
         }
 
-        function deleteFolder(folderId, folderName) {
-            tg.showConfirm(`Delete the folder "${folderName}"? It must be empty to be deleted.`, async (confirmed) => {
-                if (confirmed) {
-                    try {
-                         const data = await apiCall(`/delete_folder/${folderId}`, 'POST', { current_folder_id: currentFolderId });
-                         if (data.status === 'ok') {
-                             showFlash(`Folder "${folderName}" deleted.`, 'success');
-                             loadFolderContent(currentFolderId);
-                         } else {
-                             showFlash(data.message || 'Failed to delete folder.', 'error');
-                         }
-                     } catch (error) {
-                          // Error handled by apiCall
-                     }
-                }
-            });
-        }
+        async function deleteItem(itemId, itemName, isFolder) {
+             const itemType = isFolder ? 'папку' : 'файл';
+             const apiEndpoint = isFolder ? `/delete_folder/${itemId}` : `/delete_file/${itemId}`;
+             const confirmMessage = `Вы уверены, что хотите удалить ${itemType} "${itemName}"? ${isFolder ? 'Папку можно удалить только если она пуста.' : ''}`;
 
-         function deleteFile(fileId, fileName) {
-             tg.showConfirm(`Delete the file "${fileName}"? This cannot be undone.`, async (confirmed) => {
+             tg.showConfirm(confirmMessage, async (confirmed) => {
                  if (confirmed) {
+                     if (tg.HapticFeedback) tg.HapticFeedback.impactOccurred('medium');
                      try {
-                         const data = await apiCall(`/delete_file/${fileId}`, 'POST', { current_folder_id: currentFolderId });
-                         if (data.status === 'ok') {
-                             showFlash(`File "${fileName}" deleted.`, 'success');
-                             loadFolderContent(currentFolderId);
-                         } else {
-                             showFlash(data.message || 'Failed to delete file.', 'error');
-                         }
-                     } catch (error) {
-                          // Error handled by apiCall
-                     }
+                          // We need to tell the backend which folder we are currently IN
+                          // so it can potentially return the updated content of *that* folder,
+                          // even though we are deleting an item *within* it.
+                          // But the primary identifier is the itemId being deleted.
+                          const data = await apiCall(apiEndpoint, 'POST', { current_folder_id: currentFolderId });
+                          if (data.status === 'ok') {
+                              showFlash(`${isFolder ? 'Папка' : 'Файл'} "${itemName}" удален(а).`, 'success');
+                              // Find and remove the item from the current view immediately
+                              const itemElement = document.querySelector(`.item-card [onclick*="'${itemId}'"]`)?.closest('.item-card');
+                              if(itemElement) {
+                                  itemElement.style.transition = 'opacity 0.3s ease-out, transform 0.3s ease-out';
+                                  itemElement.style.opacity = '0';
+                                  itemElement.style.transform = 'scale(0.9)';
+                                  setTimeout(() => itemElement.remove(), 300);
+                              } else {
+                                  // Fallback if element not found, just reload
+                                  loadFolderContent(currentFolderId);
+                              }
+                              // Update the item count if needed
+                              currentItems = currentItems.filter(item => item.id !== itemId);
+                              if (currentItems.length === 0) {
+                                   renderItems([]); // Show empty message
+                              }
+
+                          } else {
+                              // Error handled by apiCall
+                          }
+                      } catch (error) {
+                           console.error(`Deletion failed for ${itemType} ${itemId}:`, error);
+                           // Error handled by apiCall
+                      }
                  }
              });
         }
 
+        function deleteFolder(folderId, folderName) {
+             deleteItem(folderId, folderName, true);
+        }
+
+        function deleteFile(fileId, fileName) {
+             deleteItem(fileId, fileName, false);
+        }
+
+
+        // --- File Upload ---
         function handleFileUpload(event) {
              event.preventDefault();
              const files = fileInput.files;
              if (files.length === 0) {
-                 showFlash('Please select files to upload.', 'error');
+                 showFlash('Выберите файлы для загрузки.', 'warning');
                  return;
              }
 
+             // Removed explicit file count limit
+
              progressContainer.style.display = 'block';
              progressBar.style.width = '0%';
-             progressText.textContent = '0%';
+             progressTextEl.textContent = 'Подготовка...';
+             progressTextEl.style.display = 'block';
              uploadBtn.disabled = true;
-             uploadBtn.textContent = 'Uploading...';
-             fileInput.disabled = true;
-             createFolderBtn.disabled = true;
+             uploadBtn.textContent = 'Загрузка...';
+             if (tg.HapticFeedback) tg.HapticFeedback.impactOccurred('light');
 
              const formData = new FormData();
              for (let i = 0; i < files.length; i++) {
                  formData.append('files', files[i]);
              }
              formData.append('current_folder_id', currentFolderId);
+             // Add initData directly to FormData for validation on backend
              formData.append('initData', validatedInitData);
 
+
              const xhr = new XMLHttpRequest();
 
              xhr.upload.addEventListener('progress', function(event) {
                  if (event.lengthComputable) {
                      const percentComplete = Math.round((event.loaded / event.total) * 100);
                      progressBar.style.width = percentComplete + '%';
-                     // progressText.textContent = percentComplete + '%'; // Maybe remove text?
+                     progressTextEl.textContent = `Загрузка: ${percentComplete}%`;
+                 } else {
+                     progressTextEl.textContent = 'Загрузка... (размер неизвестен)';
                  }
              });
 
              xhr.addEventListener('load', function() {
                  uploadBtn.disabled = false;
-                 uploadBtn.textContent = 'Upload Files';
-                 fileInput.disabled = false;
-                 createFolderBtn.disabled = false;
+                 uploadBtn.textContent = 'Загрузить файлы';
                  progressContainer.style.display = 'none';
-                 fileInput.value = ''; // Clear selection
+                 progressTextEl.style.display = 'none';
+                 fileInput.value = ''; // Clear file input
 
                  if (xhr.status >= 200 && xhr.status < 300) {
                      try {
                          const data = JSON.parse(xhr.responseText);
-                         if (data.status === 'ok') {
-                              showFlash(data.message || `${files.length} file(s) uploaded.`, 'success');
-                              loadFolderContent(currentFolderId);
+                         console.log("Upload response:", data);
+                         if (data.status === 'ok' || data.status === 'partial') {
+                              // Show success or partial success message
+                              showFlash(data.message || `${files.length} файл(ов) обработано.`, data.status === 'ok' ? 'success' : 'warning');
+                              loadFolderContent(currentFolderId); // Refresh view
                          } else {
-                              showFlash(data.message || 'Error processing upload on server.', 'error');
+                              // Show error message from server
+                              showFlash(data.message || 'Ошибка при обработке загрузки на сервере.', 'error');
                          }
                      } catch (e) {
-                         showFlash('Invalid response from server after upload.', 'error');
+                         console.error("Error parsing upload response:", e, xhr.responseText);
+                         showFlash('Некорректный ответ от сервера после загрузки.', 'error');
                      }
                  } else {
-                      let errorMsg = `Upload failed: ${xhr.statusText || xhr.status}`;
+                      // Handle HTTP errors
+                      let errorMsg = `Ошибка загрузки: ${xhr.status}`;
                       try {
                           const errData = JSON.parse(xhr.responseText);
                           errorMsg = errData.message || errorMsg;
-                      } catch(e) { /* ignore */}
+                      } catch (e) { /* Ignore if response is not JSON */ }
                       showFlash(errorMsg, 'error');
                  }
              });
 
              xhr.addEventListener('error', function() {
-                 showFlash('Network error during upload.', 'error');
+                 showFlash('Ошибка сети во время загрузки.', 'error');
                  uploadBtn.disabled = false;
-                 uploadBtn.textContent = 'Upload Files';
-                 fileInput.disabled = false;
-                 createFolderBtn.disabled = false;
+                 uploadBtn.textContent = 'Загрузить файлы';
                  progressContainer.style.display = 'none';
+                 progressTextEl.style.display = 'none';
              });
 
              xhr.addEventListener('abort', function() {
-                 showFlash('Upload aborted.', 'error');
+                 showFlash('Загрузка отменена.', 'warning');
                  uploadBtn.disabled = false;
-                 uploadBtn.textContent = 'Upload Files';
-                 fileInput.disabled = false;
-                 createFolderBtn.disabled = false;
+                 uploadBtn.textContent = 'Загрузить файлы';
                  progressContainer.style.display = 'none';
+                 progressTextEl.style.display = 'none';
              });
 
              xhr.open('POST', '/upload', true);
-             // Consider adding auth token if needed, but initData should suffice for now
-             // xhr.setRequestHeader('Authorization', 'Bearer ' + your_token);
+             // Note: No Content-Type header needed for FormData, browser sets it with boundary
              xhr.send(formData);
         }
 
-        function goBack() {
-            const breadcrumbs = Array.from(breadcrumbsContainerEl.querySelectorAll('a'));
-            if (breadcrumbs.length > 0) {
-                const parentLink = breadcrumbs[breadcrumbs.length - 1];
-                parentLink.click();
-            } else if (currentFolderId !== 'root') {
-                // Fallback if breadcrumbs aren't fully rendered yet
-                loadFolderContent('root');
-            }
-        }
 
+        // --- Initialization ---
         function initializeApp() {
-            tg.ready();
-            tg.expand();
-            tg.enableClosingConfirmation();
-
-            // Set theme
-            const themeParams = tg.themeParams;
-            document.documentElement.style.setProperty('--tg-bg-color', themeParams.bg_color);
-            document.documentElement.style.setProperty('--tg-text-color', themeParams.text_color);
-            document.documentElement.style.setProperty('--tg-hint-color', themeParams.hint_color);
-            document.documentElement.style.setProperty('--tg-link-color', themeParams.link_color);
-            document.documentElement.style.setProperty('--tg-button-color', themeParams.button_color);
-            document.documentElement.style.setProperty('--tg-button-text-color', themeParams.button_text_color);
-            document.documentElement.style.setProperty('--tg-secondary-bg-color', themeParams.secondary_bg_color);
-            // Try to detect dark mode for better default fallback colors if needed
-            if (themeParams.bg_color) {
-                const color = themeParams.bg_color.replace('#','');
-                const r = parseInt(color.substring(0,2), 16);
-                const g = parseInt(color.substring(2,4), 16);
-                const b = parseInt(color.substring(4,6), 16);
-                const brightness = (r * 299 + g * 587 + b * 114) / 1000;
-                if (brightness < 128) {
-                    document.documentElement.style.colorScheme = 'dark';
-                } else {
-                     document.documentElement.style.colorScheme = 'light';
-                }
-            }
-            tg.setHeaderColor(themeParams.secondary_bg_color || '#f0f0f0');
-            tg.setBackgroundColor(themeParams.bg_color || '#ffffff');
-
-
-            if (!tg.initData) {
-                 showError("Could not get Telegram authorization data (initData). Please try restarting the Mini App.");
-                 return;
-            }
-            validatedInitData = tg.initData;
-
-            fetch('/validate_init_data', {
-                 method: 'POST',
-                 headers: { 'Content-Type': 'application/json' },
-                 body: JSON.stringify({ initData: validatedInitData })
-             })
-             .then(response => {
-                 if (!response.ok) {
-                    return response.json().then(err => { throw new Error(err.message || `HTTP ${response.status}`) });
-                 }
-                 return response.json();
-             })
-             .then(data => {
-                 if (data.status === 'ok' && data.user) {
-                     currentUser = data.user;
-                     let userName = currentUser.first_name || '';
-                     if (currentUser.last_name) userName += ' ' + currentUser.last_name;
-                     if (!userName && currentUser.username) userName = '@' + currentUser.username;
-                     if (!userName) userName = `ID: ${currentUser.id}`;
-                     userInfoHeaderEl.textContent = `User: ${userName}`;
-                     showAppContent();
-                     loadFolderContent('root');
-                 } else {
-                     throw new Error(data.message || 'User verification failed.');
-                 }
-             })
-             .catch(error => {
-                 console.error("Validation or initial load failed:", error);
-                 showError(`Authorization Error: ${error.message}. Please try reloading.`);
-                 validatedInitData = null;
-             });
-
-            uploadForm.addEventListener('submit', handleFileUpload);
-            createFolderBtn.addEventListener('click', handleCreateFolder);
-            tg.BackButton.onClick(goBack);
-            tg.BackButton.hide(); // Initially hidden, shown when navigating into a folder
+             console.log("Initializing App...");
+             tg.ready();
+             tg.expand();
+
+             // Apply theme colors more dynamically
+             const theme = tg.themeParams;
+             const root = document.documentElement;
+             root.style.setProperty('--tg-bg-color', theme.bg_color || '#f0f0f0');
+             root.style.setProperty('--tg-text-color', theme.text_color || '#000000');
+             root.style.setProperty('--tg-hint-color', theme.hint_color || '#aaaaaa');
+             root.style.setProperty('--tg-link-color', theme.link_color || '#007aff');
+             root.style.setProperty('--tg-button-color', theme.button_color || '#007aff');
+             root.style.setProperty('--tg-button-text-color', theme.button_text_color || '#ffffff');
+             root.style.setProperty('--tg-secondary-bg-color', theme.secondary_bg_color || '#ffffff');
+
+             // Set header color based on theme (optional, but good for consistency)
+             tg.setHeaderColor(theme.secondary_bg_color || '#ffffff');
+
+             if (!tg.initData) {
+                  showError("Не удалось получить данные авторизации Telegram (initData). Попробуйте перезапустить Mini App или обновить Telegram.", false);
+                  console.error("Telegram initData is missing or empty.");
+                  return;
+             }
+             console.log("Telegram initData received:", tg.initData.length > 100 ? tg.initData.substring(0, 100) + "..." : tg.initData);
+             validatedInitData = tg.initData; // Store it for API calls
+
+              // Validate initData with backend
+              showLoadingScreen("Проверка авторизации...");
+              fetch('/validate_init_data', {
+                  method: 'POST',
+                  headers: { 'Content-Type': 'application/json' },
+                  body: JSON.stringify({ initData: validatedInitData })
+              })
+              .then(response => {
+                   if (!response.ok) {
+                       // Try to parse error message from backend
+                       return response.json().then(errData => {
+                           throw new Error(errData.message || `Ошибка ${response.status}`);
+                       }).catch(() => {
+                           // If parsing fails, throw generic error
+                           throw new Error(`Ошибка ${response.status}`);
+                       });
+                   }
+                   return response.json();
+              })
+              .then(data => {
+                  console.log("Validation response:", data);
+                  if (data.status === 'ok' && data.user && data.user.id) {
+                      currentUser = data.user;
+                      let userName = currentUser.first_name || '';
+                      if (currentUser.last_name) userName += ' ' + currentUser.last_name;
+                      if (!userName && currentUser.username) userName = '@' + currentUser.username;
+                      if (!userName) userName = `ID: ${currentUser.id}`;
+                      userInfoHeaderEl.textContent = `Пользователь: ${userName}`;
+                      userInfoHeaderEl.style.display = 'block'; // Show user info
+
+                      // Initial load of root folder
+                      loadFolderContent('root');
+
+                      // Make app content visible only after successful validation and initial load trigger
+                      // showAppContent(); // Moved inside loadFolderContent success path
+                  } else {
+                      throw new Error(data.message || 'Не удалось верифицировать пользователя.');
+                  }
+              })
+              .catch(error => {
+                  console.error("Validation or initial load failed:", error);
+                  showError(`Ошибка авторизации: ${error.message}. Попробуйте перезапустить.`);
+                  validatedInitData = null; // Invalidate data on failure
+              });
+
+             // Setup event listeners
+             uploadForm.addEventListener('submit', handleFileUpload);
+             createFolderBtn.addEventListener('click', handleCreateFolder);
+
+             // Optional: Basic Back button handling
+             // tg.BackButton.onClick(() => {
+             //     const breadcrumbs = Array.from(breadcrumbsContainerEl.querySelectorAll('a'));
+             //     if (breadcrumbs.length > 0) {
+             //         // Click the second to last breadcrumb link (parent folder)
+             //         breadcrumbs[breadcrumbs.length - 1].click();
+             //     } else {
+             //         // Maybe close app or do nothing if already at root
+             //         // tg.close();
+             //     }
+             // });
+             // Note: Back button visibility is updated in loadFolderContent
         }
 
-        initializeApp();
+        // --- Start the App ---
+        document.addEventListener('DOMContentLoaded', initializeApp);
 
     </script>
+     <div class="spinner" style="display: none;"></div> <!-- Preload spinner styles -->
+     <style>.spinner{width:24px;height:24px;border:3px solid var(--tg-theme-hint-color);border-bottom-color:transparent;border-radius:50%;display:inline-block;box-sizing:border-box;animation:rotation 1s linear infinite}@keyframes rotation{0%{transform:rotate(0deg)}100%{transform:rotate(360deg)}}</style>
+
 </body>
 </html>
 """
 
+
+# --- Flask Routes ---
+
 @app.route('/')
 def index():
     return Response(HTML_TEMPLATE, mimetype='text/html')
 
 @app.route('/validate_init_data', methods=['POST'])
 def validate_init_data():
+    start_time = time.time()
     data = request.get_json()
     if not data or 'initData' not in data:
-        return jsonify({"status": "error", "message": "Missing initData"}), 400
+        logging.warning("validate_init_data: Missing initData in request.")
+        return jsonify({"status": "error", "message": "Отсутствуют данные авторизации."}), 400
 
-    init_data = data['initData']
-    user_info = check_telegram_authorization(init_data, BOT_TOKEN)
+    init_data_str = data['initData']
+    user_info = check_telegram_authorization(init_data_str, BOT_TOKEN)
 
     if user_info and 'id' in user_info:
         tg_user_id = str(user_info['id'])
-        db_data = load_data()
-        users = db_data.setdefault('users', {})
-        needs_save = False
+        logging.info(f"validate_init_data: Auth success for user {tg_user_id}.")
 
-        if tg_user_id not in users or not isinstance(users.get(tg_user_id), dict):
-            logging.info(f"New user detected: {tg_user_id}. Initializing filesystem.")
-            users[tg_user_id] = {
-                'user_info': user_info,
-                'created_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-            }
-            initialize_user_filesystem(users[tg_user_id])
-            needs_save = True
-        else:
-            if 'user_info' not in users[tg_user_id] or users[tg_user_id]['user_info'].get('username') != user_info.get('username'):
-                users[tg_user_id]['user_info'] = user_info
+        try:
+            db_data = load_data()
+            users = db_data.setdefault('users', {})
+            needs_save = False
+
+            if tg_user_id not in users or not isinstance(users.get(tg_user_id), dict):
+                logging.info(f"validate_init_data: New user {tg_user_id}. Initializing data.")
+                users[tg_user_id] = {
+                    'user_info': user_info,
+                    'created_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+                }
+                initialize_user_filesystem(users[tg_user_id])
                 needs_save = True
-            if 'filesystem' not in users[tg_user_id]:
-                 initialize_user_filesystem(users[tg_user_id])
-                 needs_save = True
-            elif 'children' not in users[tg_user_id]['filesystem'] or not isinstance(users[tg_user_id]['filesystem']['children'], list):
-                 users[tg_user_id]['filesystem']['children'] = []
-                 needs_save = True
+            else:
+                # Ensure filesystem exists and update user info if changed
+                user_entry = users[tg_user_id]
+                initialize_user_filesystem(user_entry) # Ensures filesystem exists
+
+                # Check if user_info needs update (e.g., username change)
+                if user_entry.get('user_info') != user_info:
+                    logging.info(f"validate_init_data: Updating user_info for user {tg_user_id}.")
+                    user_entry['user_info'] = user_info
+                    needs_save = True
+
+            if needs_save:
+                try:
+                    save_data(db_data)
+                    logging.info(f"validate_init_data: Saved data for user {tg_user_id}.")
+                except Exception as e:
+                     # Critical: If save fails, especially for a new user, they might not be usable
+                     logging.error(f"validate_init_data: CRITICAL - Failed to save data for user {tg_user_id}: {e}", exc_info=True)
+                     return jsonify({"status": "error", "message": "Критическая ошибка сохранения данных пользователя."}), 500
 
+            elapsed = time.time() - start_time
+            logging.info(f"validate_init_data: Completed for user {tg_user_id} in {elapsed:.3f}s")
+            return jsonify({"status": "ok", "user": user_info})
 
-        if needs_save:
-            if not save_data(db_data):
-                 logging.error(f"Failed to save data for user {tg_user_id} during validation.")
-                 # Avoid failing validation just because save failed, but log it.
-                 # return jsonify({"status": "error", "message": "Error saving user data."}), 500
+        except Exception as e:
+            logging.error(f"validate_init_data: Unexpected error processing user {tg_user_id}: {e}", exc_info=True)
+            return jsonify({"status": "error", "message": "Внутренняя ошибка сервера при обработке данных."}), 500
 
-        return jsonify({"status": "ok", "user": user_info})
     else:
-        logging.warning(f"Validation failed for initData: {init_data[:100]}...")
-        return jsonify({"status": "error", "message": "Invalid authorization data."}), 403
+        logging.warning(f"validate_init_data: Validation failed for provided initData.")
+        return jsonify({"status": "error", "message": "Недействительные данные авторизации Telegram."}), 403
 
 
 @app.route('/get_dashboard_data', methods=['POST'])
 def get_dashboard_data():
+    start_time = time.time()
     data = request.get_json()
     if not data or 'initData' not in data or 'folder_id' not in data:
-        return jsonify({"status": "error", "message": "Incomplete request"}), 400
+        return jsonify({"status": "error", "message": "Неполный запрос данных"}), 400
 
     user_info = check_telegram_authorization(data['initData'], BOT_TOKEN)
     if not user_info or 'id' not in user_info:
-        return jsonify({"status": "error", "message": "Not authorized"}), 403
+        return jsonify({"status": "error", "message": "Ошибка авторизации"}), 403
 
     tg_user_id = str(user_info['id'])
     folder_id = data['folder_id']
-    db_data = load_data()
-    user_data = db_data.get('users', {}).get(tg_user_id)
-
-    if not user_data or 'filesystem' not in user_data or not isinstance(user_data['filesystem'], dict):
-         logging.error(f"User data or filesystem missing/invalid for validated user {tg_user_id}")
-         # Attempt to re-initialize if possible, might indicate corrupted data
-         if user_data and isinstance(user_data, dict):
-             initialize_user_filesystem(user_data)
-             if save_data(db_data):
-                  logging.info(f"Re-initialized filesystem for user {tg_user_id}")
-             else:
-                  logging.error(f"Failed to save re-initialized filesystem for user {tg_user_id}")
-                  return jsonify({"status": "error", "message": "User data error"}), 500
-         else:
-             return jsonify({"status": "error", "message": "User data error"}), 500
+    logging.info(f"get_dashboard_data: Request for folder '{folder_id}' by user {tg_user_id}")
+
+    try:
+        db_data = load_data()
+        user_data = db_data.get('users', {}).get(tg_user_id)
+
+        if not user_data or 'filesystem' not in user_data:
+             logging.error(f"get_dashboard_data: User data or filesystem structure missing for validated user {tg_user_id}")
+             return jsonify({"status": "error", "message": "Ошибка структуры данных пользователя"}), 500
+
+        filesystem = user_data['filesystem']
+        current_folder, _ = find_node_by_id(filesystem, folder_id)
+
+        if not current_folder or current_folder.get('type') != 'folder':
+            logging.warning(f"get_dashboard_data: Folder '{folder_id}' not found or not a folder for user {tg_user_id}. Defaulting to root.")
+            folder_id = 'root'
+            current_folder, _ = find_node_by_id(filesystem, folder_id)
+            if not current_folder:
+                 logging.critical(f"get_dashboard_data: CRITICAL - Root folder not found for user {tg_user_id}!")
+                 # Attempt to re-initialize and save
+                 initialize_user_filesystem(user_data)
+                 try:
+                     save_data(db_data)
+                     logging.info(f"Re-initialized and saved filesystem for user {tg_user_id}")
+                     current_folder, _ = find_node_by_id(user_data['filesystem'], folder_id)
+                     if not current_folder: # If still not found after re-init
+                         raise RuntimeError("Root folder reconstruction failed.")
+                 except Exception as e:
+                     logging.critical(f"Failed to recover missing root folder for user {tg_user_id}: {e}", exc_info=True)
+                     return jsonify({"status": "error", "message": "Критическая ошибка файловой системы пользователя"}), 500
+
 
+        items_in_folder = current_folder.get('children', [])
+        # Ensure items are dicts before sending
+        valid_items = [item for item in items_in_folder if isinstance(item, dict)]
+        if len(valid_items) != len(items_in_folder):
+            logging.warning(f"get_dashboard_data: Filtered out non-dict items from children of folder {folder_id} for user {tg_user_id}")
 
-    current_folder, _ = find_node_by_id(user_data['filesystem'], folder_id)
 
-    if not current_folder or current_folder.get('type') != 'folder':
-        logging.warning(f"Folder {folder_id} not found or invalid for user {tg_user_id}. Defaulting to root.")
-        folder_id = 'root'
-        current_folder, _ = find_node_by_id(user_data['filesystem'], folder_id)
-        if not current_folder:
-             logging.error(f"CRITICAL: Root folder not found for user {tg_user_id}")
-             return jsonify({"status": "error", "message": "Critical error: Root folder missing"}), 500
+        breadcrumbs = get_node_path_list(filesystem, folder_id)
 
-    items_in_folder = current_folder.get('children', [])
-    # Filter out any potentially invalid children (non-dicts)
-    items_in_folder = [item for item in items_in_folder if isinstance(item, dict)]
+        current_folder_info = {
+            'id': current_folder.get('id'),
+            'name': current_folder.get('name', 'Root') # Should have a name, but fallback
+        }
 
-    breadcrumbs = get_node_path_list(user_data['filesystem'], folder_id)
+        elapsed = time.time() - start_time
+        logging.info(f"get_dashboard_data: Returning {len(valid_items)} items for folder '{folder_id}' (user {tg_user_id}) in {elapsed:.3f}s")
 
-    current_folder_info = {
-        'id': current_folder.get('id'),
-        'name': current_folder.get('name', 'Root')
-    }
+        return jsonify({
+            "status": "ok",
+            "items": valid_items,
+            "breadcrumbs": breadcrumbs,
+            "current_folder": current_folder_info
+        })
 
-    return jsonify({
-        "status": "ok",
-        "items": items_in_folder,
-        "breadcrumbs": breadcrumbs,
-        "current_folder": current_folder_info
-    })
+    except Exception as e:
+        logging.error(f"get_dashboard_data: Unexpected error for user {tg_user_id}, folder {folder_id}: {e}", exc_info=True)
+        return jsonify({"status": "error", "message": "Внутренняя ошибка сервера при получении данных"}), 500
 
 
 @app.route('/upload', methods=['POST'])
 def upload_files():
+    start_time = time.time()
+    # Use request.form for FormData, including initData
     init_data = request.form.get('initData')
     current_folder_id = request.form.get('current_folder_id', 'root')
     files = request.files.getlist('files')
 
+    if not init_data:
+         return jsonify({"status": "error", "message": "Отсутствуют данные авторизации.", "details": "initData missing"}), 400
+
     user_info = check_telegram_authorization(init_data, BOT_TOKEN)
     if not user_info or 'id' not in user_info:
-        return jsonify({"status": "error", "message": "Not authorized"}), 403
+        return jsonify({"status": "error", "message": "Ошибка авторизации.", "details": "Invalid initData"}), 403
 
     tg_user_id = str(user_info['id'])
+    logging.info(f"upload_files: User {tg_user_id} uploading {len(files)} file(s) to folder '{current_folder_id}'.")
 
     if not HF_TOKEN_WRITE:
-        return jsonify({'status': 'error', 'message': 'Upload not configured (missing HF token).'}), 503
+        logging.error("upload_files: HF_TOKEN_WRITE is not configured.")
+        return jsonify({'status': 'error', 'message': 'Загрузка невозможна: отсутствует ключ доступа к хранилищу.', "details": "HF token missing"}), 500
 
     if not files or all(not f.filename for f in files):
-        return jsonify({'status': 'error', 'message': 'No files selected for upload.'}), 400
+        return jsonify({'status': 'error', 'message': 'Файлы для загрузки не выбраны.'}), 400
 
     # Removed file count limit
 
-    db_data = load_data()
-    user_data = db_data.get('users', {}).get(tg_user_id)
-    if not user_data or 'filesystem' not in user_data or not isinstance(user_data.get('filesystem'), dict):
-         logging.error(f"Upload failed: User data or filesystem missing/invalid for user {tg_user_id}")
-         return jsonify({"status": "error", "message": "User data error"}), 500
-
-    target_folder_node, _ = find_node_by_id(user_data['filesystem'], current_folder_id)
-    if not target_folder_node or target_folder_node.get('type') != 'folder':
-         logging.error(f"Upload failed: Target folder {current_folder_id} not found for user {tg_user_id}")
-         return jsonify({'status': 'error', 'message': 'Target folder not found!'}), 404
-
-    api = HfApi()
-    uploaded_count = 0
-    errors = []
-    needs_save = False
-
-    for file in files:
-        if file and file.filename:
-            original_filename = secure_filename(file.filename)
-            if not original_filename:
-                logging.warning(f"Skipping file with invalid secure filename: {file.filename}")
-                errors.append(f"Skipped file with invalid name: {file.filename}")
-                continue
-
-            name_part, ext_part = os.path.splitext(original_filename)
-            unique_suffix = uuid.uuid4().hex[:8]
-            # Ensure filename isn't excessively long after adding suffix
-            max_name_len = 240 # Arbitrary limit, adjust if needed
-            unique_filename = f"{name_part[:max_name_len - len(ext_part) - 9]}_{unique_suffix}{ext_part}"
-            file_id = uuid.uuid4().hex
-
-            # Construct path more carefully to avoid issues with folder IDs like 'root'
-            path_parts = ["cloud_files", tg_user_id]
-            if current_folder_id != 'root':
-                # Potentially get full path if needed, but simpler might be just ID
-                 path_parts.append(current_folder_id)
-            path_parts.append(unique_filename)
-            hf_path = "/".join(path_parts)
-
-            temp_path = os.path.join(UPLOAD_FOLDER, f"{file_id}_{unique_filename}")
+    try:
+        db_data = load_data()
+        user_data = db_data.get('users', {}).get(tg_user_id)
+        if not user_data or 'filesystem' not in user_data:
+             logging.error(f"upload_files: User data or filesystem missing for user {tg_user_id}.")
+             return jsonify({"status": "error", "message": "Ошибка данных пользователя."}), 500
 
-            try:
-                file.save(temp_path)
-                logging.info(f"Uploading {original_filename} as {unique_filename} to {hf_path} for user {tg_user_id}")
-                api.upload_file(
-                    path_or_fileobj=temp_path, path_in_repo=hf_path,
-                    repo_id=REPO_ID, repo_type="dataset", token=HF_TOKEN_WRITE,
-                    commit_message=f"User {tg_user_id} uploaded {original_filename}"
-                )
-                logging.info(f"Successfully uploaded to HF: {hf_path}")
+        target_folder_node, _ = find_node_by_id(user_data['filesystem'], current_folder_id)
+        if not target_folder_node or target_folder_node.get('type') != 'folder':
+             logging.error(f"upload_files: Target folder '{current_folder_id}' not found or not a folder for user {tg_user_id}.")
+             return jsonify({'status': 'error', 'message': 'Целевая папка не найдена или не является папкой.', "details": f"Folder {current_folder_id} invalid"}), 404
 
-                file_info = {
-                    'type': 'file', 'id': file_id,
-                    'original_filename': original_filename, 'unique_filename': unique_filename,
-                    'path': hf_path, 'file_type': get_file_type(original_filename),
-                    'upload_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-                }
+        api = HfApi()
+        uploaded_files_metadata = []
+        errors = []
+        needs_save = False
+
+        for file in files:
+            if file and file.filename:
+                original_filename = secure_filename(file.filename)
+                if not original_filename:
+                    logging.warning(f"upload_files: Skipped file with invalid secure filename from user {tg_user_id}.")
+                    errors.append(f"Файл с небезопасным именем пропущен.")
+                    continue
+
+                name_part, ext_part = os.path.splitext(original_filename)
+                unique_suffix = uuid.uuid4().hex[:8]
+                # Ensure filename isn't excessively long after adding suffix
+                max_name_len = 240 # Arbitrary limit for name_part + suffix
+                if len(name_part) > max_name_len:
+                     name_part = name_part[:max_name_len]
+                unique_filename = f"{name_part}_{unique_suffix}{ext_part}"
+                file_id = uuid.uuid4().hex
+
+                # Structure path: cloud_files / user_id / unique_file_id_with_ext
+                # Using file_id in path ensures uniqueness even if user uploads same name twice quickly
+                # Using current_folder_id was problematic if folders are renamed/moved later.
+                hf_path = f"cloud_files/{tg_user_id}/{file_id}{ext_part}"
+                temp_path = os.path.join(UPLOAD_FOLDER, f"{file_id}_{unique_filename}") # Temp local storage
+
+                try:
+                    file.save(temp_path)
+                    logging.info(f"upload_files: Temporarily saved '{original_filename}' to '{temp_path}' for user {tg_user_id}.")
+
+                    api.upload_file(
+                        path_or_fileobj=temp_path,
+                        path_in_repo=hf_path,
+                        repo_id=REPO_ID,
+                        repo_type="dataset",
+                        token=HF_TOKEN_WRITE,
+                        commit_message=f"User {tg_user_id} uploaded {original_filename} (id: {file_id})"
+                        # Consider run_as_future=True for potentially faster response, but makes error handling complex
+                    )
+                    logging.info(f"upload_files: Successfully uploaded '{original_filename}' to HF path '{hf_path}' for user {tg_user_id}.")
+
+                    file_metadata = {
+                        'type': 'file',
+                        'id': file_id,
+                        'original_filename': original_filename,
+                        'unique_filename': unique_filename, # Keep for potential debugging?
+                        'path': hf_path, # Store the HF path
+                        'file_type': get_file_type(original_filename),
+                        'upload_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                        # parent_id could be added here if needed, but find_node_by_id handles hierarchy
+                    }
+                    uploaded_files_metadata.append(file_metadata)
 
-                if add_node(user_data['filesystem'], current_folder_id, file_info):
-                    uploaded_count += 1
+                except Exception as e:
+                    logging.error(f"upload_files: Failed to upload '{original_filename}' for user {tg_user_id}: {e}", exc_info=True)
+                    errors.append(f"Ошибка загрузки {original_filename}: {str(e)[:100]}") # Append error for this file
+                    # If HF upload failed, we don't add metadata. Cleanup temp file.
+                finally:
+                    if os.path.exists(temp_path):
+                        try:
+                            os.remove(temp_path)
+                        except OSError as e_rm:
+                            logging.error(f"upload_files: Error removing temp file '{temp_path}': {e_rm}")
+            else:
+                logging.warning(f"upload_files: Encountered an empty file object in the list for user {tg_user_id}.")
+
+
+        # Add metadata AFTER all uploads attempted
+        added_count = 0
+        if uploaded_files_metadata:
+            for meta in uploaded_files_metadata:
+                if add_node(user_data['filesystem'], current_folder_id, meta):
+                    added_count += 1
                     needs_save = True
-                    logging.info(f"Added node {file_id} to parent {current_folder_id} in DB for user {tg_user_id}")
                 else:
-                    errors.append(f"Error adding metadata for {original_filename}.")
-                    logging.error(f"Failed add_node for {file_id} to {current_folder_id} for {tg_user_id}")
-                    try:
-                         logging.warning(f"Attempting to delete orphaned HF file: {hf_path}")
-                         api.delete_file(path_in_repo=hf_path, repo_id=REPO_ID, repo_type="dataset", token=HF_TOKEN_WRITE)
-                         logging.info(f"Deleted orphaned HF file: {hf_path}")
-                    except Exception as del_err:
-                         logging.error(f"Failed deleting orphaned HF file {hf_path}: {del_err}")
+                    # This is problematic: file uploaded to HF, but DB update failed.
+                    logging.error(f"upload_files: CRITICAL - Failed to add metadata for file {meta.get('id')} ({meta.get('original_filename')}) to folder {current_folder_id} for user {tg_user_id} AFTER successful HF upload.")
+                    errors.append(f"Ошибка сохранения метаданных для {meta.get('original_filename')}.")
+                    # Should we try to delete the orphaned HF file? Risky if DB save fails later.
+                    # For now, log prominently. Manual cleanup might be needed.
 
+        if needs_save:
+            try:
+                save_data(db_data)
+                logging.info(f"upload_files: Successfully saved DB update for user {tg_user_id} after adding {added_count} file(s).")
             except Exception as e:
-                logging.exception(f"Upload error for {original_filename} ({tg_user_id}): {e}")
-                errors.append(f"Error uploading {original_filename}: {str(e)[:100]}")
-            finally:
-                if os.path.exists(temp_path):
-                    try:
-                        os.remove(temp_path)
-                    except OSError as e:
-                        logging.error(f"Error removing temp file {temp_path}: {e}")
-
-    if needs_save:
-        if not save_data(db_data):
-             logging.error(f"CRITICAL: Error saving DB after successful uploads for {tg_user_id}")
-             errors.append("Critical error saving database after upload.")
-             # Consider how to handle this - files are on HF but not in DB list
-
-    final_message = f"{uploaded_count}/{len(files)} file(s) uploaded successfully."
-    status_code = 200
-    if errors:
-        final_message += f" Errors encountered: {len(errors)}. Check logs."
-        logging.warning(f"Upload completed for user {tg_user_id} with errors: {'; '.join(errors)}")
-        if uploaded_count == 0:
-            status_code = 500 # Treat as complete failure if nothing got through
-        else:
-            status_code = 207 # Multi-Status / Partial Success
-
-
-    return jsonify({
-        "status": "ok" if not errors else ("partial" if uploaded_count > 0 else "error"),
-        "message": final_message,
-        "uploaded_count": uploaded_count,
-        "error_count": len(errors),
-        "error_details": errors if errors else [] # Optionally return error details
-    }), status_code
+                 # Save failed AFTER files were uploaded and metadata potentially added in memory.
+                 logging.critical(f"upload_files: CRITICAL - Failed to save DB for user {tg_user_id} after uploads: {e}", exc_info=True)
+                 errors.append("Критическая ошибка: Не удалось сохранить изменения в базе данных после загрузки.")
+                 # Respond with error, state might be inconsistent.
+                 elapsed = time.time() - start_time
+                 status_code = 500
+                 final_status = "error"
+                 final_message = "Ошибка сохранения данных после загрузки."
+                 if errors:
+                     final_message += " Ошибки файлов: " + "; ".join(errors)
+                 return jsonify({"status": final_status, "message": final_message}), status_code
+
+
+        # Determine final status and message
+        elapsed = time.time() - start_time
+        successful_uploads = len(uploaded_files_metadata)
+        total_processed = len(files)
+
+        if not errors and successful_uploads == total_processed:
+            final_status = "ok"
+            final_message = f"{successful_uploads} файл(ов) успешно загружено."
+            status_code = 200
+        elif successful_uploads > 0 and errors:
+            final_status = "partial"
+            final_message = f"{successful_uploads} из {total_processed} файлов загружено. Ошибки: {'; '.join(errors)}"
+            status_code = 207 # Multi-Status
+        else: # No successes or only errors
+            final_status = "error"
+            final_message = f"Не удалось загрузить файлы. Ошибки: {'; '.join(errors)}"
+            status_code = 400 # Or 500 if server-side issues dominate
+
+        logging.info(f"upload_files: Completed for user {tg_user_id} in {elapsed:.3f}s. Status: {final_status}. Message: {final_message}")
+        return jsonify({"status": final_status, "message": final_message}), status_code
 
+    except Exception as e:
+        logging.error(f"upload_files: Unhandled exception during upload for user {tg_user_id}: {e}", exc_info=True)
+        return jsonify({"status": "error", "message": "Внутренняя ошибка сервера во время загрузки."}), 500
 
 @app.route('/create_folder', methods=['POST'])
 def create_folder():
+    start_time = time.time()
     data = request.get_json()
     if not data or 'initData' not in data or 'parent_folder_id' not in data or 'folder_name' not in data:
-         return jsonify({"status": "error", "message": "Incomplete request"}), 400
+         return jsonify({"status": "error", "message": "Неполный запрос"}), 400
 
     user_info = check_telegram_authorization(data['initData'], BOT_TOKEN)
     if not user_info or 'id' not in user_info:
-        return jsonify({"status": "error", "message": "Not authorized"}), 403
+        return jsonify({"status": "error", "message": "Ошибка авторизации"}), 403
 
     tg_user_id = str(user_info['id'])
     parent_folder_id = data['parent_folder_id']
     folder_name = data['folder_name'].strip()
+    logging.info(f"create_folder: User {tg_user_id} creating folder '{folder_name}' in parent '{parent_folder_id}'.")
+
 
     if not folder_name:
-        return jsonify({'status': 'error', 'message': 'Folder name cannot be empty.'}), 400
+        return jsonify({'status': 'error', 'message': 'Имя папки не может быть пустым.'}), 400
     if len(folder_name) > 100:
-        return jsonify({'status': 'error', 'message': 'Folder name too long (max 100).'}), 400
-    if '/' in folder_name or '\\' in folder_name or folder_name == '.' or folder_name == '..':
-         return jsonify({'status': 'error', 'message': 'Folder name contains invalid characters.'}), 400
+        return jsonify({'status': 'error', 'message': 'Имя папки слишком длинное (макс. 100 символов).'}), 400
+    if '/' in folder_name or '\\' in folder_name:
+        return jsonify({'status': 'error', 'message': 'Имя папки содержит недопустимые символы (/ или \\).'}), 400
 
+    try:
+        db_data = load_data()
+        user_data = db_data.get('users', {}).get(tg_user_id)
+        if not user_data or 'filesystem' not in user_data:
+             return jsonify({"status": "error", "message": "Ошибка данных пользователя"}), 500
+
+        # Check if folder with same name already exists in parent
+        parent_node, _ = find_node_by_id(user_data['filesystem'], parent_folder_id)
+        if parent_node and parent_node.get('type') == 'folder':
+             children = parent_node.get('children', [])
+             if any(isinstance(c, dict) and c.get('type') == 'folder' and c.get('name') == folder_name for c in children):
+                 return jsonify({'status': 'error', 'message': f'Папка с именем "{folder_name}" уже существует здесь.'}), 409 # Conflict
+
+
+        folder_id = uuid.uuid4().hex
+        folder_data = {
+            'type': 'folder',
+            'id': folder_id,
+            'name': folder_name,
+            'children': [],
+            'created_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        }
 
-    db_data = load_data()
-    user_data = db_data.get('users', {}).get(tg_user_id)
-    if not user_data or 'filesystem' not in user_data or not isinstance(user_data.get('filesystem'), dict):
-         logging.error(f"Create folder failed: User data or filesystem missing/invalid for user {tg_user_id}")
-         return jsonify({"status": "error", "message": "User data error"}), 500
-
-    parent_node, _ = find_node_by_id(user_data['filesystem'], parent_folder_id)
-    if not parent_node or parent_node.get('type') != 'folder':
-        logging.error(f"Create folder failed: Parent folder {parent_folder_id} not found for user {tg_user_id}")
-        return jsonify({'status': 'error', 'message': 'Parent folder not found.'}), 404
-
-    # Check for existing folder with the same name in the parent
-    if 'children' in parent_node and isinstance(parent_node['children'], list):
-        for child in parent_node['children']:
-            if isinstance(child, dict) and child.get('type') == 'folder' and child.get('name') == folder_name:
-                 return jsonify({'status': 'error', 'message': f'A folder named "{folder_name}" already exists here.'}), 409
-
-
-    folder_id = uuid.uuid4().hex
-    folder_data = {
-        'type': 'folder', 'id': folder_id,
-        'name': folder_name, 'children': []
-    }
-
-    if add_node(user_data['filesystem'], parent_folder_id, folder_data):
-        if save_data(db_data):
-            logging.info(f"Created folder '{folder_name}' ({folder_id}) under {parent_folder_id} for user {tg_user_id}")
-            return jsonify({'status': 'ok', 'message': f'Folder "{folder_name}" created.'})
+        if add_node(user_data['filesystem'], parent_folder_id, folder_data):
+            try:
+                save_data(db_data)
+                elapsed = time.time() - start_time
+                logging.info(f"create_folder: Successfully created and saved folder '{folder_name}' (id: {folder_id}) for user {tg_user_id} in {elapsed:.3f}s.")
+                return jsonify({'status': 'ok', 'message': f'Папка "{folder_name}" создана.'})
+            except Exception as e:
+                # Save failed after node was added in memory - attempt to rollback? Hard. Log critical error.
+                logging.critical(f"create_folder: CRITICAL - Failed to save DB after creating folder '{folder_name}' (id: {folder_id}) for user {tg_user_id}: {e}", exc_info=True)
+                # Remove the node we just added in memory before erroring out? Maybe safer not to modify further.
+                return jsonify({'status': 'error', 'message': 'Критическая ошибка сохранения данных после создания папки.'}), 500
         else:
-            logging.error(f"CRITICAL: Failed to save DB after creating folder node {folder_id} for {tg_user_id}")
-            # Attempt to rollback the node addition? Difficult without deepcopy/transaction
-            remove_node(user_data['filesystem'], folder_id) # Best effort rollback
-            return jsonify({'status': 'error', 'message': 'Error saving data after creating folder.'}), 500
-    else:
-        logging.error(f"Failed add_node for new folder {folder_id} to {parent_folder_id} for {tg_user_id}")
-        return jsonify({'status': 'error', 'message': 'Could not add folder to parent node.'}), 500
+            # add_node logs errors internally
+            logging.error(f"create_folder: Failed to add folder node '{folder_name}' for user {tg_user_id}. Parent folder '{parent_folder_id}' might be invalid.")
+            return jsonify({'status': 'error', 'message': 'Не удалось добавить папку. Родительская папка не найдена или не является папкой.'}), 400
 
+    except Exception as e:
+        logging.error(f"create_folder: Unhandled exception for user {tg_user_id}: {e}", exc_info=True)
+        return jsonify({"status": "error", "message": "Внутренняя ошибка сервера при создании папки."}), 500
 
-def find_file_owner_and_node(file_id):
-    db_data = load_data()
-    for user_id, user_data in db_data.get('users', {}).items():
-         if isinstance(user_data, dict) and 'filesystem' in user_data:
-             node, _ = find_node_by_id(user_data['filesystem'], file_id)
-             if node and isinstance(node, dict) and node.get('type') == 'file':
-                 return user_id, node
-    return None, None
 
 @app.route('/download/<file_id>')
-def download_file_route(file_id):
-    owner_user_id, file_node = find_file_owner_and_node(file_id)
+def download_file_route(file_id: str):
+    start_time = time.time()
+    logging.info(f"download_file_route: Request for file ID '{file_id}'.")
+
+    # This route is public, but we still need to find the file's metadata
+    db_data = load_data() # Use cached data if possible
+    file_node = None
+    owner_user_id = None
+
+    # This search can be slow if there are many users. Consider indexing if performance becomes an issue.
+    for user_id_iter, user_data_iter in db_data.get('users', {}).items():
+         if isinstance(user_data_iter, dict) and 'filesystem' in user_data_iter:
+             node, _ = find_node_by_id(user_data_iter['filesystem'], file_id)
+             if node and node.get('type') == 'file' and node.get('path'):
+                 file_node = node
+                 owner_user_id = user_id_iter
+                 logging.info(f"download_file_route: Found file ID '{file_id}' belonging to user {owner_user_id}.")
+                 break # Found it
 
     if not file_node:
-         return Response("File not found", status=404, mimetype='text/plain')
+         logging.warning(f"download_file_route: File ID '{file_id}' not found in any user's filesystem.")
+         return Response("Файл не найден", status=404)
 
     hf_path = file_node.get('path')
     original_filename = file_node.get('original_filename', f'{file_id}_download')
 
     if not hf_path:
-        logging.error(f"Missing HF path for file ID {file_id} (owner: {owner_user_id})")
-        return Response("Error: File path information missing", status=500, mimetype='text/plain')
+        logging.error(f"download_file_route: Missing HF path in metadata for file ID {file_id} (owner: {owner_user_id})")
+        return Response("Ошибка: Путь к файлу не найден в метаданных.", status=500)
 
+    # Construct the direct download URL
+    # Using ?download=true might help force download dialog in some browsers
     file_url = f"https://huggingface.co/datasets/{REPO_ID}/resolve/main/{hf_path}?download=true"
-    logging.info(f"Download request for file_id: {file_id}, owner: {owner_user_id}, hf_path: {hf_path}")
+    logging.info(f"download_file_route: Attempting to stream from HF URL: {file_url}")
+
 
     try:
-        headers = {}
+        headers = {"User-Agent": "ZeusCloudMiniApp/1.0"}
         if HF_TOKEN_READ:
             headers["authorization"] = f"Bearer {HF_TOKEN_READ}"
 
-        response = requests.get(file_url, headers=headers, stream=True, timeout=30)
-        response.raise_for_status()
-
-        content_type = response.headers.get('Content-Type', 'application/octet-stream')
+        # Use stream=True for large files
+        response = requests.get(file_url, headers=headers, stream=True, timeout=60) # Increased timeout
+        response.raise_for_status() # Raises HTTPError for bad responses (4xx or 5xx)
 
-        # Prepare Content-Disposition header carefully
+        # Encode filename properly for Content-Disposition header
+        # Use standard approach first, then URL encoding as fallback
         try:
-            # Try to encode filename safely for header
-            encoded_name = original_filename.encode('latin-1', 'replace').decode('latin-1')
-            utf8_encoded_name = urlencode({'filename': original_filename}, encoding='utf-8')[9:]
-            disposition = f'attachment; filename="{encoded_name}"; filename*=UTF-8\'\'{utf8_encoded_name}'
+            # Try RFC 5987 encoding (handles most characters)
+            encoded_filename = original_filename.encode('latin-1', 'ignore').decode('latin-1')
+            disposition = f"attachment; filename=\"{encoded_filename}\"; filename*=UTF-8''{urlencode({'': original_filename})[1:]}"
         except Exception:
-            logging.warning(f"Could not properly encode filename '{original_filename}' for Content-Disposition. Using simplified.")
-            safe_filename = "".join(c for c in original_filename if c.isalnum() or c in ['.', '_', '-']).strip() or "download"
-            disposition = f'attachment; filename="{safe_filename}"'
+             # Fallback to simpler encoding if the above fails
+             encoded_filename = urlencode({'filename': original_filename})[9:]
+             disposition = f"attachment; filename=\"{original_filename}\"; filename*=UTF-8''{encoded_filename}"
 
 
-        return Response(response.iter_content(chunk_size=65536),
+        # Get content type from HF response if available
+        content_type = response.headers.get('Content-Type', 'application/octet-stream')
+
+        elapsed = time.time() - start_time
+        logging.info(f"download_file_route: Streaming file '{original_filename}' (id: {file_id}) with type {content_type} in {elapsed:.3f}s")
+
+        return Response(response.iter_content(chunk_size=65536), # Stream with larger chunks
                         mimetype=content_type,
-                        headers={"Content-Disposition": disposition,
-                                 "Content-Length": response.headers.get('Content-Length')})
+                        headers={"Content-Disposition": disposition})
 
     except requests.exceptions.HTTPError as e:
-         logging.error(f"HTTP Error downloading file from HF ({hf_path}, owner: {owner_user_id}): {e}")
          status_code = e.response.status_code
-         error_message = f"Error downloading file ({status_code})"
-         if status_code == 404: error_message = "File not found on storage."
-         return Response(error_message, status=status_code, mimetype='text/plain')
+         logging.error(f"Error downloading file from HF ({hf_path}, owner: {owner_user_id}): HTTP {status_code} - {e}")
+         message = f"Ошибка скачивания файла ({status_code}). Возможно, файл был удал��н или доступ ограничен." if status_code in [401, 403, 404] else f"Ошибка сервера хранилища ({status_code})."
+         return Response(message, status=status_code)
     except requests.exceptions.RequestException as e:
-        logging.error(f"Network Error downloading file from HF ({hf_path}, owner: {owner_user_id}): {e}")
-        return Response("Error downloading file (Network Error)", status=502, mimetype='text/plain')
+        logging.error(f"Error downloading file from HF ({hf_path}, owner: {owner_user_id}): {e}")
+        return Response(f"Ошибка сети при скачивании файла.", status=504) # Gateway Timeout often indicates network issues
     except Exception as e:
-        logging.exception(f"Unexpected error during download ({hf_path}, owner: {owner_user_id}): {e}")
-        return Response("Internal server error during download", status=500, mimetype='text/plain')
+        logging.error(f"Unexpected error during download ({hf_path}, owner: {owner_user_id}): {e}", exc_info=True)
+        return Response("Внутренняя ошибка сервера при подготовке файла к скачиванию.", status=500)
 
 
 @app.route('/delete_file/<file_id>', methods=['POST'])
-def delete_file_route(file_id):
+def delete_file_route(file_id: str):
+    start_time = time.time()
     data = request.get_json()
-    if not data or 'initData' not in data: # Removed 'current_folder_id' dependency
-        return jsonify({"status": "error", "message": "Incomplete request"}), 400
+    if not data or 'initData' not in data or 'current_folder_id' not in data: # current_folder_id needed for context/logging
+        return jsonify({"status": "error", "message": "Неполный запрос"}), 400
 
     user_info = check_telegram_authorization(data['initData'], BOT_TOKEN)
     if not user_info or 'id' not in user_info:
-        return jsonify({"status": "error", "message": "Not authorized"}), 403
+        return jsonify({"status": "error", "message": "Ошибка авторизации"}), 403
 
     tg_user_id = str(user_info['id'])
+    logging.info(f"delete_file_route: User {tg_user_id} attempting to delete file ID '{file_id}'.")
 
     if not HF_TOKEN_WRITE:
-        return jsonify({'status': 'error', 'message': 'Deletion not configured (missing HF token).'}), 503
+        return jsonify({'status': 'error', 'message': 'Удаление невозможно: отсутствует ключ доступа к хранилищу.'}), 500
 
-    db_data = load_data()
-    user_data = db_data.get('users', {}).get(tg_user_id)
-    if not user_data or 'filesystem' not in user_data or not isinstance(user_data.get('filesystem'), dict):
-        logging.error(f"Delete file failed: User data or filesystem missing/invalid for user {tg_user_id}")
-        return jsonify({"status": "error", "message": "User data error"}), 500
+    try:
+        db_data = load_data()
+        user_data = db_data.get('users', {}).get(tg_user_id)
+        if not user_data or 'filesystem' not in user_data:
+            return jsonify({"status": "error", "message": "Ошибка данных пользователя"}), 500
 
-    file_node, parent_node = find_node_by_id(user_data['filesystem'], file_id)
+        file_node, parent_node = find_node_by_id(user_data['filesystem'], file_id)
 
-    if not file_node or file_node.get('type') != 'file' or not parent_node:
-        logging.warning(f"Delete request for non-existent file {file_id} by user {tg_user_id}")
-        return jsonify({'status': 'error', 'message': 'File not found or cannot be deleted.'}), 404
+        if not file_node or file_node.get('type') != 'file':
+            logging.warning(f"delete_file_route: File ID '{file_id}' not found or not a file for user {tg_user_id}.")
+            return jsonify({'status': 'error', 'message': 'Файл не найден.'}), 404
+        if not parent_node:
+             logging.error(f"delete_file_route: File ID '{file_id}' found but has no parent node (user {tg_user_id}). Filesystem corrupted?")
+             return jsonify({'status': 'error', 'message': 'Ошибка структуры данных: файл без родительской папки.'}), 500
 
-    hf_path = file_node.get('path')
-    original_filename = file_node.get('original_filename', 'file')
-    needs_save = False
-    hf_delete_success = False
 
-    if hf_path:
-        try:
-            api = HfApi()
-            logging.info(f"Attempting HF delete for {hf_path} by user {tg_user_id}")
-            api.delete_file(
-                path_in_repo=hf_path, repo_id=REPO_ID, repo_type="dataset", token=HF_TOKEN_WRITE,
-                commit_message=f"User {tg_user_id} deleted {original_filename}"
-            )
-            logging.info(f"Successfully deleted file {hf_path} from HF Hub for user {tg_user_id}")
-            hf_delete_success = True
-        except hf_utils.EntryNotFoundError:
-            logging.warning(f"File {hf_path} not found on HF Hub for delete attempt ({tg_user_id}). Assuming already deleted or inconsistent state.")
-            hf_delete_success = True # Treat as success for DB removal purpose
-        except Exception as e:
-            logging.error(f"Error deleting file from HF Hub ({hf_path}, {tg_user_id}): {e}")
-            # Decide whether to proceed with DB removal. Generally yes, to clean up metadata.
-            # return jsonify({'status': 'error', 'message': f'Error deleting file from storage: {e}'}), 500
-    else:
-        logging.warning(f"No HF path found for file node {file_id} during delete for user {tg_user_id}. Proceeding with DB removal.")
-        hf_delete_success = True # Allow DB removal if path is missing
+        hf_path = file_node.get('path')
+        original_filename = file_node.get('original_filename', 'файл')
+        needs_save = False
+        hf_delete_error = None
 
-    if hf_delete_success:
+        if hf_path:
+            try:
+                api = HfApi()
+                logging.info(f"delete_file_route: Attempting HF delete for path '{hf_path}' (user {tg_user_id}).")
+                api.delete_file(
+                    path_in_repo=hf_path,
+                    repo_id=REPO_ID,
+                    repo_type="dataset",
+                    token=HF_TOKEN_WRITE,
+                    commit_message=f"User {tg_user_id} deleted {original_filename} (id: {file_id})"
+                    # repo_revision="main" # Specify branch/revision if needed
+                )
+                logging.info(f"delete_file_route: Successfully deleted file '{hf_path}' from HF Hub for user {tg_user_id}.")
+            except hf_utils.EntryNotFoundError:
+                logging.warning(f"delete_file_route: File '{hf_path}' not found on HF Hub for delete attempt by user {tg_user_id}. Proceeding with DB removal.")
+                # This is not necessarily an error from the user's perspective if DB is out of sync
+            except Exception as e:
+                hf_delete_error = e
+                logging.error(f"delete_file_route: Error deleting file from HF Hub ('{hf_path}', user {tg_user_id}): {e}", exc_info=True)
+                # Decide if we should stop or continue to remove from DB.
+                # Let's continue to remove from DB to keep UI consistent, but report error.
+        else:
+            logging.warning(f"delete_file_route: No HF path found for file ID '{file_id}' (user {tg_user_id}). Removing only from DB.")
+
+
+        # Remove from filesystem structure regardless of HF delete outcome (unless HF delete failed critically?)
         if remove_node(user_data['filesystem'], file_id):
             needs_save = True
-            logging.info(f"Removed file node {file_id} from DB for user {tg_user_id}")
+            logging.info(f"delete_file_route: Removed file node '{file_id}' from DB structure for user {tg_user_id}.")
         else:
-            logging.error(f"Failed to remove file node {file_id} from DB structure for {tg_user_id} after potential HF delete.")
-            # This is a potential inconsistency state
-            return jsonify({'status': 'error', 'message': 'File deleted from storage (or wasn\'t found), but failed to update database.'}), 500
-    else:
-        # If HF delete failed explicitly (not 404), don't remove from DB yet
-        return jsonify({'status': 'error', 'message': 'Failed to delete file from storage. Database not updated.'}), 500
+            # This implies the node wasn't found by remove_node, even though find_node_by_id found it earlier. Odd.
+            logging.error(f"delete_file_route: Failed to remove file node {file_id} from DB structure for {tg_user_id} despite finding it earlier.")
+            # If HF delete succeeded, we have an orphaned file metadata entry conceptually.
 
-
-    if needs_save:
-        if save_data(db_data):
-            return jsonify({'status': 'ok', 'message': f'File "{original_filename}" deleted.'})
+        if needs_save:
+            try:
+                save_data(db_data)
+                elapsed = time.time() - start_time
+                if hf_delete_error:
+                    logging.warning(f"delete_file_route: Completed DB removal for file {file_id} (user {tg_user_id}) in {elapsed:.3f}s, but encountered HF delete error: {hf_delete_error}")
+                    return jsonify({'status': 'partial', 'message': f'Файл "{original_filename}" удален из списка, но произошла ошибка при удалении из хранилища.'}), 207
+                else:
+                    logging.info(f"delete_file_route: Successfully deleted file {file_id} and saved DB for user {tg_user_id} in {elapsed:.3f}s.")
+                    return jsonify({'status': 'ok', 'message': f'Файл "{original_filename}" удален.'})
+            except Exception as e:
+                logging.critical(f"delete_file_route: CRITICAL - Failed to save DB after removing file node {file_id} for user {tg_user_id}: {e}", exc_info=True)
+                # State is now inconsistent. File might be deleted from HF but still in DB (if save failed after successful HF delete)
+                # or removed from memory but not saved.
+                return jsonify({'status': 'error', 'message': 'Критическая ошибка сохранения базы данных после удаления файла.'}), 500
         else:
-            logging.error(f"CRITICAL: Delete file DB save error ({tg_user_id}) after node removal.")
-            # Data is inconsistent here. Node removed in memory, but not saved. HF file might be gone.
-            return jsonify({'status': 'error', 'message': 'File deleted, but error saving database update.'}), 500
-    else:
-         # Should not happen if hf_delete_success was true and remove_node failed, as that returns error above.
-         # This path implies HF delete failed and we didn't proceed.
-         return jsonify({'status': 'error', 'message': 'File could not be deleted.'}), 500
+             # remove_node failed, implying file wasn't really there in the structure
+             if hf_delete_error:
+                 # Both HF delete failed AND node remove failed
+                  return jsonify({'status': 'error', 'message': f'Не удалось удалить файл "{original_filename}" из хранилища и базы данных.'}), 500
+             else:
+                 # HF delete might have succeeded (or file wasn't found there), but node remove failed.
+                 return jsonify({'status': 'error', 'message': 'Файл не найден в базе данных для удаления.'}), 404 # Consistent with file not found
+
+    except Exception as e:
+        logging.error(f"delete_file_route: Unhandled exception for user {tg_user_id}, file {file_id}: {e}", exc_info=True)
+        return jsonify({"status": "error", "message": "Внутренняя ошибка сервера при удалении файла."}), 500
 
 
 @app.route('/delete_folder/<folder_id>', methods=['POST'])
-def delete_folder_route(folder_id):
+def delete_folder_route(folder_id: str):
+    start_time = time.time()
     if folder_id == 'root':
-         return jsonify({'status': 'error', 'message': 'Cannot delete the root folder.'}), 400
+         return jsonify({'status': 'error', 'message': 'Нельзя удалить корневую папку!'}), 400
 
     data = request.get_json()
-    if not data or 'initData' not in data: # Removed 'current_folder_id' dependency
-         return jsonify({"status": "error", "message": "Incomplete request"}), 400
+    if not data or 'initData' not in data or 'current_folder_id' not in data: # current_folder_id for context
+         return jsonify({"status": "error", "message": "Неполный запрос"}), 400
 
     user_info = check_telegram_authorization(data['initData'], BOT_TOKEN)
     if not user_info or 'id' not in user_info:
-        return jsonify({"status": "error", "message": "Not authorized"}), 403
+        return jsonify({"status": "error", "message": "Ошибка авторизации"}), 403
 
     tg_user_id = str(user_info['id'])
+    logging.info(f"delete_folder_route: User {tg_user_id} attempting to delete folder ID '{folder_id}'.")
 
-    db_data = load_data()
-    user_data = db_data.get('users', {}).get(tg_user_id)
-    if not user_data or 'filesystem' not in user_data or not isinstance(user_data.get('filesystem'), dict):
-        logging.error(f"Delete folder failed: User data or filesystem missing/invalid for user {tg_user_id}")
-        return jsonify({"status": "error", "message": "User data error"}), 500
+    # No HF token check needed for folder deletion as folders only exist in DB
+
+    try:
+        db_data = load_data()
+        user_data = db_data.get('users', {}).get(tg_user_id)
+        if not user_data or 'filesystem' not in user_data:
+            return jsonify({"status": "error", "message": "Ошибка данных пользователя"}), 500
 
-    folder_node, parent_node = find_node_by_id(user_data['filesystem'], folder_id)
+        folder_node, parent_node = find_node_by_id(user_data['filesystem'], folder_id)
 
-    if not folder_node or folder_node.get('type') != 'folder' or not parent_node:
-        logging.warning(f"Delete request for non-existent folder {folder_id} by user {tg_user_id}")
-        return jsonify({'status': 'error', 'message': 'Folder not found or cannot be deleted.'}), 404
+        if not folder_node or folder_node.get('type') != 'folder':
+             logging.warning(f"delete_folder_route: Folder ID '{folder_id}' not found or not a folder for user {tg_user_id}.")
+             return jsonify({'status': 'error', 'message': 'Папка не найдена.'}), 404
+        if not parent_node:
+             logging.error(f"delete_folder_route: Folder ID '{folder_id}' found but has no parent node (user {tg_user_id}). Filesystem corrupted?")
+             return jsonify({'status': 'error', 'message': 'Ошибка структуры данных: папка без родительской папки.'}), 500
 
-    folder_name = folder_node.get('name', 'folder')
+        folder_name = folder_node.get('name', 'папка')
 
-    if folder_node.get('children'):
-        logging.warning(f"Attempt to delete non-empty folder {folder_id} ('{folder_name}') by user {tg_user_id}")
-        return jsonify({'status': 'error', 'message': f'Folder "{folder_name}" is not empty. Only empty folders can be deleted.'}), 400
+        # Check if folder is empty
+        children = folder_node.get('children')
+        if children and isinstance(children, list) and len(children) > 0:
+            logging.warning(f"delete_folder_route: Attempt by user {tg_user_id} to delete non-empty folder '{folder_name}' (id: {folder_id}).")
+            return jsonify({'status': 'error', 'message': f'Папку "{folder_name}" можно удалить только если она пуста.'}), 400 # Bad Request or Conflict 409?
 
-    if remove_node(user_data['filesystem'], folder_id):
-        logging.info(f"Removed empty folder node {folder_id} ('{folder_name}') from DB for user {tg_user_id}")
-        if save_data(db_data):
-            return jsonify({'status': 'ok', 'message': f'Folder "{folder_name}" deleted.'})
+        # Proceed with removal
+        if remove_node(user_data['filesystem'], folder_id):
+            try:
+                save_data(db_data)
+                elapsed = time.time() - start_time
+                logging.info(f"delete_folder_route: Successfully deleted empty folder '{folder_name}' (id: {folder_id}) and saved DB for user {tg_user_id} in {elapsed:.3f}s.")
+                return jsonify({'status': 'ok', 'message': f'Папка "{folder_name}" удалена.'})
+            except Exception as e:
+                logging.critical(f"delete_folder_route: CRITICAL - Failed to save DB after removing folder node {folder_id} for user {tg_user_id}: {e}", exc_info=True)
+                # Folder removed from memory, but not saved. Inconsistent.
+                return jsonify({'status': 'error', 'message': 'Критическая ошибка сохранения базы данных после удаления папки.'}), 500
         else:
-            logging.error(f"CRITICAL: Delete folder save error ({tg_user_id}) after node removal.")
-            # Inconsistent state: folder removed in memory but not saved.
-            return jsonify({'status': 'error', 'message': 'Folder removed, but error saving database update.'}), 500
-    else:
-        logging.error(f"Failed to remove empty folder node {folder_id} from DB for {tg_user_id}")
-        return jsonify({'status': 'error', 'message': 'Failed to remove folder from database.'}), 500
+            # remove_node failed
+            logging.error(f"delete_folder_route: Failed to remove folder node {folder_id} from DB structure for {tg_user_id} despite checks passing.")
+            return jsonify({'status': 'error', 'message': 'Не удалось удалить папку из базы данных (внутренняя ошибка).'}), 500
+
+    except Exception as e:
+        logging.error(f"delete_folder_route: Unhandled exception for user {tg_user_id}, folder {folder_id}: {e}", exc_info=True)
+        return jsonify({"status": "error", "message": "Внутренняя ошибка сервера при удалении папки."}), 500
 
 
 @app.route('/get_text_content/<file_id>')
-def get_text_content_route(file_id):
-    owner_user_id, file_node = find_file_owner_and_node(file_id)
+def get_text_content_route(file_id: str):
+    start_time = time.time()
+    logging.info(f"get_text_content_route: Request for text content of file ID '{file_id}'.")
 
-    if not file_node or file_node.get('file_type') != 'text':
-        return Response("Text file not found", status=404, mimetype='text/plain')
+    # Public route, find file metadata
+    db_data = load_data()
+    file_node = None
+    owner_user_id = None
+
+    for user_id_iter, user_data_iter in db_data.get('users', {}).items():
+         if isinstance(user_data_iter, dict) and 'filesystem' in user_data_iter:
+             node, _ = find_node_by_id(user_data_iter['filesystem'], file_id)
+             # Check type is file and file_type is text (or potentially related like json, csv etc if needed)
+             if node and node.get('type') == 'file' and node.get('file_type') == 'text' and node.get('path'):
+                 file_node = node
+                 owner_user_id = user_id_iter
+                 break
+
+    if not file_node:
+        return Response("Текстовый файл не найден или не является текстовым файлом.", status=404)
 
     hf_path = file_node.get('path')
+    original_filename = file_node.get('original_filename', 'text_file.txt')
+
     if not hf_path:
-        return Response("Error: File path missing", status=500, mimetype='text/plain')
+        logging.error(f"get_text_content_route: Missing HF path for text file ID {file_id} (owner: {owner_user_id})")
+        return Response("Ошибка: Путь к файлу отсутствует.", status=500)
 
-    file_url = f"https://huggingface.co/datasets/{REPO_ID}/resolve/main/{hf_path}?download=true"
-    logging.info(f"Text content request for file_id: {file_id}, owner: {owner_user_id}, hf_path: {hf_path}")
+    file_url = f"https://huggingface.co/datasets/{REPO_ID}/resolve/main/{hf_path}?download=true" # Force download ensures we get raw content
+    logging.info(f"get_text_content_route: Fetching text content from HF URL: {file_url}")
 
     try:
-        headers = {}
+        headers = {"User-Agent": "ZeusCloudMiniApp/1.0"}
         if HF_TOKEN_READ:
             headers["authorization"] = f"Bearer {HF_TOKEN_READ}"
 
-        response = requests.get(file_url, headers=headers, timeout=15)
+        # Fetch the entire content, as we need to decode it
+        response = requests.get(file_url, headers=headers, timeout=20) # Shorter timeout for text files
         response.raise_for_status()
 
-        # Limit preview size to avoid browser issues
-        max_preview_size = 2 * 1024 * 1024 # 2 MB
-        content_length = int(response.headers.get('Content-Length', 0))
-
-        if content_length > max_preview_size:
-             logging.warning(f"Text file {file_id} too large for preview ({content_length} bytes)")
-             return Response(f"File is too large for preview (> {max_preview_size // 1024 // 1024}MB).", status=413, mimetype='text/plain')
+        # Limit preview size to prevent browser freeze with huge text files
+        max_preview_size = 2 * 1024 * 1024 # 2 MB limit for text preview
+        if len(response.content) > max_preview_size:
+             logging.warning(f"get_text_content_route: Text file {file_id} (owner: {owner_user_id}) is too large ({len(response.content)} bytes) for preview.")
+             return Response(f"Файл слишком большой для предпросмотра (>{max_preview_size // 1024 // 1024}MB). Скачайте его для просмотра.", status=413) # Payload Too Large
 
-        content = response.content
+        # Attempt to decode the content
         text_content = None
         detected_encoding = None
-        encodings_to_try = ['utf-8', 'cp1251', 'latin-1', 'utf-16']
+        # Try common encodings, starting with UTF-8
+        encodings_to_try = ['utf-8', 'cp1251', 'cp866', 'iso-8859-1', 'windows-1252']
+        for enc in encodings_to_try:
+             try:
+                 text_content = response.content.decode(enc)
+                 detected_encoding = enc
+                 logging.info(f"get_text_content_route: Decoded text file {file_id} using {enc}.")
+                 break
+             except UnicodeDecodeError:
+                 continue
+             except Exception as dec_err: # Catch other potential decoding errors
+                 logging.warning(f"get_text_content_route: Error decoding with {enc} for file {file_id}: {dec_err}")
+                 continue
 
-        try:
-            # Use requests' auto-detection first if available
-            detected_encoding = response.encoding
-            if detected_encoding:
-                 text_content = content.decode(detected_encoding)
-                 logging.info(f"Decoded text file {file_id} using detected encoding: {detected_encoding}")
-        except (UnicodeDecodeError, TypeError):
-             text_content = None # Reset if detected encoding failed
-
-        if text_content is None:
-            for enc in encodings_to_try:
-                 try:
-                     text_content = content.decode(enc)
-                     detected_encoding = enc
-                     logging.info(f"Decoded text file {file_id} using fallback encoding: {enc}")
-                     break
-                 except UnicodeDecodeError:
-                     continue
 
         if text_content is None:
-             logging.error(f"Could not decode text file {file_id} with any tried encoding.")
-             return Response("Could not determine file encoding.", status=500, mimetype='text/plain')
-
-        # Return as plain text with UTF-8 charset specified
+             # If all attempts fail, maybe try detecting or return error
+             logging.error(f"get_text_content_route: Failed to decode text file {file_id} (owner: {owner_user_id}) with common encodings.")
+             # You could try 'chardet' library here if installed, but adds dependency
+             # import chardet
+             # detected = chardet.detect(response.content)
+             # if detected['encoding']: ... try decoding with detected['encoding'] ...
+             return Response("Не удалось определить кодировку или декодировать текстовый файл.", status=500)
+
+        elapsed = time.time() - start_time
+        logging.info(f"get_text_content_route: Successfully retrieved and decoded text content for file {file_id} in {elapsed:.3f}s.")
+
+        # Return as plain text with UTF-8 charset specified for browser
         return Response(text_content, mimetype='text/plain; charset=utf-8')
 
     except requests.exceptions.HTTPError as e:
-         logging.error(f"HTTP Error fetching text content from HF ({hf_path}, owner {owner_user_id}): {e}")
          status_code = e.response.status_code
-         error_message = f"Error fetching content ({status_code})"
-         if status_code == 404: error_message = "File not found on storage."
-         return Response(error_message, status=status_code, mimetype='text/plain')
+         logging.error(f"Error fetching text content from HF ({hf_path}, owner {owner_user_id}): HTTP {status_code} - {e}")
+         message = f"Ошибка загрузки содержимого ({status_code})."
+         return Response(message, status=status_code)
     except requests.exceptions.RequestException as e:
-        logging.error(f"Network Error fetching text content from HF ({hf_path}, owner {owner_user_id}): {e}")
-        return Response("Error fetching content (Network Error)", status=502, mimetype='text/plain')
+        logging.error(f"Error fetching text content from HF ({hf_path}, owner {owner_user_id}): {e}")
+        return Response("Ошибка сети при загрузке содержимого.", status=504)
     except Exception as e:
-        logging.exception(f"Unexpected error fetching text content ({hf_path}, owner {owner_user_id}): {e}")
-        return Response("Internal server error", status=500, mimetype='text/plain')
+        logging.error(f"Unexpected error fetching text content ({hf_path}, owner {owner_user_id}): {e}", exc_info=True)
+        return Response("Внутренняя ошибка сервера при получении текста.", status=500)
 
 
 @app.route('/preview_thumb/<file_id>')
-def preview_thumb_route(file_id):
-    owner_user_id, file_node = find_file_owner_and_node(file_id)
+def preview_thumb_route(file_id: str):
+    # This serves potentially large images, keep similar logic to download but focus on images
+    start_time = time.time()
+    logging.debug(f"preview_thumb_route: Request for image preview ID '{file_id}'.")
+
+    db_data = load_data()
+    file_node = None
+    owner_user_id = None
+
+    for user_id_iter, user_data_iter in db_data.get('users', {}).items():
+        if isinstance(user_data_iter, dict) and 'filesystem' in user_data_iter:
+            node, _ = find_node_by_id(user_data_iter['filesystem'], file_id)
+            if node and node.get('type') == 'file' and node.get('file_type') == 'image' and node.get('path'):
+                 file_node = node
+                 owner_user_id = user_id_iter
+                 break
 
-    if not file_node or file_node.get('file_type') != 'image':
-        return Response("Image not found", status=404, mimetype='text/plain')
+    if not file_node:
+        logging.debug(f"preview_thumb_route: Image file ID '{file_id}' not found.")
+        # Return a placeholder image or 404? 404 is cleaner.
+        return Response("Изображение не найдено", status=404)
 
     hf_path = file_node.get('path')
     if not hf_path:
-        return Response("Error: File path missing", status=500, mimetype='text/plain')
+        logging.error(f"preview_thumb_route: Missing HF path for image ID {file_id} (owner: {owner_user_id})")
+        return Response("Ошибка: Путь к изображению не найден.", status=500)
 
-    # Use the raw file URL, not download=true for browser rendering
+    # Use the resolve URL directly for images
     file_url = f"https://huggingface.co/datasets/{REPO_ID}/resolve/main/{hf_path}"
-    logging.info(f"Image preview request for file_id: {file_id}, owner: {owner_user_id}, hf_path: {hf_path}")
+    logging.debug(f"preview_thumb_route: Streaming image from HF URL: {file_url}")
+
 
     try:
-        headers = {}
+        headers = {"User-Agent": "ZeusCloudMiniApp/1.0"}
         if HF_TOKEN_READ:
             headers["authorization"] = f"Bearer {HF_TOKEN_READ}"
 
-        # Use a shorter timeout for thumbnails
-        response = requests.get(file_url, headers=headers, stream=True, timeout=15)
+        response = requests.get(file_url, headers=headers, stream=True, timeout=30) # Timeout for images
         response.raise_for_status()
 
-        content_type = response.headers.get('Content-Type', 'image/jpeg')
-        # Basic check for image types
+        content_type = response.headers.get('Content-Type', 'application/octet-stream')
+        # Basic check if it looks like an image type
         if not content_type.startswith('image/'):
-            logging.warning(f"Preview requested for non-image content type '{content_type}' at {hf_path}")
-            return Response("Invalid content type for image preview", status=415, mimetype='text/plain')
+             logging.warning(f"preview_thumb_route: Content-Type from HF for {file_id} is '{content_type}', not image. Serving anyway.")
+             # Still try to serve it, browser might handle it.
 
-        # Stream the response directly
-        return Response(response.iter_content(chunk_size=65536),
-                        mimetype=content_type,
-                        headers={"Content-Length": response.headers.get('Content-Length')})
+        elapsed = time.time() - start_time
+        logging.debug(f"preview_thumb_route: Streaming image {file_id} ({content_type}) in {elapsed:.3f}s.")
+
+        # Stream the content directly
+        return Response(response.iter_content(chunk_size=65536), mimetype=content_type)
 
     except requests.exceptions.HTTPError as e:
-         logging.error(f"HTTP Error fetching preview from HF ({hf_path}, owner: {owner_user_id}): {e}")
          status_code = e.response.status_code
-         error_message = f"Error loading preview ({status_code})"
-         if status_code == 404: error_message = "Image not found on storage."
-         return Response(error_message, status=status_code, mimetype='text/plain')
+         logging.error(f"Error fetching preview from HF ({hf_path}, owner: {owner_user_id}): HTTP {status_code} - {e}")
+         return Response(f"Ошибка загрузки превью ({status_code})", status=status_code)
     except requests.exceptions.RequestException as e:
-        logging.error(f"Network Error fetching preview from HF ({hf_path}, owner: {owner_user_id}): {e}")
-        return Response("Error loading preview (Network Error)", status=502, mimetype='text/plain')
+        logging.error(f"Error fetching preview from HF ({hf_path}, owner: {owner_user_id}): {e}")
+        return Response("Ошибка сети при загрузке превью.", status=504)
     except Exception as e:
-        logging.exception(f"Unexpected error during preview ({hf_path}, owner: {owner_user_id}): {e}")
-        return Response("Internal server error loading preview", status=500, mimetype='text/plain')
+        logging.error(f"Unexpected error during preview ({hf_path}, owner: {owner_user_id}): {e}", exc_info=True)
+        return Response("Внутренняя ошибка сервера при загрузке превью.", status=500)
+
 
+# --- Main Execution ---
 if __name__ == '__main__':
+    print("Starting Zeus Cloud Mini App Server...")
+
+    # Perform mandatory environment variable checks
+    critical_error = False
     if not BOT_TOKEN or BOT_TOKEN == 'YOUR_BOT_TOKEN':
-        logging.critical("CRITICAL: TELEGRAM_BOT_TOKEN is not set correctly. Telegram authentication WILL FAIL.")
+        logging.critical("CRITICAL: TELEGRAM_BOT_TOKEN is not set or is default. Telegram authentication WILL FAIL.")
+        critical_error = True
     if not HF_TOKEN_WRITE:
-        logging.warning("HF_TOKEN_WRITE (write access) is not set. File uploads, deletions, and folder creation will fail.")
+        logging.critical("CRITICAL: HF_TOKEN (write access) is not set. File uploads and deletions WILL FAIL.")
+        critical_error = True
     if not HF_TOKEN_READ:
-        logging.warning("HF_TOKEN_READ is not set. File downloads/previews might fail if the HF dataset is private.")
+        logging.warning("WARNING: HF_TOKEN_READ is not set (or using write token). File downloads/previews might fail if the repo is private and read/write tokens differ.")
+    if not REPO_ID or '/' not in REPO_ID:
+         logging.critical(f"CRITICAL: REPO_ID '{REPO_ID}' seems invalid. It should be in 'namespace/repo_name' format.")
+         critical_error = True
+
+    if critical_error:
+        logging.error("Exiting due to critical configuration errors.")
+        exit(1)
+
+    logging.info(f"Configuration:")
+    logging.info(f"  - Bot Token: {'*' * (len(BOT_TOKEN) - 4)}{BOT_TOKEN[-4:]}")
+    logging.info(f"  - Data File: {DATA_FILE}")
+    logging.info(f"  - HF Repo ID: {REPO_ID}")
+    logging.info(f"  - HF Write Token: {'Set' if HF_TOKEN_WRITE else 'Not Set'}")
+    logging.info(f"  - HF Read Token: {'Set' if HF_TOKEN_READ else 'Not Set (Using Write Token or None)'}")
+    logging.info(f"  - Upload Folder: {UPLOAD_FOLDER}")
+    logging.info(f"  - Auth Lifetime: {AUTH_DATA_LIFETIME}s")
+
+    # Perform initial database download check synchronously before starting server
+    logging.info("Performing initial database check/download from Hugging Face...")
+    try:
+        download_db_from_hf()
+        # Attempt a load to catch immediate JSON errors
+        load_data()
+        cache.clear() # Clear cache after initial load
+        logging.info("Initial database check/load successful.")
+    except Exception as e:
+        logging.error(f"Error during initial database download/load: {e}", exc_info=True)
+        # Decide if this is fatal. If load_data fails, it returns empty, so server might start but be empty.
+        logging.warning("Server will start, but initial data load encountered issues.")
 
-    logging.info("Attempting initial database download/load...")
-    initial_data = load_data()
-    if initial_data == {'users': {}}:
-         logging.warning("Started with empty or unrecoverable database.")
-    else:
-         logging.info(f"Initial load successful. Found {len(initial_data.get('users',{}))} user(s).")
 
-    # Use waitress or gunicorn in production instead of Flask's built-in server
-    # Example: waitress-serve --host 0.0.0.0 --port 7860 'app (24):app'
-    app.run(debug=False, host='0.0.0.0', port=7860, threaded=True) # threaded=True for concurrent requests
\ No newline at end of file
+    # Consider using a more production-ready WSGI server like Gunicorn or Waitress
+    # For development/simple deployment, Flask's built-in server is okay.
+    # Example: gunicorn -w 4 -b 0.0.0.0:7860 app:app
+    logging.info("Starting Flask development server on http://0.0.0.0:7860")
+    app.run(debug=False, host='0.0.0.0', port=7860)