fix: guest membership

* make guest status a flag on users
* add logout handlers
* add logout notification for other users

.gitignore

@@ -2,3 +2,5 @@
 .run-dev.lock
 chattyness-webserver/static/
 */target/*
+e2e/node_modules
+e2e/playwright-report

apps/chattyness-app/src/main.rs

@@ -178,16 +178,22 @@ mod server {
             leptos_options: leptos_options.clone(),
             ws_state: ws_state.clone(),
             ws_config: config.websocket.clone(),
+            signup_config: config.signup.clone(),
         };
         let admin_api_state = chattyness_admin_ui::AdminAppState {
             pool: pool.clone(),
             leptos_options: leptos_options.clone(),
         };
 
+        // Create admin connection layer for RLS context on admin API routes
+        let admin_conn_layer =
+            chattyness_admin_ui::auth::AdminConnLayer::new(pool.clone());
+
         // Build nested API routers with their own state
         let user_api_router = chattyness_user_ui::api::api_router().with_state(user_api_state);
-        let admin_api_router =
-            chattyness_admin_ui::api::admin_api_router().with_state(admin_api_state);
+        let admin_api_router = chattyness_admin_ui::api::admin_api_router()
+            .layer(admin_conn_layer)
+            .with_state(admin_api_state);
 
         // Create RLS layer for row-level security
         let rls_layer = chattyness_user_ui::auth::RlsLayer::new(pool.clone());

apps/chattyness-owner/src/main.rs

@@ -108,6 +108,10 @@ mod server {
         // Shared assets directory for uploaded files (realm images, etc.)
         let assets_dir = Path::new("/srv/chattyness/assets");
 
+        // Create admin connection layer for RLS context
+        let admin_conn_layer =
+            chattyness_admin_ui::auth::AdminConnLayer::new(pool.clone());
+
         // Build the app
         let app = Router::new()
             // Redirect root to admin
@@ -115,7 +119,9 @@ mod server {
             // Nest API routes under /api/admin (matches frontend expectations when UI is at /admin)
             .nest(
                 "/api/admin",
-                chattyness_admin_ui::api::admin_api_router().with_state(app_state.clone()),
+                chattyness_admin_ui::api::admin_api_router()
+                    .layer(admin_conn_layer)
+                    .with_state(app_state.clone()),
             )
             // Uploaded assets (realm backgrounds, props, etc.) - must come before /static
             .nest_service("/assets/server", ServeDir::new(assets_dir.join("server")))

config.toml

@@ -16,3 +16,13 @@ stale_threshold_secs = 120
 
 # Clear all instance_members on server startup (recommended for single-server deployments)
 clear_on_startup = true
+
+[signup]
+# birthday: "ask" = show field during signup, omit = don't ask
+# birthday = "ask"
+
+# age: "ask" = user selects, "infer" = from birthday, "default_adult", "default_child"
+age = "default_adult"
+
+# gender: "ask" = user selects, "default_neutral", "default_male", "default_female"
+gender = "default_neutral"

crates/chattyness-admin-ui/Cargo.toml

@@ -24,6 +24,7 @@ leptos_router = { workspace = true }
 axum = { workspace = true, optional = true }
 axum-extra = { workspace = true, optional = true }
 sqlx = { workspace = true, optional = true }
+tower = { workspace = true, optional = true }
 tower-sessions = { workspace = true, optional = true }
 tower-sessions-sqlx-store = { workspace = true, optional = true }
 argon2 = { workspace = true, optional = true }
@@ -52,6 +53,7 @@ ssr = [
     "dep:axum",
     "dep:axum-extra",
     "dep:sqlx",
+    "dep:tower",
     "dep:tracing",
     "dep:tower-sessions",
     "dep:tower-sessions-sqlx-store",

crates/chattyness-admin-ui/src/api.rs

@@ -3,6 +3,8 @@
 #[cfg(feature = "ssr")]
 pub mod auth;
 #[cfg(feature = "ssr")]
+pub mod avatars;
+#[cfg(feature = "ssr")]
 pub mod config;
 #[cfg(feature = "ssr")]
 pub mod dashboard;

crates/chattyness-admin-ui/src/api/avatars.rs

@@ -0,0 +1,138 @@
+//! Server avatars management API handlers for admin UI.
+
+use axum::Json;
+use axum::extract::State;
+use chattyness_db::{
+    models::{CreateServerAvatarRequest, ServerAvatar, ServerAvatarSummary, UpdateServerAvatarRequest},
+    queries::server_avatars,
+};
+use chattyness_error::AppError;
+use serde::Serialize;
+use sqlx::PgPool;
+use uuid::Uuid;
+
+use crate::auth::AdminConn;
+
+// =============================================================================
+// API Types
+// =============================================================================
+
+/// Response for avatar creation.
+#[derive(Debug, Serialize)]
+pub struct CreateAvatarResponse {
+    pub id: Uuid,
+    pub slug: String,
+    pub name: String,
+    pub is_public: bool,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+}
+
+impl From<ServerAvatar> for CreateAvatarResponse {
+    fn from(avatar: ServerAvatar) -> Self {
+        Self {
+            id: avatar.id,
+            slug: avatar.slug,
+            name: avatar.name,
+            is_public: avatar.is_public,
+            created_at: avatar.created_at,
+        }
+    }
+}
+
+// =============================================================================
+// API Handlers
+// =============================================================================
+
+/// List all server avatars.
+pub async fn list_avatars(
+    State(pool): State<PgPool>,
+) -> Result<Json<Vec<ServerAvatarSummary>>, AppError> {
+    let avatars = server_avatars::list_all_server_avatars(&pool).await?;
+    Ok(Json(avatars))
+}
+
+/// Create a new server avatar.
+pub async fn create_avatar(
+    admin_conn: AdminConn,
+    Json(req): Json<CreateServerAvatarRequest>,
+) -> Result<Json<CreateAvatarResponse>, AppError> {
+    let conn = admin_conn.0;
+    let mut guard = conn.acquire().await;
+
+    // Validate the request
+    req.validate()?;
+
+    // Check slug availability
+    let slug = req.slug_or_generate();
+    let available = server_avatars::is_avatar_slug_available(&mut *guard, &slug).await?;
+    if !available {
+        return Err(AppError::Conflict(format!(
+            "Avatar slug '{}' is already taken",
+            slug
+        )));
+    }
+
+    // Create the avatar
+    let avatar = server_avatars::create_server_avatar(&mut *guard, &req, None).await?;
+
+    tracing::info!("Created server avatar: {} ({})", avatar.name, avatar.id);
+
+    Ok(Json(CreateAvatarResponse::from(avatar)))
+}
+
+/// Get a server avatar by ID.
+pub async fn get_avatar(
+    State(pool): State<PgPool>,
+    axum::extract::Path(avatar_id): axum::extract::Path<Uuid>,
+) -> Result<Json<ServerAvatar>, AppError> {
+    let avatar = server_avatars::get_server_avatar_by_id(&pool, avatar_id)
+        .await?
+        .ok_or_else(|| AppError::NotFound("Avatar not found".to_string()))?;
+    Ok(Json(avatar))
+}
+
+/// Update a server avatar.
+pub async fn update_avatar(
+    admin_conn: AdminConn,
+    axum::extract::Path(avatar_id): axum::extract::Path<Uuid>,
+    Json(req): Json<UpdateServerAvatarRequest>,
+) -> Result<Json<ServerAvatar>, AppError> {
+    let conn = admin_conn.0;
+    let mut guard = conn.acquire().await;
+
+    // Validate the request
+    req.validate()?;
+
+    // Check avatar exists
+    let existing = server_avatars::get_server_avatar_by_id(&mut *guard, avatar_id)
+        .await?
+        .ok_or_else(|| AppError::NotFound("Avatar not found".to_string()))?;
+
+    // Update the avatar
+    let avatar = server_avatars::update_server_avatar(&mut *guard, avatar_id, &req).await?;
+
+    tracing::info!("Updated server avatar: {} ({})", existing.name, avatar_id);
+
+    Ok(Json(avatar))
+}
+
+/// Delete a server avatar.
+pub async fn delete_avatar(
+    admin_conn: AdminConn,
+    axum::extract::Path(avatar_id): axum::extract::Path<Uuid>,
+) -> Result<Json<()>, AppError> {
+    let conn = admin_conn.0;
+    let mut guard = conn.acquire().await;
+
+    // Get the avatar first to log its name
+    let avatar = server_avatars::get_server_avatar_by_id(&mut *guard, avatar_id)
+        .await?
+        .ok_or_else(|| AppError::NotFound("Avatar not found".to_string()))?;
+
+    // Delete from database
+    server_avatars::delete_server_avatar(&mut *guard, avatar_id).await?;
+
+    tracing::info!("Deleted server avatar: {} ({})", avatar.name, avatar_id);
+
+    Ok(Json(()))
+}

crates/chattyness-admin-ui/src/api/props.rs

@@ -15,6 +15,8 @@ use sqlx::PgPool;
 use std::path::PathBuf;
 use uuid::Uuid;
 
+use crate::auth::AdminConn;
+
 // =============================================================================
 // API Types
 // =============================================================================
@@ -115,10 +117,12 @@ pub async fn list_props(
 /// Query parameters:
 /// - `force`: If true, update existing prop with same slug instead of returning 409 Conflict.
 pub async fn create_prop(
-    State(pool): State<PgPool>,
+    admin_conn: AdminConn,
     Query(query): Query<CreatePropQuery>,
     mut multipart: Multipart,
 ) -> Result<Json<CreatePropResponse>, AppError> {
+    let conn = admin_conn.0;
+
     let mut metadata: Option<CreateServerPropRequest> = None;
     let mut file_data: Option<(Vec<u8>, String)> = None; // (bytes, extension)
 
@@ -182,20 +186,23 @@ pub async fn create_prop(
     // Store the file first (SHA256-based, safe to run even if prop exists)
     let asset_path = store_prop_file(&file_bytes, &extension).await?;
 
+    // Acquire the connection for database operations
+    let mut guard = conn.acquire().await;
+
     let prop = if query.force {
         // Force mode: upsert (insert or update)
-        props::upsert_server_prop(&pool, &metadata, &asset_path, None).await?
+        props::upsert_server_prop(&mut *guard, &metadata, &asset_path, None).await?
     } else {
         // Normal mode: check availability first
         let slug = metadata.slug_or_generate();
-        let available = props::is_prop_slug_available(&pool, &slug).await?;
+        let available = props::is_prop_slug_available(&mut *guard, &slug).await?;
         if !available {
             return Err(AppError::Conflict(format!(
                 "Prop slug '{}' is already taken",
                 slug
             )));
         }
-        props::create_server_prop(&pool, &metadata, &asset_path, None).await?
+        props::create_server_prop(&mut *guard, &metadata, &asset_path, None).await?
     };
 
     let action = if query.force { "Upserted" } else { "Created" };
@@ -217,16 +224,19 @@ pub async fn get_prop(
 
 /// Delete a server prop.
 pub async fn delete_prop(
-    State(pool): State<PgPool>,
+    admin_conn: AdminConn,
     axum::extract::Path(prop_id): axum::extract::Path<Uuid>,
 ) -> Result<Json<()>, AppError> {
+    let conn = admin_conn.0;
+    let mut guard = conn.acquire().await;
+
     // Get the prop first to get the asset path
-    let prop = props::get_server_prop_by_id(&pool, prop_id)
+    let prop = props::get_server_prop_by_id(&mut *guard, prop_id)
         .await?
         .ok_or_else(|| AppError::NotFound("Prop not found".to_string()))?;
 
     // Delete from database
-    props::delete_server_prop(&pool, prop_id).await?;
+    props::delete_server_prop(&mut *guard, prop_id).await?;
 
     // Try to delete the file (don't fail if file doesn't exist)
     let file_path = PathBuf::from("/srv/chattyness/assets").join(&prop.asset_path);

crates/chattyness-admin-ui/src/api/realms.rs

@@ -5,14 +5,19 @@ use axum::{
     extract::{Path, Query, State},
 };
 use chattyness_db::{
-    models::{OwnerCreateRealmRequest, RealmDetail, RealmListItem, UpdateRealmRequest},
-    queries::owner as queries,
+    models::{
+        CreateRealmAvatarRequest, OwnerCreateRealmRequest, RealmAvatar, RealmAvatarSummary,
+        RealmDetail, RealmListItem, UpdateRealmAvatarRequest, UpdateRealmRequest,
+    },
+    queries::{owner as queries, realm_avatars},
 };
 use chattyness_error::AppError;
 use serde::{Deserialize, Serialize};
 use sqlx::PgPool;
 use uuid::Uuid;
 
+use crate::auth::AdminConn;
+
 /// Create realm response.
 #[derive(Debug, Serialize)]
 pub struct CreateRealmResponse {
@@ -63,6 +68,9 @@ pub async fn get_realm(
 }
 
 /// Create a new realm.
+///
+/// Note: Uses State(pool) instead of AdminConn because create_realm_with_new_owner
+/// uses transactions internally that require pool access.
 pub async fn create_realm(
     State(pool): State<PgPool>,
     Json(req): Json<OwnerCreateRealmRequest>,
@@ -107,6 +115,8 @@ pub async fn create_realm(
 }
 
 /// Update a realm.
+///
+/// Note: Uses State(pool) because owner queries use &PgPool directly.
 pub async fn update_realm(
     State(pool): State<PgPool>,
     Path(slug): Path<String>,
@@ -121,6 +131,9 @@ pub async fn update_realm(
 }
 
 /// Transfer realm ownership.
+///
+/// Note: Uses State(pool) instead of AdminConn because transfer_realm_ownership
+/// uses transactions internally that require pool access.
 pub async fn transfer_ownership(
     State(pool): State<PgPool>,
     Path(slug): Path<String>,
@@ -131,3 +144,157 @@ pub async fn transfer_ownership(
     queries::transfer_realm_ownership(&pool, existing.id, req.new_owner_id).await?;
     Ok(Json(()))
 }
+
+// =============================================================================
+// Realm Avatar Handlers
+// =============================================================================
+
+/// Response for realm avatar creation.
+#[derive(Debug, Serialize)]
+pub struct CreateRealmAvatarResponse {
+    pub id: Uuid,
+    pub slug: String,
+    pub name: String,
+    pub is_public: bool,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+}
+
+impl From<RealmAvatar> for CreateRealmAvatarResponse {
+    fn from(avatar: RealmAvatar) -> Self {
+        Self {
+            id: avatar.id,
+            slug: avatar.slug,
+            name: avatar.name,
+            is_public: avatar.is_public,
+            created_at: avatar.created_at,
+        }
+    }
+}
+
+/// List all avatars for a realm.
+pub async fn list_realm_avatars(
+    State(pool): State<PgPool>,
+    Path(slug): Path<String>,
+) -> Result<Json<Vec<RealmAvatarSummary>>, AppError> {
+    let realm = queries::get_realm_by_slug(&pool, &slug).await?;
+    let avatars = realm_avatars::list_all_realm_avatars(&pool, realm.id).await?;
+    Ok(Json(avatars))
+}
+
+/// Create a new realm avatar.
+pub async fn create_realm_avatar(
+    State(pool): State<PgPool>,
+    admin_conn: AdminConn,
+    Path(slug): Path<String>,
+    Json(req): Json<CreateRealmAvatarRequest>,
+) -> Result<Json<CreateRealmAvatarResponse>, AppError> {
+    let conn = admin_conn.0;
+    let mut guard = conn.acquire().await;
+
+    // Validate the request
+    req.validate()?;
+
+    // Get realm ID (uses pool because owner queries require it)
+    let realm = queries::get_realm_by_slug(&pool, &slug).await?;
+
+    // Check slug availability
+    let avatar_slug = req.slug_or_generate();
+    let available =
+        realm_avatars::is_avatar_slug_available(&mut *guard, realm.id, &avatar_slug).await?;
+    if !available {
+        return Err(AppError::Conflict(format!(
+            "Avatar slug '{}' is already taken in this realm",
+            avatar_slug
+        )));
+    }
+
+    // Create the avatar
+    let avatar = realm_avatars::create_realm_avatar(&mut *guard, realm.id, &req, None).await?;
+
+    tracing::info!(
+        "Created realm avatar: {} ({}) in realm {}",
+        avatar.name,
+        avatar.id,
+        slug
+    );
+
+    Ok(Json(CreateRealmAvatarResponse::from(avatar)))
+}
+
+/// Get a realm avatar by ID.
+pub async fn get_realm_avatar(
+    State(pool): State<PgPool>,
+    Path((slug, avatar_id)): Path<(String, Uuid)>,
+) -> Result<Json<RealmAvatar>, AppError> {
+    // Verify realm exists
+    let _realm = queries::get_realm_by_slug(&pool, &slug).await?;
+
+    let avatar = realm_avatars::get_realm_avatar_by_id(&pool, avatar_id)
+        .await?
+        .ok_or_else(|| AppError::NotFound("Avatar not found".to_string()))?;
+    Ok(Json(avatar))
+}
+
+/// Update a realm avatar.
+pub async fn update_realm_avatar(
+    State(pool): State<PgPool>,
+    admin_conn: AdminConn,
+    Path((slug, avatar_id)): Path<(String, Uuid)>,
+    Json(req): Json<UpdateRealmAvatarRequest>,
+) -> Result<Json<RealmAvatar>, AppError> {
+    let conn = admin_conn.0;
+    let mut guard = conn.acquire().await;
+
+    // Validate the request
+    req.validate()?;
+
+    // Verify realm exists (uses pool because owner queries require it)
+    let _realm = queries::get_realm_by_slug(&pool, &slug).await?;
+
+    // Check avatar exists
+    let existing = realm_avatars::get_realm_avatar_by_id(&mut *guard, avatar_id)
+        .await?
+        .ok_or_else(|| AppError::NotFound("Avatar not found".to_string()))?;
+
+    // Update the avatar
+    let avatar = realm_avatars::update_realm_avatar(&mut *guard, avatar_id, &req).await?;
+
+    tracing::info!(
+        "Updated realm avatar: {} ({}) in realm {}",
+        existing.name,
+        avatar_id,
+        slug
+    );
+
+    Ok(Json(avatar))
+}
+
+/// Delete a realm avatar.
+pub async fn delete_realm_avatar(
+    State(pool): State<PgPool>,
+    admin_conn: AdminConn,
+    Path((slug, avatar_id)): Path<(String, Uuid)>,
+) -> Result<Json<()>, AppError> {
+    let conn = admin_conn.0;
+    let mut guard = conn.acquire().await;
+
+    // Verify realm exists (uses pool because owner queries require it)
+    let _realm = queries::get_realm_by_slug(&pool, &slug).await?;
+
+    // Get the avatar first to log its name
+    let avatar = realm_avatars::get_realm_avatar_by_id(&mut *guard, avatar_id)
+        .await?
+        .ok_or_else(|| AppError::NotFound("Avatar not found".to_string()))?;
+
+    // Delete from database
+    realm_avatars::delete_realm_avatar(&mut *guard, avatar_id).await?;
+
+    tracing::info!(
+        "Deleted realm avatar: {} ({}) from realm {}",
+        avatar.name,
+        avatar_id,
+        slug
+    );
+
+    Ok(Json(()))
+}

crates/chattyness-admin-ui/src/api/routes.rs

@@ -5,7 +5,7 @@ use axum::{
     routing::{delete, get, post, put},
 };
 
-use super::{auth, config, dashboard, props, realms, scenes, spots, staff, users};
+use super::{auth, avatars, config, dashboard, props, realms, scenes, spots, staff, users};
 use crate::app::AdminAppState;
 
 /// Create the admin API router.
@@ -85,6 +85,28 @@ pub fn admin_api_router() -> Router<AdminAppState> {
             "/props/{prop_id}",
             get(props::get_prop).delete(props::delete_prop),
         )
+        // API - Server Avatars
+        .route(
+            "/avatars",
+            get(avatars::list_avatars).post(avatars::create_avatar),
+        )
+        .route(
+            "/avatars/{avatar_id}",
+            get(avatars::get_avatar)
+                .put(avatars::update_avatar)
+                .delete(avatars::delete_avatar),
+        )
+        // API - Realm Avatars
+        .route(
+            "/realms/{slug}/avatars",
+            get(realms::list_realm_avatars).post(realms::create_realm_avatar),
+        )
+        .route(
+            "/realms/{slug}/avatars/{avatar_id}",
+            get(realms::get_realm_avatar)
+                .put(realms::update_realm_avatar)
+                .delete(realms::delete_realm_avatar),
+        )
 }
 
 /// Health check endpoint.

crates/chattyness-admin-ui/src/api/scenes.rs

@@ -14,6 +14,8 @@ use sqlx::PgPool;
 use std::path::PathBuf;
 use uuid::Uuid;
 
+use crate::auth::AdminConn;
+
 // =============================================================================
 // Image Processing Helpers
 // =============================================================================
@@ -210,17 +212,20 @@ pub struct CreateSceneResponse {
 
 /// Create a new scene in a realm.
 pub async fn create_scene(
-    State(pool): State<PgPool>,
+    admin_conn: AdminConn,
     Path(slug): Path<String>,
     Json(mut req): Json<CreateSceneRequest>,
 ) -> Result<Json<CreateSceneResponse>, AppError> {
+    let conn = admin_conn.0;
+    let mut guard = conn.acquire().await;
+
     // Get the realm
-    let realm = realms::get_realm_by_slug(&pool, &slug)
+    let realm = realms::get_realm_by_slug(&mut *guard, &slug)
         .await?
         .ok_or_else(|| AppError::NotFound(format!("Realm '{}' not found", slug)))?;
 
     // Check if slug is available
-    let available = scenes::is_scene_slug_available(&pool, realm.id, &req.slug).await?;
+    let available = scenes::is_scene_slug_available(&mut *guard, realm.id, &req.slug).await?;
     if !available {
         return Err(AppError::Conflict(format!(
             "Scene slug '{}' is already taken in this realm",
@@ -249,7 +254,7 @@ pub async fn create_scene(
         }
     }
 
-    let scene = scenes::create_scene_with_id(&pool, scene_id, realm.id, &req).await?;
+    let scene = scenes::create_scene_with_id(&mut *guard, scene_id, realm.id, &req).await?;
     Ok(Json(CreateSceneResponse {
         id: scene.id,
         slug: scene.slug,
@@ -258,12 +263,15 @@ pub async fn create_scene(
 
 /// Update a scene.
 pub async fn update_scene(
-    State(pool): State<PgPool>,
+    admin_conn: AdminConn,
     Path(scene_id): Path<Uuid>,
     Json(mut req): Json<UpdateSceneRequest>,
 ) -> Result<Json<Scene>, AppError> {
+    let conn = admin_conn.0;
+    let mut guard = conn.acquire().await;
+
     // Get the existing scene to get realm_id
-    let existing_scene = scenes::get_scene_by_id(&pool, scene_id)
+    let existing_scene = scenes::get_scene_by_id(&mut *guard, scene_id)
         .await?
         .ok_or_else(|| AppError::NotFound("Scene not found".to_string()))?;
 
@@ -296,15 +304,17 @@ pub async fn update_scene(
         }
     }
 
-    let scene = scenes::update_scene(&pool, scene_id, &req).await?;
+    let scene = scenes::update_scene(&mut *guard, scene_id, &req).await?;
     Ok(Json(scene))
 }
 
 /// Delete a scene.
 pub async fn delete_scene(
-    State(pool): State<PgPool>,
+    admin_conn: AdminConn,
     Path(scene_id): Path<Uuid>,
 ) -> Result<Json<()>, AppError> {
-    scenes::delete_scene(&pool, scene_id).await?;
+    let conn = admin_conn.0;
+    let mut guard = conn.acquire().await;
+    scenes::delete_scene(&mut *guard, scene_id).await?;
     Ok(Json(()))
 }

crates/chattyness-admin-ui/src/api/spots.rs

@@ -13,6 +13,8 @@ use serde::Serialize;
 use sqlx::PgPool;
 use uuid::Uuid;
 
+use crate::auth::AdminConn;
+
 /// List all spots for a scene.
 pub async fn list_spots(
     State(pool): State<PgPool>,
@@ -41,13 +43,16 @@ pub struct CreateSpotResponse {
 
 /// Create a new spot in a scene.
 pub async fn create_spot(
-    State(pool): State<PgPool>,
+    admin_conn: AdminConn,
     Path(scene_id): Path<Uuid>,
     Json(req): Json<CreateSpotRequest>,
 ) -> Result<Json<CreateSpotResponse>, AppError> {
+    let conn = admin_conn.0;
+    let mut guard = conn.acquire().await;
+
     // Check if slug is available (if provided)
     if let Some(ref slug) = req.slug {
-        let available = spots::is_spot_slug_available(&pool, scene_id, slug).await?;
+        let available = spots::is_spot_slug_available(&mut *guard, scene_id, slug).await?;
         if !available {
             return Err(AppError::Conflict(format!(
                 "Spot slug '{}' is already taken in this scene",
@@ -56,25 +61,28 @@ pub async fn create_spot(
         }
     }
 
-    let spot = spots::create_spot(&pool, scene_id, &req).await?;
+    let spot = spots::create_spot(&mut *guard, scene_id, &req).await?;
     Ok(Json(CreateSpotResponse { id: spot.id }))
 }
 
 /// Update a spot.
 pub async fn update_spot(
-    State(pool): State<PgPool>,
+    admin_conn: AdminConn,
     Path(spot_id): Path<Uuid>,
     Json(req): Json<UpdateSpotRequest>,
 ) -> Result<Json<Spot>, AppError> {
+    let conn = admin_conn.0;
+    let mut guard = conn.acquire().await;
+
     // If updating slug, check availability
     if let Some(ref new_slug) = req.slug {
-        let existing = spots::get_spot_by_id(&pool, spot_id)
+        let existing = spots::get_spot_by_id(&mut *guard, spot_id)
             .await?
             .ok_or_else(|| AppError::NotFound("Spot not found".to_string()))?;
 
         if Some(new_slug.clone()) != existing.slug {
             let available =
-                spots::is_spot_slug_available(&pool, existing.scene_id, new_slug).await?;
+                spots::is_spot_slug_available(&mut *guard, existing.scene_id, new_slug).await?;
             if !available {
                 return Err(AppError::Conflict(format!(
                     "Spot slug '{}' is already taken in this scene",
@@ -84,15 +92,17 @@ pub async fn update_spot(
         }
     }
 
-    let spot = spots::update_spot(&pool, spot_id, &req).await?;
+    let spot = spots::update_spot(&mut *guard, spot_id, &req).await?;
     Ok(Json(spot))
 }
 
 /// Delete a spot.
 pub async fn delete_spot(
-    State(pool): State<PgPool>,
+    admin_conn: AdminConn,
     Path(spot_id): Path<Uuid>,
 ) -> Result<Json<()>, AppError> {
-    spots::delete_spot(&pool, spot_id).await?;
+    let conn = admin_conn.0;
+    let mut guard = conn.acquire().await;
+    spots::delete_spot(&mut *guard, spot_id).await?;
     Ok(Json(()))
 }

crates/chattyness-admin-ui/src/auth.rs

@@ -4,6 +4,12 @@
 //! - Server staff: Uses chattyness_owner pool (bypasses RLS, full access)
 //! - Realm admins: Uses chattyness_app pool (RLS enforces permissions)
 
+#[cfg(feature = "ssr")]
+mod admin_conn;
+
+#[cfg(feature = "ssr")]
+pub use admin_conn::{AdminConn, AdminConnError, AdminConnGuard, AdminConnLayer, AdminConnection};
+
 #[cfg(feature = "ssr")]
 use axum::{
     http::StatusCode,

crates/chattyness-admin-ui/src/auth/admin_conn.rs

@@ -0,0 +1,315 @@
+//! Admin connection extractor with RLS context.
+//!
+//! Provides database connections that set RLS context when a user is authenticated.
+//! Used by admin API handlers to ensure write operations respect RLS policies.
+//!
+//! - In owner app: No session, uses plain connection (RLS bypassed by chattyness_owner role)
+//! - In user app: Session exists, sets current_user_id() for RLS enforcement
+
+use axum::{
+    Json,
+    extract::FromRequestParts,
+    http::{Request, StatusCode, request::Parts},
+    response::{IntoResponse, Response},
+};
+use sqlx::{PgPool, Postgres, pool::PoolConnection, postgres::PgConnection};
+use std::{
+    future::Future,
+    ops::{Deref, DerefMut},
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+};
+use tokio::sync::{Mutex, MutexGuard};
+use tower::{Layer, Service};
+use tower_sessions::Session;
+use uuid::Uuid;
+
+use super::{ADMIN_SESSION_STAFF_ID_KEY, SESSION_USER_ID_KEY};
+use chattyness_error::ErrorResponse;
+
+// =============================================================================
+// Admin Connection Wrapper
+// =============================================================================
+
+struct AdminConnectionInner {
+    conn: Option<PoolConnection<Postgres>>,
+    pool: PgPool,
+    had_user_context: bool,
+}
+
+impl Drop for AdminConnectionInner {
+    fn drop(&mut self) {
+        if let Some(mut conn) = self.conn.take() {
+            // Only clear context if we set it
+            if self.had_user_context {
+                let pool = self.pool.clone();
+                tokio::spawn(async move {
+                    let _ = sqlx::query("SELECT public.set_current_user_id(NULL)")
+                        .execute(&mut *conn)
+                        .await;
+                    drop(conn);
+                    drop(pool);
+                });
+            }
+        }
+    }
+}
+
+/// A database connection with optional RLS user context set.
+#[derive(Clone)]
+pub struct AdminConnection {
+    inner: Arc<Mutex<AdminConnectionInner>>,
+}
+
+impl AdminConnection {
+    fn new(conn: PoolConnection<Postgres>, pool: PgPool, had_user_context: bool) -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(AdminConnectionInner {
+                conn: Some(conn),
+                pool,
+                had_user_context,
+            })),
+        }
+    }
+
+    /// Acquire exclusive access to the admin connection.
+    pub async fn acquire(&self) -> AdminConnGuard<'_> {
+        AdminConnGuard {
+            guard: self.inner.lock().await,
+        }
+    }
+}
+
+/// A guard providing mutable access to the admin database connection.
+pub struct AdminConnGuard<'a> {
+    guard: MutexGuard<'a, AdminConnectionInner>,
+}
+
+impl Deref for AdminConnGuard<'_> {
+    type Target = PgConnection;
+
+    fn deref(&self) -> &Self::Target {
+        self.guard
+            .conn
+            .as_ref()
+            .expect("AdminConnection already consumed")
+            .deref()
+    }
+}
+
+impl DerefMut for AdminConnGuard<'_> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.guard
+            .conn
+            .as_mut()
+            .expect("AdminConnection already consumed")
+            .deref_mut()
+    }
+}
+
+// =============================================================================
+// Admin Connection Extractor
+// =============================================================================
+
+/// Extractor for an admin database connection with RLS context.
+///
+/// Usage in handlers:
+/// ```ignore
+/// pub async fn create_scene(
+///     admin_conn: AdminConn,
+///     Json(req): Json<CreateSceneRequest>,
+/// ) -> Result<Json<Scene>, AppError> {
+///     let mut conn = admin_conn.0;
+///     let mut guard = conn.acquire().await;
+///     scenes::create_scene(&mut *guard, ...).await
+/// }
+/// ```
+pub struct AdminConn(pub AdminConnection);
+
+impl<S> FromRequestParts<S> for AdminConn
+where
+    S: Send + Sync,
+{
+    type Rejection = AdminConnError;
+
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
+        parts
+            .extensions
+            .remove::<AdminConnection>()
+            .map(AdminConn)
+            .ok_or(AdminConnError::NoConnection)
+    }
+}
+
+impl Deref for AdminConn {
+    type Target = AdminConnection;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for AdminConn {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+/// Errors related to admin connection handling.
+#[derive(Debug)]
+pub enum AdminConnError {
+    NoConnection,
+    DatabaseError(String),
+}
+
+impl IntoResponse for AdminConnError {
+    fn into_response(self) -> Response {
+        let (status, message) = match self {
+            AdminConnError::NoConnection => (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "Admin connection not available - is AdminConnLayer middleware configured?",
+            ),
+            AdminConnError::DatabaseError(msg) => (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                msg.leak() as &'static str,
+            ),
+        };
+
+        let body = ErrorResponse {
+            error: message.to_string(),
+            code: Some("ADMIN_CONN_ERROR".to_string()),
+        };
+
+        (status, Json(body)).into_response()
+    }
+}
+
+// =============================================================================
+// Admin Connection Middleware Layer
+// =============================================================================
+
+/// Layer that provides admin database connections with RLS context per request.
+///
+/// This middleware:
+/// 1. Checks for user_id in session (staff_id or user_id)
+/// 2. Acquires a connection from the pool
+/// 3. If user_id exists, calls `set_current_user_id($1)` for RLS
+/// 4. Inserts the connection into request extensions
+///
+/// Usage:
+/// ```ignore
+/// let app = Router::new()
+///     .nest("/api/admin", admin_api_router())
+///     .layer(AdminConnLayer::new(pool.clone()))
+///     .layer(session_layer);
+/// ```
+#[derive(Clone)]
+pub struct AdminConnLayer {
+    pool: PgPool,
+}
+
+impl AdminConnLayer {
+    pub fn new(pool: PgPool) -> Self {
+        Self { pool }
+    }
+}
+
+impl<S> Layer<S> for AdminConnLayer {
+    type Service = AdminConnMiddleware<S>;
+
+    fn layer(&self, inner: S) -> Self::Service {
+        AdminConnMiddleware {
+            inner,
+            pool: self.pool.clone(),
+        }
+    }
+}
+
+/// Middleware that sets up admin connections with RLS context per request.
+#[derive(Clone)]
+pub struct AdminConnMiddleware<S> {
+    inner: S,
+    pool: PgPool,
+}
+
+impl<S, B> Service<Request<B>> for AdminConnMiddleware<S>
+where
+    S: Service<Request<B>, Response = Response> + Clone + Send + 'static,
+    S::Future: Send,
+    B: Send + 'static,
+{
+    type Response = Response;
+    type Error = S::Error;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx)
+    }
+
+    fn call(&mut self, mut request: Request<B>) -> Self::Future {
+        let pool = self.pool.clone();
+        let mut inner = self.inner.clone();
+
+        let session = request.extensions().get::<Session>().cloned();
+
+        Box::pin(async move {
+            let user_id = get_admin_user_id(session).await;
+
+            match acquire_admin_connection(&pool, user_id).await {
+                Ok(admin_conn) => {
+                    request.extensions_mut().insert(admin_conn);
+                    inner.call(request).await
+                }
+                Err(e) => {
+                    tracing::error!("Failed to acquire admin connection: {}", e);
+                    Ok(AdminConnError::DatabaseError(e.to_string()).into_response())
+                }
+            }
+        })
+    }
+}
+
+/// Get user ID from session for RLS context.
+///
+/// Checks in order:
+/// 1. staff_id - server staff member
+/// 2. user_id - realm admin user
+///
+/// Returns None if no session or no user ID (owner app context).
+async fn get_admin_user_id(session: Option<Session>) -> Option<Uuid> {
+    let Some(session) = session else {
+        return None;
+    };
+
+    // Try staff_id first (server staff)
+    if let Ok(Some(staff_id)) = session.get::<Uuid>(ADMIN_SESSION_STAFF_ID_KEY).await {
+        return Some(staff_id);
+    }
+
+    // Try user_id (realm admin)
+    if let Ok(Some(user_id)) = session.get::<Uuid>(SESSION_USER_ID_KEY).await {
+        return Some(user_id);
+    }
+
+    None
+}
+
+/// Acquire a database connection and set RLS context if user_id is provided.
+async fn acquire_admin_connection(
+    pool: &PgPool,
+    user_id: Option<Uuid>,
+) -> Result<AdminConnection, sqlx::Error> {
+    let mut conn = pool.acquire().await?;
+
+    let had_user_context = user_id.is_some();
+
+    if let Some(user_id) = user_id {
+        sqlx::query("SELECT public.set_current_user_id($1)")
+            .bind(user_id)
+            .execute(&mut *conn)
+            .await?;
+    }
+
+    Ok(AdminConnection::new(conn, pool.clone(), had_user_context))
+}

crates/chattyness-admin-ui/src/components.rs

@@ -177,6 +177,8 @@ fn Sidebar(
     let realms_new_href = format!("{}/realms/new", base_path);
     let props_href = format!("{}/props", base_path);
     let props_new_href = format!("{}/props/new", base_path);
+    let avatars_href = format!("{}/avatars", base_path);
+    let avatars_new_href = format!("{}/avatars/new", base_path);
 
     view! {
         <nav class="sidebar">
@@ -259,6 +261,24 @@ fn Sidebar(
                                 />
                             </ul>
                         </li>
+
+                        <li class="nav-section">
+                            <span class="nav-section-title">"Avatars"</span>
+                            <ul class="nav-sublist">
+                                <NavItem
+                                    href=avatars_href.clone()
+                                    label="All Avatars"
+                                    active=current_page == "avatars"
+                                    sub=true
+                                />
+                                <NavItem
+                                    href=avatars_new_href.clone()
+                                    label="Create Avatar"
+                                    active=current_page == "avatars_new"
+                                    sub=true
+                                />
+                            </ul>
+                        </li>
                     }.into_any()
                 } else {
                     // Realm admin: show realm-specific options only

crates/chattyness-admin-ui/src/models.rs

@@ -95,6 +95,7 @@ pub struct RealmDetail {
     pub privacy: String,
     pub is_nsfw: bool,
     pub allow_guest_access: bool,
+    pub allow_user_teleport: bool,
     pub max_users: i32,
     pub theme_color: Option<String>,
     pub owner_id: String,
@@ -256,3 +257,73 @@ pub struct CreatePropResponse {
     pub slug: String,
     pub asset_path: String,
 }
+
+// =============================================================================
+// Avatar Models
+// =============================================================================
+
+/// Server avatar summary for list display.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct AvatarSummary {
+    pub id: String,
+    pub slug: String,
+    pub name: String,
+    pub description: Option<String>,
+    pub is_public: bool,
+    pub is_active: bool,
+    pub thumbnail_path: Option<String>,
+    pub created_at: String,
+}
+
+/// Server avatar detail from API.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct AvatarDetail {
+    pub id: String,
+    pub slug: String,
+    pub name: String,
+    pub description: Option<String>,
+    pub is_public: bool,
+    pub is_active: bool,
+    pub thumbnail_path: Option<String>,
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+/// Response for avatar creation.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct CreateAvatarResponse {
+    pub id: String,
+    pub slug: String,
+    pub name: String,
+    pub is_public: bool,
+    pub created_at: String,
+}
+
+/// Realm avatar summary for list display.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct RealmAvatarSummary {
+    pub id: String,
+    pub realm_id: String,
+    pub slug: String,
+    pub name: String,
+    pub description: Option<String>,
+    pub is_public: bool,
+    pub is_active: bool,
+    pub thumbnail_path: Option<String>,
+    pub created_at: String,
+}
+
+/// Realm avatar detail from API.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct RealmAvatarDetail {
+    pub id: String,
+    pub realm_id: String,
+    pub slug: String,
+    pub name: String,
+    pub description: Option<String>,
+    pub is_public: bool,
+    pub is_active: bool,
+    pub thumbnail_path: Option<String>,
+    pub created_at: String,
+    pub updated_at: String,
+}

crates/chattyness-admin-ui/src/pages.rs

@@ -1,11 +1,17 @@
 //! Admin interface Leptos page components.
 
+mod avatars;
+mod avatars_detail;
+mod avatars_new;
 mod config;
 mod dashboard;
 mod login;
 mod props;
 mod props_detail;
 mod props_new;
+mod realm_avatars;
+mod realm_avatars_detail;
+mod realm_avatars_new;
 mod realm_detail;
 mod realm_new;
 mod realms;
@@ -17,12 +23,18 @@ mod user_detail;
 mod user_new;
 mod users;
 
+pub use avatars::AvatarsPage;
+pub use avatars_detail::AvatarsDetailPage;
+pub use avatars_new::AvatarsNewPage;
 pub use config::ConfigPage;
 pub use dashboard::DashboardPage;
 pub use login::LoginPage;
 pub use props::PropsPage;
 pub use props_detail::PropsDetailPage;
 pub use props_new::PropsNewPage;
+pub use realm_avatars::RealmAvatarsPage;
+pub use realm_avatars_detail::RealmAvatarsDetailPage;
+pub use realm_avatars_new::RealmAvatarsNewPage;
 pub use realm_detail::RealmDetailPage;
 pub use realm_new::RealmNewPage;
 pub use realms::RealmsPage;

crates/chattyness-admin-ui/src/pages/avatars.rs

@@ -0,0 +1,188 @@
+//! Server avatars list page component.
+
+use leptos::prelude::*;
+
+use crate::components::{Card, EmptyState, PageHeader};
+use crate::hooks::use_fetch;
+use crate::models::AvatarSummary;
+
+/// View mode for avatars listing.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum ViewMode {
+    Table,
+    Grid,
+}
+
+/// Server avatars page component with table and grid views.
+#[component]
+pub fn AvatarsPage() -> impl IntoView {
+    let (view_mode, set_view_mode) = signal(ViewMode::Table);
+
+    let avatars = use_fetch::<Vec<AvatarSummary>>(|| "/api/admin/avatars".to_string());
+
+    view! {
+        <PageHeader title="Server Avatars" subtitle="Manage pre-configured avatar templates">
+            <div class="flex gap-2">
+                <button
+                    type="button"
+                    class=move || if view_mode.get() == ViewMode::Table {
+                        "btn btn-primary"
+                    } else {
+                        "btn btn-secondary"
+                    }
+                    on:click=move |_| set_view_mode.set(ViewMode::Table)
+                >
+                    "Table"
+                </button>
+                <button
+                    type="button"
+                    class=move || if view_mode.get() == ViewMode::Grid {
+                        "btn btn-primary"
+                    } else {
+                        "btn btn-secondary"
+                    }
+                    on:click=move |_| set_view_mode.set(ViewMode::Grid)
+                >
+                    "Grid"
+                </button>
+                <a href="/admin/avatars/new" class="btn btn-primary">"Create Avatar"</a>
+            </div>
+        </PageHeader>
+
+        <Card>
+            <Suspense fallback=|| view! { <p>"Loading avatars..."</p> }>
+                {move || {
+                    avatars.get().map(|maybe_avatars: Option<Vec<AvatarSummary>>| {
+                        match maybe_avatars {
+                            Some(avatar_list) if !avatar_list.is_empty() => {
+                                if view_mode.get() == ViewMode::Table {
+                                    view! { <AvatarsTable avatars=avatar_list.clone() /> }.into_any()
+                                } else {
+                                    view! { <AvatarsGrid avatars=avatar_list.clone() /> }.into_any()
+                                }
+                            }
+                            _ => view! {
+                                <EmptyState
+                                    message="No server avatars found."
+                                    action_href="/admin/avatars/new"
+                                    action_text="Create Avatar"
+                                />
+                            }.into_any()
+                        }
+                    })
+                }}
+            </Suspense>
+        </Card>
+    }
+}
+
+/// Table view for avatars.
+#[component]
+fn AvatarsTable(avatars: Vec<AvatarSummary>) -> impl IntoView {
+    view! {
+        <div class="table-container">
+            <table class="data-table">
+                <thead>
+                    <tr>
+                        <th>"Thumbnail"</th>
+                        <th>"Name"</th>
+                        <th>"Slug"</th>
+                        <th>"Public"</th>
+                        <th>"Active"</th>
+                        <th>"Created"</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {avatars.into_iter().map(|avatar| {
+                        let thumbnail_url = avatar.thumbnail_path.clone()
+                            .map(|p| format!("/assets/{}", p));
+                        view! {
+                            <tr>
+                                <td>
+                                    {thumbnail_url.map(|url| view! {
+                                        <img
+                                            src=url
+                                            alt=avatar.name.clone()
+                                            class="avatar-thumbnail"
+                                            style="width: 48px; height: 48px; object-fit: contain; border-radius: 4px;"
+                                        />
+                                    })}
+                                </td>
+                                <td>
+                                    <a href=format!("/admin/avatars/{}", avatar.id) class="table-link">
+                                        {avatar.name}
+                                    </a>
+                                </td>
+                                <td><code>{avatar.slug}</code></td>
+                                <td>
+                                    {if avatar.is_public {
+                                        view! { <span class="status-badge status-active">"Public"</span> }.into_any()
+                                    } else {
+                                        view! { <span class="status-badge status-inactive">"Private"</span> }.into_any()
+                                    }}
+                                </td>
+                                <td>
+                                    {if avatar.is_active {
+                                        view! { <span class="status-badge status-active">"Active"</span> }.into_any()
+                                    } else {
+                                        view! { <span class="status-badge status-inactive">"Inactive"</span> }.into_any()
+                                    }}
+                                </td>
+                                <td>{avatar.created_at}</td>
+                            </tr>
+                        }
+                    }).collect_view()}
+                </tbody>
+            </table>
+        </div>
+    }
+}
+
+/// Grid view for avatars with thumbnails.
+#[component]
+fn AvatarsGrid(avatars: Vec<AvatarSummary>) -> impl IntoView {
+    view! {
+        <div class="avatars-grid" style="display: grid; grid-template-columns: repeat(auto-fill, minmax(120px, 1fr)); gap: 16px; padding: 16px;">
+            {avatars.into_iter().map(|avatar| {
+                let thumbnail_url = avatar.thumbnail_path.clone()
+                    .map(|p| format!("/assets/{}", p))
+                    .unwrap_or_else(|| "/static/placeholder-avatar.svg".to_string());
+                let avatar_url = format!("/admin/avatars/{}", avatar.id);
+                let avatar_name_for_title = avatar.name.clone();
+                let avatar_name_for_alt = avatar.name.clone();
+                let avatar_name_for_label = avatar.name;
+                let is_active = avatar.is_active;
+                let is_public = avatar.is_public;
+                view! {
+                    <a
+                        href=avatar_url
+                        class="avatars-grid-item"
+                        style="display: flex; flex-direction: column; align-items: center; text-decoration: none; color: inherit; padding: 12px; border-radius: 8px; background: var(--bg-secondary, #1e293b); transition: background 0.2s; position: relative;"
+                        title=avatar_name_for_title
+                    >
+                        <img
+                            src=thumbnail_url
+                            alt=avatar_name_for_alt
+                            style="width: 80px; height: 80px; object-fit: contain; border-radius: 4px;"
+                        />
+                        <span style="font-size: 0.75rem; margin-top: 8px; text-align: center; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; max-width: 100%;">
+                            {avatar_name_for_label}
+                        </span>
+                        <div style="display: flex; gap: 4px; margin-top: 4px;">
+                            {if is_public {
+                                view! { <span class="status-badge status-active" style="font-size: 0.6rem; padding: 2px 4px;">"Public"</span> }.into_any()
+                            } else {
+                                view! { <span class="status-badge status-inactive" style="font-size: 0.6rem; padding: 2px 4px;">"Private"</span> }.into_any()
+                            }}
+                            {if !is_active {
+                                view! { <span class="status-badge status-inactive" style="font-size: 0.6rem; padding: 2px 4px;">"Inactive"</span> }.into_any()
+                            } else {
+                                view! {}.into_any()
+                            }}
+                        </div>
+                    </a>
+                }
+            }).collect_view()}
+        </div>
+    }
+}

crates/chattyness-admin-ui/src/pages/avatars_detail.rs

@@ -0,0 +1,306 @@
+//! Server avatar detail/edit page component.
+
+use leptos::prelude::*;
+#[cfg(feature = "hydrate")]
+use leptos::task::spawn_local;
+use leptos_router::hooks::use_params_map;
+
+use crate::components::{Card, DeleteConfirmation, DetailGrid, DetailItem, MessageAlert, PageHeader};
+use crate::hooks::use_fetch_if;
+use crate::models::AvatarDetail;
+use crate::utils::get_api_base;
+
+/// Server avatar detail page component.
+#[component]
+pub fn AvatarsDetailPage() -> impl IntoView {
+    let params = use_params_map();
+    let avatar_id = move || params.get().get("avatar_id").unwrap_or_default();
+    let initial_avatar_id = params.get_untracked().get("avatar_id").unwrap_or_default();
+
+    let (message, set_message) = signal(Option::<(String, bool)>::None);
+
+    let avatar = use_fetch_if::<AvatarDetail>(
+        move || !avatar_id().is_empty(),
+        move || format!("{}/avatars/{}", get_api_base(), avatar_id()),
+    );
+
+    view! {
+        <PageHeader title="Avatar Details" subtitle=format!("ID: {}", initial_avatar_id)>
+            <a href="/admin/avatars" class="btn btn-secondary">"Back to Avatars"</a>
+        </PageHeader>
+
+        <Suspense fallback=|| view! { <p>"Loading avatar..."</p> }>
+            {move || {
+                avatar.get().map(|maybe_avatar| {
+                    match maybe_avatar {
+                        Some(a) => view! {
+                            <AvatarDetailView avatar=a message=message set_message=set_message />
+                        }.into_any(),
+                        None => view! {
+                            <Card>
+                                <p class="text-error">"Avatar not found or you don't have permission to view."</p>
+                            </Card>
+                        }.into_any()
+                    }
+                })
+            }}
+        </Suspense>
+    }
+}
+
+#[component]
+#[allow(unused_variables)]
+fn AvatarDetailView(
+    avatar: AvatarDetail,
+    message: ReadSignal<Option<(String, bool)>>,
+    set_message: WriteSignal<Option<(String, bool)>>,
+) -> impl IntoView {
+    #[cfg(feature = "hydrate")]
+    let avatar_id = avatar.id.clone();
+    let slug_display = avatar.slug.clone();
+    let (pending, set_pending) = signal(false);
+    let (delete_pending, set_delete_pending) = signal(false);
+
+    // Form state
+    let (name, set_name) = signal(avatar.name.clone());
+    let (description, set_description) = signal(avatar.description.clone().unwrap_or_default());
+    let (is_public, set_is_public) = signal(avatar.is_public);
+    let (is_active, set_is_active) = signal(avatar.is_active);
+    let (thumbnail_path, set_thumbnail_path) = signal(
+        avatar.thumbnail_path.clone().unwrap_or_default(),
+    );
+
+    // Thumbnail preview
+    let thumbnail_preview = move || {
+        let path = thumbnail_path.get();
+        if path.is_empty() {
+            None
+        } else {
+            Some(format!("/assets/{}", path))
+        }
+    };
+
+    let on_submit = move |ev: leptos::ev::SubmitEvent| {
+        ev.prevent_default();
+        set_pending.set(true);
+        set_message.set(None);
+
+        #[cfg(feature = "hydrate")]
+        {
+            use gloo_net::http::Request;
+
+            let api_base = get_api_base();
+            let avatar_id = avatar_id.clone();
+            let data = serde_json::json!({
+                "name": name.get(),
+                "description": if description.get().is_empty() { None::<String> } else { Some(description.get()) },
+                "is_public": is_public.get(),
+                "is_active": is_active.get(),
+                "thumbnail_path": if thumbnail_path.get().is_empty() { None::<String> } else { Some(thumbnail_path.get()) }
+            });
+
+            spawn_local(async move {
+                let response = Request::put(&format!("{}/avatars/{}", api_base, avatar_id))
+                    .json(&data)
+                    .unwrap()
+                    .send()
+                    .await;
+
+                set_pending.set(false);
+
+                match response {
+                    Ok(resp) if resp.ok() => {
+                        set_message.set(Some(("Avatar updated successfully!".to_string(), true)));
+                    }
+                    Ok(_) => {
+                        set_message.set(Some(("Failed to update avatar".to_string(), false)));
+                    }
+                    Err(_) => {
+                        set_message.set(Some(("Network error".to_string(), false)));
+                    }
+                }
+            });
+        }
+    };
+
+    #[cfg(feature = "hydrate")]
+    let avatar_id_for_delete = avatar.id.clone();
+
+    let on_delete = move || {
+        set_delete_pending.set(true);
+
+        #[cfg(feature = "hydrate")]
+        {
+            use gloo_net::http::Request;
+
+            let api_base = get_api_base();
+            let avatar_id = avatar_id_for_delete.clone();
+
+            spawn_local(async move {
+                let response = Request::delete(&format!("{}/avatars/{}", api_base, avatar_id))
+                    .send()
+                    .await;
+
+                set_delete_pending.set(false);
+
+                match response {
+                    Ok(resp) if resp.ok() => {
+                        // Navigate back to avatars list
+                        crate::utils::navigate_to("/admin/avatars");
+                    }
+                    Ok(_) => {
+                        set_message.set(Some(("Failed to delete avatar".to_string(), false)));
+                    }
+                    Err(_) => {
+                        set_message.set(Some(("Network error".to_string(), false)));
+                    }
+                }
+            });
+        }
+    };
+
+    // Clone values for the view to avoid borrow issues
+    let avatar_name_for_alt = avatar.name.clone();
+    let avatar_name_header = avatar.name.clone();
+    let avatar_desc_header = avatar.description.clone().unwrap_or_default();
+    let avatar_id_display = avatar.id.clone();
+    let avatar_created = avatar.created_at.clone();
+    let avatar_updated = avatar.updated_at.clone();
+
+    view! {
+        <Card>
+            <div class="avatar-header" style="display: flex; align-items: center; gap: 16px; margin-bottom: 16px;">
+                {move || {
+                    let name_for_alt = avatar_name_for_alt.clone();
+                    thumbnail_preview().map(move |url| view! {
+                        <img
+                            src=url
+                            alt=name_for_alt
+                            style="width: 80px; height: 80px; object-fit: contain; border-radius: 8px; background: var(--bg-secondary, #1e293b);"
+                        />
+                    })
+                }}
+                <div class="avatar-info">
+                    <h2>{avatar_name_header}</h2>
+                    <p class="text-muted">{avatar_desc_header}</p>
+                </div>
+                <div class="avatar-badges" style="margin-left: auto; display: flex; gap: 8px;">
+                    {if avatar.is_public {
+                        view! { <span class="status-badge status-active">"Public"</span> }.into_any()
+                    } else {
+                        view! { <span class="status-badge status-inactive">"Private"</span> }.into_any()
+                    }}
+                    {if avatar.is_active {
+                        view! { <span class="status-badge status-active">"Active"</span> }.into_any()
+                    } else {
+                        view! { <span class="status-badge status-inactive">"Inactive"</span> }.into_any()
+                    }}
+                </div>
+            </div>
+
+            <DetailGrid>
+                <DetailItem label="ID">
+                    <code>{avatar_id_display}</code>
+                </DetailItem>
+                <DetailItem label="Slug">
+                    <code>{slug_display}</code>
+                </DetailItem>
+                <DetailItem label="Created">
+                    {avatar_created}
+                </DetailItem>
+                <DetailItem label="Updated">
+                    {avatar_updated}
+                </DetailItem>
+            </DetailGrid>
+        </Card>
+
+        <Card title="Edit Avatar Settings">
+            <form on:submit=on_submit>
+                <div class="form-group">
+                    <label for="name" class="form-label">"Name"</label>
+                    <input
+                        type="text"
+                        id="name"
+                        required=true
+                        class="form-input"
+                        prop:value=move || name.get()
+                        on:input=move |ev| set_name.set(event_target_value(&ev))
+                    />
+                </div>
+
+                <div class="form-group">
+                    <label for="description" class="form-label">"Description"</label>
+                    <textarea
+                        id="description"
+                        class="form-textarea"
+                        prop:value=move || description.get()
+                        on:input=move |ev| set_description.set(event_target_value(&ev))
+                    ></textarea>
+                </div>
+
+                <div class="form-group">
+                    <label for="thumbnail_path" class="form-label">"Thumbnail Path"</label>
+                    <input
+                        type="text"
+                        id="thumbnail_path"
+                        class="form-input"
+                        placeholder="avatars/thumbnails/avatar-name.png"
+                        prop:value=move || thumbnail_path.get()
+                        on:input=move |ev| set_thumbnail_path.set(event_target_value(&ev))
+                    />
+                    <small class="form-help">"Relative path to thumbnail image in assets folder."</small>
+                </div>
+
+                <div class="form-row">
+                    <div class="checkbox-group">
+                        <label class="checkbox-label">
+                            <input
+                                type="checkbox"
+                                class="form-checkbox"
+                                prop:checked=move || is_public.get()
+                                on:change=move |ev| set_is_public.set(event_target_checked(&ev))
+                            />
+                            "Public"
+                        </label>
+                        <small class="form-help">"Public avatars can be selected by users."</small>
+                    </div>
+                    <div class="checkbox-group">
+                        <label class="checkbox-label">
+                            <input
+                                type="checkbox"
+                                class="form-checkbox"
+                                prop:checked=move || is_active.get()
+                                on:change=move |ev| set_is_active.set(event_target_checked(&ev))
+                            />
+                            "Active"
+                        </label>
+                        <small class="form-help">"Inactive avatars are not shown to users."</small>
+                    </div>
+                </div>
+
+                <MessageAlert message=message />
+
+                <div class="form-actions">
+                    <button
+                        type="submit"
+                        class="btn btn-primary"
+                        disabled=move || pending.get()
+                    >
+                        {move || if pending.get() { "Saving..." } else { "Save Changes" }}
+                    </button>
+                </div>
+            </form>
+        </Card>
+
+        <Card title="Danger Zone" class="danger-zone">
+            <p class="text-warning">"Deleting an avatar is permanent and cannot be undone."</p>
+            <DeleteConfirmation
+                message="Are you sure you want to delete this avatar? This action cannot be undone."
+                button_text="Delete Avatar"
+                confirm_text="Yes, Delete Avatar"
+                pending=delete_pending
+                on_confirm=on_delete
+            />
+        </Card>
+    }
+}

crates/chattyness-admin-ui/src/pages/avatars_new.rs

@@ -0,0 +1,222 @@
+//! Create new server avatar page component.
+
+use leptos::prelude::*;
+#[cfg(feature = "hydrate")]
+use leptos::task::spawn_local;
+
+use crate::components::{Card, PageHeader};
+
+/// Server avatar new page component.
+#[component]
+pub fn AvatarsNewPage() -> impl IntoView {
+    // Form state
+    let (name, set_name) = signal(String::new());
+    let (slug, set_slug) = signal(String::new());
+    let (description, set_description) = signal(String::new());
+    let (is_public, set_is_public) = signal(true);
+    let (thumbnail_path, set_thumbnail_path) = signal(String::new());
+
+    // UI state
+    let (message, set_message) = signal(Option::<(String, bool)>::None);
+    let (pending, set_pending) = signal(false);
+    let (created_id, _set_created_id) = signal(Option::<String>::None);
+    #[cfg(feature = "hydrate")]
+    let set_created_id = _set_created_id;
+    let (slug_auto, set_slug_auto) = signal(true);
+
+    let update_name = move |ev: leptos::ev::Event| {
+        let new_name = event_target_value(&ev);
+        set_name.set(new_name.clone());
+        if slug_auto.get() {
+            let new_slug = new_name
+                .to_lowercase()
+                .chars()
+                .map(|c| if c.is_alphanumeric() { c } else { '-' })
+                .collect::<String>()
+                .trim_matches('-')
+                .to_string();
+            set_slug.set(new_slug);
+        }
+    };
+
+    let on_submit = move |ev: leptos::ev::SubmitEvent| {
+        ev.prevent_default();
+        set_pending.set(true);
+        set_message.set(None);
+
+        #[cfg(feature = "hydrate")]
+        {
+            use gloo_net::http::Request;
+
+            let data = serde_json::json!({
+                "name": name.get(),
+                "slug": if slug.get().is_empty() { None::<String> } else { Some(slug.get()) },
+                "description": if description.get().is_empty() { None::<String> } else { Some(description.get()) },
+                "is_public": is_public.get(),
+                "thumbnail_path": if thumbnail_path.get().is_empty() { None::<String> } else { Some(thumbnail_path.get()) }
+            });
+
+            spawn_local(async move {
+                let response = Request::post("/api/admin/avatars")
+                    .json(&data)
+                    .unwrap()
+                    .send()
+                    .await;
+
+                set_pending.set(false);
+
+                match response {
+                    Ok(resp) if resp.ok() => {
+                        #[derive(serde::Deserialize)]
+                        struct CreateResponse {
+                            id: String,
+                            #[allow(dead_code)]
+                            name: String,
+                            #[allow(dead_code)]
+                            slug: String,
+                        }
+                        if let Ok(result) = resp.json::<CreateResponse>().await {
+                            set_created_id.set(Some(result.id));
+                            set_message.set(Some(("Avatar created successfully!".to_string(), true)));
+                        }
+                    }
+                    Ok(resp) => {
+                        #[derive(serde::Deserialize)]
+                        struct ErrorResp {
+                            error: String,
+                        }
+                        if let Ok(err) = resp.json::<ErrorResp>().await {
+                            set_message.set(Some((err.error, false)));
+                        } else {
+                            set_message.set(Some(("Failed to create avatar".to_string(), false)));
+                        }
+                    }
+                    Err(_) => {
+                        set_message.set(Some(("Network error".to_string(), false)));
+                    }
+                }
+            });
+        }
+    };
+
+    view! {
+        <PageHeader title="Create Server Avatar" subtitle="Add a new pre-configured avatar template">
+            <a href="/admin/avatars" class="btn btn-secondary">"Back to Avatars"</a>
+        </PageHeader>
+
+        <Card>
+            <form on:submit=on_submit>
+                <h3 class="section-title">"Avatar Details"</h3>
+
+                <div class="form-row">
+                    <div class="form-group">
+                        <label for="name" class="form-label">
+                            "Name" <span class="required">"*"</span>
+                        </label>
+                        <input
+                            type="text"
+                            id="name"
+                            required=true
+                            class="form-input"
+                            placeholder="Happy Robot"
+                            prop:value=move || name.get()
+                            on:input=update_name
+                        />
+                    </div>
+                    <div class="form-group">
+                        <label for="slug" class="form-label">"Slug (URL)"</label>
+                        <input
+                            type="text"
+                            id="slug"
+                            pattern="[a-z0-9][a-z0-9\\-]*[a-z0-9]|[a-z0-9]"
+                            class="form-input"
+                            placeholder="happy-robot"
+                            prop:value=move || slug.get()
+                            on:input=move |ev| {
+                                set_slug_auto.set(false);
+                                set_slug.set(event_target_value(&ev));
+                            }
+                        />
+                        <small class="form-help">"Optional. Auto-generated from name if not provided."</small>
+                    </div>
+                </div>
+
+                <div class="form-group">
+                    <label for="description" class="form-label">"Description"</label>
+                    <textarea
+                        id="description"
+                        class="form-textarea"
+                        placeholder="A cheerful robot avatar for friendly chats"
+                        prop:value=move || description.get()
+                        on:input=move |ev| set_description.set(event_target_value(&ev))
+                    ></textarea>
+                </div>
+
+                <div class="form-group">
+                    <label for="thumbnail_path" class="form-label">"Thumbnail Path"</label>
+                    <input
+                        type="text"
+                        id="thumbnail_path"
+                        class="form-input"
+                        placeholder="avatars/thumbnails/happy-robot.png"
+                        prop:value=move || thumbnail_path.get()
+                        on:input=move |ev| set_thumbnail_path.set(event_target_value(&ev))
+                    />
+                    <small class="form-help">"Relative path to thumbnail image in assets folder."</small>
+                </div>
+
+                <h3 class="section-title">"Visibility"</h3>
+
+                <div class="checkbox-group">
+                    <label class="checkbox-label">
+                        <input
+                            type="checkbox"
+                            class="form-checkbox"
+                            prop:checked=move || is_public.get()
+                            on:change=move |ev| set_is_public.set(event_target_checked(&ev))
+                        />
+                        "Public"
+                    </label>
+                    <small class="form-help">"Public avatars can be selected by users. Private avatars are only available to admins."</small>
+                </div>
+
+                <Show when=move || message.get().is_some()>
+                    {move || {
+                        let (msg, is_success) = message.get().unwrap_or_default();
+                        let class = if is_success { "alert alert-success" } else { "alert alert-error" };
+                        view! {
+                            <div class=class role="alert">
+                                <p>{msg}</p>
+                            </div>
+                        }
+                    }}
+                </Show>
+
+                <Show when=move || created_id.get().is_some()>
+                    {move || {
+                        let id = created_id.get().unwrap_or_default();
+                        view! {
+                            <div class="alert alert-info">
+                                <p>
+                                    <a href=format!("/admin/avatars/{}", id)>
+                                        "View avatar"
+                                    </a>
+                                </p>
+                            </div>
+                        }
+                    }}
+                </Show>
+
+                <div class="form-actions">
+                    <button
+                        type="submit"
+                        class="btn btn-primary"
+                        disabled=move || pending.get()
+                    >
+                        {move || if pending.get() { "Creating..." } else { "Create Avatar" }}
+                    </button>
+                </div>
+            </form>
+        </Card>
+    }
+}

crates/chattyness-admin-ui/src/pages/realm_avatars.rs

@@ -0,0 +1,203 @@
+//! Realm avatars list page component.
+
+use leptos::prelude::*;
+use leptos_router::hooks::use_params_map;
+
+use crate::components::{Card, EmptyState, PageHeader};
+use crate::hooks::use_fetch_if;
+use crate::models::RealmAvatarSummary;
+use crate::utils::get_api_base;
+
+/// View mode for avatars listing.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum ViewMode {
+    Table,
+    Grid,
+}
+
+/// Realm avatars page component with table and grid views.
+#[component]
+pub fn RealmAvatarsPage() -> impl IntoView {
+    let params = use_params_map();
+    let slug = move || params.get().get("slug").unwrap_or_default();
+    let initial_slug = params.get_untracked().get("slug").unwrap_or_default();
+
+    let (view_mode, set_view_mode) = signal(ViewMode::Table);
+
+    let avatars = use_fetch_if::<Vec<RealmAvatarSummary>>(
+        move || !slug().is_empty(),
+        move || format!("{}/realms/{}/avatars", get_api_base(), slug()),
+    );
+
+    let slug_for_new = initial_slug.clone();
+    let slug_for_back = initial_slug.clone();
+
+    view! {
+        <PageHeader title="Realm Avatars" subtitle=format!("Manage avatars for /{}", initial_slug)>
+            <div class="flex gap-2">
+                <button
+                    type="button"
+                    class=move || if view_mode.get() == ViewMode::Table {
+                        "btn btn-primary"
+                    } else {
+                        "btn btn-secondary"
+                    }
+                    on:click=move |_| set_view_mode.set(ViewMode::Table)
+                >
+                    "Table"
+                </button>
+                <button
+                    type="button"
+                    class=move || if view_mode.get() == ViewMode::Grid {
+                        "btn btn-primary"
+                    } else {
+                        "btn btn-secondary"
+                    }
+                    on:click=move |_| set_view_mode.set(ViewMode::Grid)
+                >
+                    "Grid"
+                </button>
+                <a href=format!("/admin/realms/{}/avatars/new", slug_for_new) class="btn btn-primary">"Create Avatar"</a>
+                <a href=format!("/admin/realms/{}", slug_for_back) class="btn btn-secondary">"Back to Realm"</a>
+            </div>
+        </PageHeader>
+
+        <Card>
+            <Suspense fallback=|| view! { <p>"Loading avatars..."</p> }>
+                {move || {
+                    let slug = slug();
+                    avatars.get().map(move |maybe_avatars: Option<Vec<RealmAvatarSummary>>| {
+                        match maybe_avatars {
+                            Some(avatar_list) if !avatar_list.is_empty() => {
+                                if view_mode.get() == ViewMode::Table {
+                                    view! { <RealmAvatarsTable avatars=avatar_list.clone() realm_slug=slug.clone() /> }.into_any()
+                                } else {
+                                    view! { <RealmAvatarsGrid avatars=avatar_list.clone() realm_slug=slug.clone() /> }.into_any()
+                                }
+                            }
+                            _ => view! {
+                                <EmptyState
+                                    message="No realm avatars found."
+                                    action_href=format!("/admin/realms/{}/avatars/new", slug).leak()
+                                    action_text="Create Avatar"
+                                />
+                            }.into_any()
+                        }
+                    })
+                }}
+            </Suspense>
+        </Card>
+    }
+}
+
+/// Table view for realm avatars.
+#[component]
+fn RealmAvatarsTable(avatars: Vec<RealmAvatarSummary>, realm_slug: String) -> impl IntoView {
+    view! {
+        <div class="table-container">
+            <table class="data-table">
+                <thead>
+                    <tr>
+                        <th>"Thumbnail"</th>
+                        <th>"Name"</th>
+                        <th>"Slug"</th>
+                        <th>"Public"</th>
+                        <th>"Active"</th>
+                        <th>"Created"</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {avatars.into_iter().map(|avatar| {
+                        let thumbnail_url = avatar.thumbnail_path.clone()
+                            .map(|p| format!("/assets/{}", p));
+                        let detail_url = format!("/admin/realms/{}/avatars/{}", realm_slug, avatar.id);
+                        view! {
+                            <tr>
+                                <td>
+                                    {thumbnail_url.map(|url| view! {
+                                        <img
+                                            src=url
+                                            alt=avatar.name.clone()
+                                            class="avatar-thumbnail"
+                                            style="width: 48px; height: 48px; object-fit: contain; border-radius: 4px;"
+                                        />
+                                    })}
+                                </td>
+                                <td>
+                                    <a href=detail_url class="table-link">
+                                        {avatar.name}
+                                    </a>
+                                </td>
+                                <td><code>{avatar.slug}</code></td>
+                                <td>
+                                    {if avatar.is_public {
+                                        view! { <span class="status-badge status-active">"Public"</span> }.into_any()
+                                    } else {
+                                        view! { <span class="status-badge status-inactive">"Private"</span> }.into_any()
+                                    }}
+                                </td>
+                                <td>
+                                    {if avatar.is_active {
+                                        view! { <span class="status-badge status-active">"Active"</span> }.into_any()
+                                    } else {
+                                        view! { <span class="status-badge status-inactive">"Inactive"</span> }.into_any()
+                                    }}
+                                </td>
+                                <td>{avatar.created_at}</td>
+                            </tr>
+                        }
+                    }).collect_view()}
+                </tbody>
+            </table>
+        </div>
+    }
+}
+
+/// Grid view for realm avatars with thumbnails.
+#[component]
+fn RealmAvatarsGrid(avatars: Vec<RealmAvatarSummary>, realm_slug: String) -> impl IntoView {
+    view! {
+        <div class="avatars-grid" style="display: grid; grid-template-columns: repeat(auto-fill, minmax(120px, 1fr)); gap: 16px; padding: 16px;">
+            {avatars.into_iter().map(|avatar| {
+                let thumbnail_url = avatar.thumbnail_path.clone()
+                    .map(|p| format!("/assets/{}", p))
+                    .unwrap_or_else(|| "/static/placeholder-avatar.svg".to_string());
+                let avatar_url = format!("/admin/realms/{}/avatars/{}", realm_slug, avatar.id);
+                let avatar_name_for_title = avatar.name.clone();
+                let avatar_name_for_alt = avatar.name.clone();
+                let avatar_name_for_label = avatar.name;
+                let is_active = avatar.is_active;
+                let is_public = avatar.is_public;
+                view! {
+                    <a
+                        href=avatar_url
+                        class="avatars-grid-item"
+                        style="display: flex; flex-direction: column; align-items: center; text-decoration: none; color: inherit; padding: 12px; border-radius: 8px; background: var(--bg-secondary, #1e293b); transition: background 0.2s; position: relative;"
+                        title=avatar_name_for_title
+                    >
+                        <img
+                            src=thumbnail_url
+                            alt=avatar_name_for_alt
+                            style="width: 80px; height: 80px; object-fit: contain; border-radius: 4px;"
+                        />
+                        <span style="font-size: 0.75rem; margin-top: 8px; text-align: center; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; max-width: 100%;">
+                            {avatar_name_for_label}
+                        </span>
+                        <div style="display: flex; gap: 4px; margin-top: 4px;">
+                            {if is_public {
+                                view! { <span class="status-badge status-active" style="font-size: 0.6rem; padding: 2px 4px;">"Public"</span> }.into_any()
+                            } else {
+                                view! { <span class="status-badge status-inactive" style="font-size: 0.6rem; padding: 2px 4px;">"Private"</span> }.into_any()
+                            }}
+                            {if !is_active {
+                                view! { <span class="status-badge status-inactive" style="font-size: 0.6rem; padding: 2px 4px;">"Inactive"</span> }.into_any()
+                            } else {
+                                view! {}.into_any()
+                            }}
+                        </div>
+                    </a>
+                }
+            }).collect_view()}
+        </div>
+    }
+}

crates/chattyness-admin-ui/src/pages/realm_avatars_detail.rs

@@ -0,0 +1,332 @@
+//! Realm avatar detail/edit page component.
+
+use leptos::prelude::*;
+#[cfg(feature = "hydrate")]
+use leptos::task::spawn_local;
+use leptos_router::hooks::use_params_map;
+
+use crate::components::{Card, DeleteConfirmation, DetailGrid, DetailItem, MessageAlert, PageHeader};
+use crate::hooks::use_fetch_if;
+use crate::models::RealmAvatarDetail;
+use crate::utils::get_api_base;
+
+/// Realm avatar detail page component.
+#[component]
+pub fn RealmAvatarsDetailPage() -> impl IntoView {
+    let params = use_params_map();
+    let realm_slug = move || params.get().get("slug").unwrap_or_default();
+    let avatar_id = move || params.get().get("avatar_id").unwrap_or_default();
+    let initial_realm_slug = params.get_untracked().get("slug").unwrap_or_default();
+    let initial_avatar_id = params.get_untracked().get("avatar_id").unwrap_or_default();
+
+    let (message, set_message) = signal(Option::<(String, bool)>::None);
+
+    let avatar = use_fetch_if::<RealmAvatarDetail>(
+        move || !realm_slug().is_empty() && !avatar_id().is_empty(),
+        move || format!("{}/realms/{}/avatars/{}", get_api_base(), realm_slug(), avatar_id()),
+    );
+
+    let realm_slug_for_back = initial_realm_slug.clone();
+
+    view! {
+        <PageHeader title="Realm Avatar Details" subtitle=format!("ID: {}", initial_avatar_id)>
+            <a href=format!("/admin/realms/{}/avatars", realm_slug_for_back) class="btn btn-secondary">"Back to Avatars"</a>
+        </PageHeader>
+
+        <Suspense fallback=|| view! { <p>"Loading avatar..."</p> }>
+            {move || {
+                let realm_slug = initial_realm_slug.clone();
+                avatar.get().map(move |maybe_avatar| {
+                    match maybe_avatar {
+                        Some(a) => view! {
+                            <RealmAvatarDetailView
+                                avatar=a
+                                realm_slug=realm_slug.clone()
+                                message=message
+                                set_message=set_message
+                            />
+                        }.into_any(),
+                        None => view! {
+                            <Card>
+                                <p class="text-error">"Avatar not found or you don't have permission to view."</p>
+                            </Card>
+                        }.into_any()
+                    }
+                })
+            }}
+        </Suspense>
+    }
+}
+
+#[component]
+#[allow(unused_variables)]
+fn RealmAvatarDetailView(
+    avatar: RealmAvatarDetail,
+    realm_slug: String,
+    message: ReadSignal<Option<(String, bool)>>,
+    set_message: WriteSignal<Option<(String, bool)>>,
+) -> impl IntoView {
+    #[cfg(feature = "hydrate")]
+    let avatar_id = avatar.id.clone();
+    #[cfg(feature = "hydrate")]
+    let realm_slug_for_api = realm_slug.clone();
+    let realm_slug_for_delete = realm_slug.clone();
+    let slug_display = avatar.slug.clone();
+    let (pending, set_pending) = signal(false);
+    let (delete_pending, set_delete_pending) = signal(false);
+
+    // Form state
+    let (name, set_name) = signal(avatar.name.clone());
+    let (description, set_description) = signal(avatar.description.clone().unwrap_or_default());
+    let (is_public, set_is_public) = signal(avatar.is_public);
+    let (is_active, set_is_active) = signal(avatar.is_active);
+    let (thumbnail_path, set_thumbnail_path) = signal(
+        avatar.thumbnail_path.clone().unwrap_or_default(),
+    );
+
+    // Thumbnail preview
+    let thumbnail_preview = move || {
+        let path = thumbnail_path.get();
+        if path.is_empty() {
+            None
+        } else {
+            Some(format!("/assets/{}", path))
+        }
+    };
+
+    let on_submit = move |ev: leptos::ev::SubmitEvent| {
+        ev.prevent_default();
+        set_pending.set(true);
+        set_message.set(None);
+
+        #[cfg(feature = "hydrate")]
+        {
+            use gloo_net::http::Request;
+
+            let api_base = get_api_base();
+            let avatar_id = avatar_id.clone();
+            let realm_slug = realm_slug_for_api.clone();
+            let data = serde_json::json!({
+                "name": name.get(),
+                "description": if description.get().is_empty() { None::<String> } else { Some(description.get()) },
+                "is_public": is_public.get(),
+                "is_active": is_active.get(),
+                "thumbnail_path": if thumbnail_path.get().is_empty() { None::<String> } else { Some(thumbnail_path.get()) }
+            });
+
+            spawn_local(async move {
+                let response = Request::put(&format!("{}/realms/{}/avatars/{}", api_base, realm_slug, avatar_id))
+                    .json(&data)
+                    .unwrap()
+                    .send()
+                    .await;
+
+                set_pending.set(false);
+
+                match response {
+                    Ok(resp) if resp.ok() => {
+                        set_message.set(Some(("Avatar updated successfully!".to_string(), true)));
+                    }
+                    Ok(_) => {
+                        set_message.set(Some(("Failed to update avatar".to_string(), false)));
+                    }
+                    Err(_) => {
+                        set_message.set(Some(("Network error".to_string(), false)));
+                    }
+                }
+            });
+        }
+    };
+
+    #[cfg(feature = "hydrate")]
+    let avatar_id_for_delete = avatar.id.clone();
+    #[cfg(feature = "hydrate")]
+    let realm_slug_for_delete_api = realm_slug_for_delete.clone();
+
+    let on_delete = move || {
+        set_delete_pending.set(true);
+
+        #[cfg(feature = "hydrate")]
+        {
+            use gloo_net::http::Request;
+
+            let api_base = get_api_base();
+            let avatar_id = avatar_id_for_delete.clone();
+            let realm_slug = realm_slug_for_delete_api.clone();
+            let nav_slug = realm_slug_for_delete.clone();
+
+            spawn_local(async move {
+                let response = Request::delete(&format!("{}/realms/{}/avatars/{}", api_base, realm_slug, avatar_id))
+                    .send()
+                    .await;
+
+                set_delete_pending.set(false);
+
+                match response {
+                    Ok(resp) if resp.ok() => {
+                        // Navigate back to avatars list
+                        crate::utils::navigate_to(&format!("/admin/realms/{}/avatars", nav_slug));
+                    }
+                    Ok(_) => {
+                        set_message.set(Some(("Failed to delete avatar".to_string(), false)));
+                    }
+                    Err(_) => {
+                        set_message.set(Some(("Network error".to_string(), false)));
+                    }
+                }
+            });
+        }
+    };
+
+    // Clone for the view
+    let avatar_name_header = avatar.name.clone();
+    let avatar_desc_header = avatar.description.clone().unwrap_or_default();
+    let avatar_id_display = avatar.id.clone();
+    let avatar_created = avatar.created_at.clone();
+    let avatar_updated = avatar.updated_at.clone();
+
+    // Additional clone for the closure
+    let avatar_name_for_alt = avatar_name_header.clone();
+
+    view! {
+        <Card>
+            <div class="avatar-header" style="display: flex; align-items: center; gap: 16px; margin-bottom: 16px;">
+                {move || {
+                    let name_for_alt = avatar_name_for_alt.clone();
+                    thumbnail_preview().map(move |url| view! {
+                        <img
+                            src=url
+                            alt=name_for_alt
+                            style="width: 80px; height: 80px; object-fit: contain; border-radius: 8px; background: var(--bg-secondary, #1e293b);"
+                        />
+                    })
+                }}
+                <div class="avatar-info">
+                    <h2>{avatar_name_header}</h2>
+                    <p class="text-muted">{avatar_desc_header}</p>
+                </div>
+                <div class="avatar-badges" style="margin-left: auto; display: flex; gap: 8px;">
+                    {if avatar.is_public {
+                        view! { <span class="status-badge status-active">"Public"</span> }.into_any()
+                    } else {
+                        view! { <span class="status-badge status-inactive">"Private"</span> }.into_any()
+                    }}
+                    {if avatar.is_active {
+                        view! { <span class="status-badge status-active">"Active"</span> }.into_any()
+                    } else {
+                        view! { <span class="status-badge status-inactive">"Inactive"</span> }.into_any()
+                    }}
+                </div>
+            </div>
+
+            <DetailGrid>
+                <DetailItem label="ID">
+                    <code>{avatar_id_display}</code>
+                </DetailItem>
+                <DetailItem label="Slug">
+                    <code>{slug_display}</code>
+                </DetailItem>
+                <DetailItem label="Realm">
+                    <a href=format!("/admin/realms/{}", realm_slug) class="table-link">
+                        {realm_slug.clone()}
+                    </a>
+                </DetailItem>
+                <DetailItem label="Created">
+                    {avatar_created}
+                </DetailItem>
+                <DetailItem label="Updated">
+                    {avatar_updated}
+                </DetailItem>
+            </DetailGrid>
+        </Card>
+
+        <Card title="Edit Avatar Settings">
+            <form on:submit=on_submit>
+                <div class="form-group">
+                    <label for="name" class="form-label">"Name"</label>
+                    <input
+                        type="text"
+                        id="name"
+                        required=true
+                        class="form-input"
+                        prop:value=move || name.get()
+                        on:input=move |ev| set_name.set(event_target_value(&ev))
+                    />
+                </div>
+
+                <div class="form-group">
+                    <label for="description" class="form-label">"Description"</label>
+                    <textarea
+                        id="description"
+                        class="form-textarea"
+                        prop:value=move || description.get()
+                        on:input=move |ev| set_description.set(event_target_value(&ev))
+                    ></textarea>
+                </div>
+
+                <div class="form-group">
+                    <label for="thumbnail_path" class="form-label">"Thumbnail Path"</label>
+                    <input
+                        type="text"
+                        id="thumbnail_path"
+                        class="form-input"
+                        placeholder="avatars/thumbnails/avatar-name.png"
+                        prop:value=move || thumbnail_path.get()
+                        on:input=move |ev| set_thumbnail_path.set(event_target_value(&ev))
+                    />
+                    <small class="form-help">"Relative path to thumbnail image in assets folder."</small>
+                </div>
+
+                <div class="form-row">
+                    <div class="checkbox-group">
+                        <label class="checkbox-label">
+                            <input
+                                type="checkbox"
+                                class="form-checkbox"
+                                prop:checked=move || is_public.get()
+                                on:change=move |ev| set_is_public.set(event_target_checked(&ev))
+                            />
+                            "Public"
+                        </label>
+                        <small class="form-help">"Public avatars can be selected by users."</small>
+                    </div>
+                    <div class="checkbox-group">
+                        <label class="checkbox-label">
+                            <input
+                                type="checkbox"
+                                class="form-checkbox"
+                                prop:checked=move || is_active.get()
+                                on:change=move |ev| set_is_active.set(event_target_checked(&ev))
+                            />
+                            "Active"
+                        </label>
+                        <small class="form-help">"Inactive avatars are not shown to users."</small>
+                    </div>
+                </div>
+
+                <MessageAlert message=message />
+
+                <div class="form-actions">
+                    <button
+                        type="submit"
+                        class="btn btn-primary"
+                        disabled=move || pending.get()
+                    >
+                        {move || if pending.get() { "Saving..." } else { "Save Changes" }}
+                    </button>
+                </div>
+            </form>
+        </Card>
+
+        <Card title="Danger Zone" class="danger-zone">
+            <p class="text-warning">"Deleting an avatar is permanent and cannot be undone."</p>
+            <DeleteConfirmation
+                message="Are you sure you want to delete this avatar? This action cannot be undone."
+                button_text="Delete Avatar"
+                confirm_text="Yes, Delete Avatar"
+                pending=delete_pending
+                on_confirm=on_delete
+            />
+        </Card>
+    }
+}

crates/chattyness-admin-ui/src/pages/realm_avatars_new.rs

@@ -0,0 +1,239 @@
+//! Create new realm avatar page component.
+
+use leptos::prelude::*;
+#[cfg(feature = "hydrate")]
+use leptos::task::spawn_local;
+use leptos_router::hooks::use_params_map;
+
+use crate::components::{Card, PageHeader};
+#[cfg(feature = "hydrate")]
+use crate::utils::get_api_base;
+
+/// Realm avatar new page component.
+#[component]
+pub fn RealmAvatarsNewPage() -> impl IntoView {
+    let params = use_params_map();
+    #[allow(unused_variables)]
+    let slug = move || params.get().get("slug").unwrap_or_default();
+    let initial_slug = params.get_untracked().get("slug").unwrap_or_default();
+
+    // Form state
+    let (name, set_name) = signal(String::new());
+    let (avatar_slug, set_avatar_slug) = signal(String::new());
+    let (description, set_description) = signal(String::new());
+    let (is_public, set_is_public) = signal(true);
+    let (thumbnail_path, set_thumbnail_path) = signal(String::new());
+
+    // UI state
+    let (message, set_message) = signal(Option::<(String, bool)>::None);
+    let (pending, set_pending) = signal(false);
+    let (created_id, _set_created_id) = signal(Option::<String>::None);
+    #[cfg(feature = "hydrate")]
+    let set_created_id = _set_created_id;
+    let (slug_auto, set_slug_auto) = signal(true);
+
+    let update_name = move |ev: leptos::ev::Event| {
+        let new_name = event_target_value(&ev);
+        set_name.set(new_name.clone());
+        if slug_auto.get() {
+            let new_slug = new_name
+                .to_lowercase()
+                .chars()
+                .map(|c| if c.is_alphanumeric() { c } else { '-' })
+                .collect::<String>()
+                .trim_matches('-')
+                .to_string();
+            set_avatar_slug.set(new_slug);
+        }
+    };
+
+    let slug_for_back = initial_slug.clone();
+    let slug_for_view = initial_slug.clone();
+
+    let on_submit = move |ev: leptos::ev::SubmitEvent| {
+        ev.prevent_default();
+        set_pending.set(true);
+        set_message.set(None);
+
+        #[cfg(feature = "hydrate")]
+        {
+            use gloo_net::http::Request;
+
+            let api_base = get_api_base();
+            let realm_slug = slug();
+            let data = serde_json::json!({
+                "name": name.get(),
+                "slug": if avatar_slug.get().is_empty() { None::<String> } else { Some(avatar_slug.get()) },
+                "description": if description.get().is_empty() { None::<String> } else { Some(description.get()) },
+                "is_public": is_public.get(),
+                "thumbnail_path": if thumbnail_path.get().is_empty() { None::<String> } else { Some(thumbnail_path.get()) }
+            });
+
+            spawn_local(async move {
+                let response = Request::post(&format!("{}/realms/{}/avatars", api_base, realm_slug))
+                    .json(&data)
+                    .unwrap()
+                    .send()
+                    .await;
+
+                set_pending.set(false);
+
+                match response {
+                    Ok(resp) if resp.ok() => {
+                        #[derive(serde::Deserialize)]
+                        struct CreateResponse {
+                            id: String,
+                            #[allow(dead_code)]
+                            name: String,
+                            #[allow(dead_code)]
+                            slug: String,
+                        }
+                        if let Ok(result) = resp.json::<CreateResponse>().await {
+                            set_created_id.set(Some(result.id));
+                            set_message.set(Some(("Avatar created successfully!".to_string(), true)));
+                        }
+                    }
+                    Ok(resp) => {
+                        #[derive(serde::Deserialize)]
+                        struct ErrorResp {
+                            error: String,
+                        }
+                        if let Ok(err) = resp.json::<ErrorResp>().await {
+                            set_message.set(Some((err.error, false)));
+                        } else {
+                            set_message.set(Some(("Failed to create avatar".to_string(), false)));
+                        }
+                    }
+                    Err(_) => {
+                        set_message.set(Some(("Network error".to_string(), false)));
+                    }
+                }
+            });
+        }
+    };
+
+    view! {
+        <PageHeader title="Create Realm Avatar" subtitle=format!("Add a new avatar for /{}", initial_slug)>
+            <a href=format!("/admin/realms/{}/avatars", slug_for_back) class="btn btn-secondary">"Back to Avatars"</a>
+        </PageHeader>
+
+        <Card>
+            <form on:submit=on_submit>
+                <h3 class="section-title">"Avatar Details"</h3>
+
+                <div class="form-row">
+                    <div class="form-group">
+                        <label for="name" class="form-label">
+                            "Name" <span class="required">"*"</span>
+                        </label>
+                        <input
+                            type="text"
+                            id="name"
+                            required=true
+                            class="form-input"
+                            placeholder="Happy Robot"
+                            prop:value=move || name.get()
+                            on:input=update_name
+                        />
+                    </div>
+                    <div class="form-group">
+                        <label for="slug" class="form-label">"Slug (URL)"</label>
+                        <input
+                            type="text"
+                            id="slug"
+                            pattern="[a-z0-9][a-z0-9\\-]*[a-z0-9]|[a-z0-9]"
+                            class="form-input"
+                            placeholder="happy-robot"
+                            prop:value=move || avatar_slug.get()
+                            on:input=move |ev| {
+                                set_slug_auto.set(false);
+                                set_avatar_slug.set(event_target_value(&ev));
+                            }
+                        />
+                        <small class="form-help">"Optional. Auto-generated from name if not provided."</small>
+                    </div>
+                </div>
+
+                <div class="form-group">
+                    <label for="description" class="form-label">"Description"</label>
+                    <textarea
+                        id="description"
+                        class="form-textarea"
+                        placeholder="A cheerful robot avatar for friendly chats"
+                        prop:value=move || description.get()
+                        on:input=move |ev| set_description.set(event_target_value(&ev))
+                    ></textarea>
+                </div>
+
+                <div class="form-group">
+                    <label for="thumbnail_path" class="form-label">"Thumbnail Path"</label>
+                    <input
+                        type="text"
+                        id="thumbnail_path"
+                        class="form-input"
+                        placeholder="avatars/thumbnails/happy-robot.png"
+                        prop:value=move || thumbnail_path.get()
+                        on:input=move |ev| set_thumbnail_path.set(event_target_value(&ev))
+                    />
+                    <small class="form-help">"Relative path to thumbnail image in assets folder."</small>
+                </div>
+
+                <h3 class="section-title">"Visibility"</h3>
+
+                <div class="checkbox-group">
+                    <label class="checkbox-label">
+                        <input
+                            type="checkbox"
+                            class="form-checkbox"
+                            prop:checked=move || is_public.get()
+                            on:change=move |ev| set_is_public.set(event_target_checked(&ev))
+                        />
+                        "Public"
+                    </label>
+                    <small class="form-help">"Public avatars can be selected by users. Private avatars are only available to admins."</small>
+                </div>
+
+                <Show when=move || message.get().is_some()>
+                    {move || {
+                        let (msg, is_success) = message.get().unwrap_or_default();
+                        let class = if is_success { "alert alert-success" } else { "alert alert-error" };
+                        view! {
+                            <div class=class role="alert">
+                                <p>{msg}</p>
+                            </div>
+                        }
+                    }}
+                </Show>
+
+                <Show when=move || created_id.get().is_some()>
+                    {
+                        let realm_slug = slug_for_view.clone();
+                        move || {
+                            let id = created_id.get().unwrap_or_default();
+                            let realm_slug = realm_slug.clone();
+                            view! {
+                                <div class="alert alert-info">
+                                    <p>
+                                        <a href=format!("/admin/realms/{}/avatars/{}", realm_slug, id)>
+                                            "View avatar"
+                                        </a>
+                                    </p>
+                                </div>
+                            }
+                        }
+                    }
+                </Show>
+
+                <div class="form-actions">
+                    <button
+                        type="submit"
+                        class="btn btn-primary"
+                        disabled=move || pending.get()
+                    >
+                        {move || if pending.get() { "Creating..." } else { "Create Avatar" }}
+                    </button>
+                </div>
+            </form>
+        </Card>
+    }
+}

crates/chattyness-admin-ui/src/pages/realm_detail.rs

@@ -73,6 +73,7 @@ fn RealmDetailView(
     let (max_users, set_max_users) = signal(realm.max_users);
     let (is_nsfw, set_is_nsfw) = signal(realm.is_nsfw);
     let (allow_guest_access, set_allow_guest_access) = signal(realm.allow_guest_access);
+    let (allow_user_teleport, set_allow_user_teleport) = signal(realm.allow_user_teleport);
     let (theme_color, set_theme_color) = signal(
         realm
             .theme_color
@@ -99,6 +100,7 @@ fn RealmDetailView(
                 "is_nsfw": is_nsfw.get(),
                 "max_users": max_users.get(),
                 "allow_guest_access": allow_guest_access.get(),
+                "allow_user_teleport": allow_user_teleport.get(),
                 "theme_color": theme_color.get()
             });
 
@@ -269,6 +271,17 @@ fn RealmDetailView(
                             "Allow Guest Access"
                         </label>
                     </div>
+                    <div class="checkbox-group">
+                        <label class="checkbox-label">
+                            <input
+                                type="checkbox"
+                                class="form-checkbox"
+                                prop:checked=move || allow_user_teleport.get()
+                                on:change=move |ev| set_allow_user_teleport.set(event_target_checked(&ev))
+                            />
+                            "Allow User Teleport"
+                        </label>
+                    </div>
                 </div>
 
                 <div class="form-group">

crates/chattyness-admin-ui/src/routes.rs

@@ -15,9 +15,10 @@ use leptos_router::{
 
 use crate::components::{AuthenticatedLayout, LoginLayout};
 use crate::pages::{
-    ConfigPage, DashboardPage, LoginPage, PropsDetailPage, PropsNewPage, PropsPage,
-    RealmDetailPage, RealmNewPage, RealmsPage, SceneDetailPage, SceneNewPage, ScenesPage,
-    StaffPage, UserDetailPage, UserNewPage, UsersPage,
+    AvatarsDetailPage, AvatarsNewPage, AvatarsPage, ConfigPage, DashboardPage, LoginPage,
+    PropsDetailPage, PropsNewPage, PropsPage, RealmAvatarsDetailPage, RealmAvatarsNewPage,
+    RealmAvatarsPage, RealmDetailPage, RealmNewPage, RealmsPage, SceneDetailPage, SceneNewPage,
+    ScenesPage, StaffPage, UserDetailPage, UserNewPage, UsersPage,
 };
 
 /// Admin routes that can be embedded in a parent Router.
@@ -91,6 +92,23 @@ pub fn AdminRoutes() -> impl IntoView {
                 </AuthenticatedLayout>
             } />
 
+            // Server Avatars
+            <Route path=StaticSegment("avatars") view=|| view! {
+                <AuthenticatedLayout current_page="avatars">
+                    <AvatarsPage />
+                </AuthenticatedLayout>
+            } />
+            <Route path=(StaticSegment("avatars"), StaticSegment("new")) view=|| view! {
+                <AuthenticatedLayout current_page="avatars_new">
+                    <AvatarsNewPage />
+                </AuthenticatedLayout>
+            } />
+            <Route path=(StaticSegment("avatars"), ParamSegment("avatar_id")) view=|| view! {
+                <AuthenticatedLayout current_page="avatars">
+                    <AvatarsDetailPage />
+                </AuthenticatedLayout>
+            } />
+
             // Realms
             <Route path=StaticSegment("realms") view=|| view! {
                 <AuthenticatedLayout current_page="realms">
@@ -120,6 +138,23 @@ pub fn AdminRoutes() -> impl IntoView {
                 </AuthenticatedLayout>
             } />
 
+            // Realm Avatars (nested under realms)
+            <Route path=(StaticSegment("realms"), ParamSegment("slug"), StaticSegment("avatars")) view=|| view! {
+                <AuthenticatedLayout current_page="realm_avatars">
+                    <RealmAvatarsPage />
+                </AuthenticatedLayout>
+            } />
+            <Route path=(StaticSegment("realms"), ParamSegment("slug"), StaticSegment("avatars"), StaticSegment("new")) view=|| view! {
+                <AuthenticatedLayout current_page="realm_avatars_new">
+                    <RealmAvatarsNewPage />
+                </AuthenticatedLayout>
+            } />
+            <Route path=(StaticSegment("realms"), ParamSegment("slug"), StaticSegment("avatars"), ParamSegment("avatar_id")) view=|| view! {
+                <AuthenticatedLayout current_page="realm_avatars">
+                    <RealmAvatarsDetailPage />
+                </AuthenticatedLayout>
+            } />
+
             // Realm detail (must come after more specific realm routes)
             <Route path=(StaticSegment("realms"), ParamSegment("slug")) view=|| view! {
                 <AuthenticatedLayout current_page="realms">

crates/chattyness-db/src/pool.rs

@@ -62,23 +62,3 @@ pub async fn clear_user_context(pool: &PgPool) -> Result<(), AppError> {
         .await?;
     Ok(())
 }
-
-/// Set the current guest session context for Row-Level Security.
-///
-/// This should be called for guest users to enable RLS policies
-/// that depend on the current guest session ID.
-pub async fn set_guest_context(pool: &PgPool, guest_session_id: Uuid) -> Result<(), AppError> {
-    sqlx::query("SELECT public.set_current_guest_session_id($1)")
-        .bind(guest_session_id)
-        .execute(pool)
-        .await?;
-    Ok(())
-}
-
-/// Clear the current guest session context.
-pub async fn clear_guest_context(pool: &PgPool) -> Result<(), AppError> {
-    sqlx::query("SELECT public.set_current_guest_session_id(NULL)")
-        .execute(pool)
-        .await?;
-    Ok(())
-}

crates/chattyness-db/src/queries.rs

@@ -3,14 +3,15 @@
 pub mod avatars;
 pub mod channel_members;
 pub mod channels;
-pub mod guests;
 pub mod inventory;
 pub mod loose_props;
 pub mod memberships;
 pub mod moderation;
 pub mod owner;
 pub mod props;
+pub mod realm_avatars;
 pub mod realms;
 pub mod scenes;
+pub mod server_avatars;
 pub mod spots;
 pub mod users;

crates/chattyness-db/src/queries/avatars.rs

@@ -16,7 +16,11 @@ pub async fn get_active_avatar<'e>(
 ) -> Result<Option<ActiveAvatar>, AppError> {
     let avatar = sqlx::query_as::<_, ActiveAvatar>(
         r#"
-        SELECT user_id, realm_id, avatar_id, current_emotion, updated_at
+        SELECT
+            user_id, realm_id, avatar_id,
+            selected_server_avatar_id, selected_realm_avatar_id,
+            current_emotion, updated_at,
+            forced_avatar_id, forced_avatar_source, forced_by, forced_until
         FROM auth.active_avatars
         WHERE user_id = $1 AND realm_id = $2
         "#,
@@ -31,86 +35,54 @@ pub async fn get_active_avatar<'e>(
 
 /// Set the current emotion for a user in a realm.
 /// Returns the full emotion layer (9 asset paths) for the new emotion.
+///
+/// This function works with any avatar source:
+/// - Custom user avatars (auth.avatars)
+/// - Selected server avatars (server.avatars)
+/// - Selected realm avatars (realm.avatars)
+/// - Server default avatars (server.avatars via server.config)
+/// - Realm default avatars (realm.avatars via realm.realms)
+///
+/// Takes both a connection (for RLS-protected update) and a pool (for avatar resolution).
 pub async fn set_emotion<'e>(
-    executor: impl PgExecutor<'e>,
+    conn: &mut PgConnection,
+    pool: &PgPool,
     user_id: Uuid,
     realm_id: Uuid,
     emotion: EmotionState,
 ) -> Result<[Option<String>; 9], AppError> {
-    // Map emotion to column prefix
-    let emotion_prefix = match emotion {
-        EmotionState::Neutral => "e_neutral",
-        EmotionState::Happy => "e_happy",
-        EmotionState::Sad => "e_sad",
-        EmotionState::Angry => "e_angry",
-        EmotionState::Surprised => "e_surprised",
-        EmotionState::Thinking => "e_thinking",
-        EmotionState::Laughing => "e_laughing",
-        EmotionState::Crying => "e_crying",
-        EmotionState::Love => "e_love",
-        EmotionState::Confused => "e_confused",
-        EmotionState::Sleeping => "e_sleeping",
-        EmotionState::Wink => "e_wink",
-    };
-
-    // Get the numeric index for the database
-    let emotion_index = emotion.to_index() as i16;
-
-    // Build dynamic query for the specific emotion's 9 positions
-    let query = format!(
+    // First, update the emotion in active_avatars (uses RLS connection)
+    let update_result = sqlx::query(
         r#"
-        WITH updated AS (
-            UPDATE auth.active_avatars
-            SET current_emotion = $3, updated_at = now()
-            WHERE user_id = $1 AND realm_id = $2
-            RETURNING avatar_id
-        )
-        SELECT
-            (SELECT prop_asset_path FROM auth.inventory WHERE id = a.{prefix}_0) as p0,
-            (SELECT prop_asset_path FROM auth.inventory WHERE id = a.{prefix}_1) as p1,
-            (SELECT prop_asset_path FROM auth.inventory WHERE id = a.{prefix}_2) as p2,
-            (SELECT prop_asset_path FROM auth.inventory WHERE id = a.{prefix}_3) as p3,
-            (SELECT prop_asset_path FROM auth.inventory WHERE id = a.{prefix}_4) as p4,
-            (SELECT prop_asset_path FROM auth.inventory WHERE id = a.{prefix}_5) as p5,
-            (SELECT prop_asset_path FROM auth.inventory WHERE id = a.{prefix}_6) as p6,
-            (SELECT prop_asset_path FROM auth.inventory WHERE id = a.{prefix}_7) as p7,
-            (SELECT prop_asset_path FROM auth.inventory WHERE id = a.{prefix}_8) as p8
-        FROM updated u
-        JOIN auth.avatars a ON a.id = u.avatar_id
+        UPDATE auth.active_avatars
+        SET current_emotion = $3::server.emotion_state, updated_at = now()
+        WHERE user_id = $1 AND realm_id = $2
         "#,
-        prefix = emotion_prefix
-    );
+    )
+    .bind(user_id)
+    .bind(realm_id)
+    .bind(emotion.to_string())
+    .execute(&mut *conn)
+    .await?;
 
-    let result = sqlx::query_as::<_, EmotionLayerRow>(&query)
-        .bind(user_id)
-        .bind(realm_id)
-        .bind(emotion_index)
-        .fetch_optional(executor)
-        .await?;
-
-    match result {
-        Some(row) => Ok([
-            row.p0, row.p1, row.p2, row.p3, row.p4, row.p5, row.p6, row.p7, row.p8,
-        ]),
-        None => Err(AppError::NotFound(
+    if update_result.rows_affected() == 0 {
+        return Err(AppError::NotFound(
             "No active avatar for this user in this realm".to_string(),
-        )),
+        ));
+    }
+
+    // Now get the effective avatar and return the emotion layer (uses pool for multiple queries)
+    let render_data = get_effective_avatar_render_data(pool, user_id, realm_id).await?;
+
+    match render_data {
+        Some((data, _source)) => Ok(data.emotion_layer),
+        None => {
+            // No avatar found - return empty layer
+            Ok([None, None, None, None, None, None, None, None, None])
+        }
     }
 }
 
-/// Row type for emotion layer query.
-#[derive(Debug, sqlx::FromRow)]
-struct EmotionLayerRow {
-    p0: Option<String>,
-    p1: Option<String>,
-    p2: Option<String>,
-    p3: Option<String>,
-    p4: Option<String>,
-    p5: Option<String>,
-    p6: Option<String>,
-    p7: Option<String>,
-    p8: Option<String>,
-}
 
 /// Get emotion availability for a user's avatar in a realm.
 ///
@@ -1469,7 +1441,7 @@ fn collect_uuids(dest: &mut Vec<Uuid>, sources: &[Option<Uuid>]) {
 #[derive(Debug, sqlx::FromRow)]
 struct AvatarWithEmotion {
     pub id: Uuid,
-    pub current_emotion: i16,
+    pub current_emotion: EmotionState,
     // Content layers
     pub l_skin_0: Option<Uuid>,
     pub l_skin_1: Option<Uuid>,
@@ -1617,22 +1589,18 @@ pub async fn set_emotion_simple<'e>(
     executor: impl PgExecutor<'e>,
     user_id: Uuid,
     realm_id: Uuid,
-    emotion: i16,
+    emotion: EmotionState,
 ) -> Result<(), AppError> {
-    if emotion < 0 || emotion > 11 {
-        return Err(AppError::Validation("Emotion must be 0-11".to_string()));
-    }
-
     let result = sqlx::query(
         r#"
         UPDATE auth.active_avatars
-        SET current_emotion = $3, updated_at = now()
+        SET current_emotion = $3::server.emotion_state, updated_at = now()
         WHERE user_id = $1 AND realm_id = $2
         "#,
     )
     .bind(user_id)
     .bind(realm_id)
-    .bind(emotion)
+    .bind(emotion.to_string())
     .execute(executor)
     .await?;
 
@@ -1723,3 +1691,472 @@ pub async fn update_avatar_slot(
 
     Ok(())
 }
+
+/// Data needed to resolve effective avatar for a user.
+#[derive(Debug, sqlx::FromRow)]
+pub struct AvatarResolutionContext {
+    // Active avatar row data
+    pub avatar_id: Option<Uuid>,
+    pub selected_server_avatar_id: Option<Uuid>,
+    pub selected_realm_avatar_id: Option<Uuid>,
+    pub current_emotion: EmotionState,
+    // Forced avatar data
+    pub forced_avatar_id: Option<Uuid>,
+    pub forced_avatar_source: Option<String>,
+    pub forced_until: Option<chrono::DateTime<chrono::Utc>>,
+    // User preferences
+    pub gender_preference: crate::models::GenderPreference,
+    pub age_category: crate::models::AgeCategory,
+}
+
+/// Source of the resolved avatar.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AvatarSource {
+    /// User's custom avatar from auth.avatars
+    Custom,
+    /// User-selected realm avatar from avatar store
+    SelectedRealm,
+    /// User-selected server avatar from avatar store
+    SelectedServer,
+    /// Realm default avatar based on gender/age
+    RealmDefault,
+    /// Server default avatar based on gender/age
+    ServerDefault,
+    /// Forced avatar (mod command or scene)
+    Forced,
+}
+
+/// Get the effective avatar render data for a user in a realm.
+///
+/// This function implements the avatar resolution priority chain:
+/// 1. Forced avatar (mod command or scene) - highest priority
+/// 2. User's custom avatar (auth.avatars via avatar_id)
+/// 3. User-selected realm avatar (selected_realm_avatar_id)
+/// 4. User-selected server avatar (selected_server_avatar_id)
+/// 5. Realm default (based on gender+age)
+/// 6. Server default (based on gender+age) - lowest priority
+pub async fn get_effective_avatar_render_data<'e>(
+    executor: impl PgExecutor<'e> + Copy,
+    user_id: Uuid,
+    realm_id: Uuid,
+) -> Result<Option<(crate::models::AvatarRenderData, AvatarSource)>, AppError> {
+
+    // Get the resolution context with all necessary data
+    // Use LEFT JOIN so we can still get user preferences even without an active_avatars entry
+    let ctx = sqlx::query_as::<_, AvatarResolutionContext>(
+        r#"
+        SELECT
+            aa.avatar_id,
+            aa.selected_server_avatar_id,
+            aa.selected_realm_avatar_id,
+            COALESCE(aa.current_emotion, 'happy'::server.emotion_state) as current_emotion,
+            aa.forced_avatar_id,
+            aa.forced_avatar_source,
+            aa.forced_until,
+            u.gender_preference,
+            u.age_category
+        FROM auth.users u
+        LEFT JOIN auth.active_avatars aa ON aa.user_id = u.id AND aa.realm_id = $2
+        WHERE u.id = $1
+        "#,
+    )
+    .bind(user_id)
+    .bind(realm_id)
+    .fetch_optional(executor)
+    .await?;
+
+    let Some(ctx) = ctx else {
+        // User doesn't exist
+        return Ok(None);
+    };
+
+    // Priority 1: Check for forced avatar (not expired)
+    if let Some(forced_id) = ctx.forced_avatar_id {
+        let is_expired = ctx.forced_until.map(|t| t < chrono::Utc::now()).unwrap_or(false);
+        if !is_expired {
+            if let Some(source) = &ctx.forced_avatar_source {
+                match source.as_str() {
+                    "server" | "scene" => {
+                        // Resolve from server.avatars
+                        if let Some(avatar) = super::server_avatars::get_server_avatar_by_id(executor, forced_id).await? {
+                            let render = super::server_avatars::resolve_server_avatar_to_render_data(
+                                executor, &avatar, ctx.current_emotion
+                            ).await?;
+                            return Ok(Some((render, AvatarSource::Forced)));
+                        }
+                    }
+                    "realm" => {
+                        // Resolve from realm.avatars
+                        if let Some(avatar) = super::realm_avatars::get_realm_avatar_by_id(executor, forced_id).await? {
+                            let render = super::realm_avatars::resolve_realm_avatar_to_render_data(
+                                executor, &avatar, ctx.current_emotion
+                            ).await?;
+                            return Ok(Some((render, AvatarSource::Forced)));
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+
+    // Priority 2: User's custom avatar
+    if let Some(avatar_id) = ctx.avatar_id {
+        if let Some(render) = resolve_user_avatar_to_render_data(executor, avatar_id, ctx.current_emotion).await? {
+            return Ok(Some((render, AvatarSource::Custom)));
+        }
+    }
+
+    // Priority 3: User-selected realm avatar
+    if let Some(realm_avatar_id) = ctx.selected_realm_avatar_id {
+        if let Some(avatar) = super::realm_avatars::get_realm_avatar_by_id(executor, realm_avatar_id).await? {
+            let render = super::realm_avatars::resolve_realm_avatar_to_render_data(
+                executor, &avatar, ctx.current_emotion
+            ).await?;
+            return Ok(Some((render, AvatarSource::SelectedRealm)));
+        }
+    }
+
+    // Priority 4: User-selected server avatar
+    if let Some(server_avatar_id) = ctx.selected_server_avatar_id {
+        if let Some(avatar) = super::server_avatars::get_server_avatar_by_id(executor, server_avatar_id).await? {
+            let render = super::server_avatars::resolve_server_avatar_to_render_data(
+                executor, &avatar, ctx.current_emotion
+            ).await?;
+            return Ok(Some((render, AvatarSource::SelectedServer)));
+        }
+    }
+
+    // Priority 5: Realm default avatar (based on gender+age)
+    let realm_default_id = get_realm_default_avatar_id(executor, realm_id, ctx.gender_preference, ctx.age_category).await?;
+    if let Some(avatar_id) = realm_default_id {
+        if let Some(avatar) = super::realm_avatars::get_realm_avatar_by_id(executor, avatar_id).await? {
+            let render = super::realm_avatars::resolve_realm_avatar_to_render_data(
+                executor, &avatar, ctx.current_emotion
+            ).await?;
+            return Ok(Some((render, AvatarSource::RealmDefault)));
+        }
+    }
+
+    // Priority 6: Server default avatar (based on gender+age)
+    let server_default_id = get_server_default_avatar_id(executor, ctx.gender_preference, ctx.age_category).await?;
+    if let Some(avatar_id) = server_default_id {
+        if let Some(avatar) = super::server_avatars::get_server_avatar_by_id(executor, avatar_id).await? {
+            let render = super::server_avatars::resolve_server_avatar_to_render_data(
+                executor, &avatar, ctx.current_emotion
+            ).await?;
+            return Ok(Some((render, AvatarSource::ServerDefault)));
+        }
+    }
+
+    Ok(None)
+}
+
+/// Resolve a user's custom avatar (from auth.avatars) to render data.
+async fn resolve_user_avatar_to_render_data<'e>(
+    executor: impl PgExecutor<'e> + Copy,
+    avatar_id: Uuid,
+    current_emotion: EmotionState,
+) -> Result<Option<crate::models::AvatarRenderData>, AppError> {
+    // Get the avatar with inventory joins
+    let avatar = sqlx::query_as::<_, AvatarWithEmotion>(
+        r#"
+        SELECT
+            a.id, $2::server.emotion_state as current_emotion,
+            a.l_skin_0, a.l_skin_1, a.l_skin_2, a.l_skin_3, a.l_skin_4,
+            a.l_skin_5, a.l_skin_6, a.l_skin_7, a.l_skin_8,
+            a.l_clothes_0, a.l_clothes_1, a.l_clothes_2, a.l_clothes_3, a.l_clothes_4,
+            a.l_clothes_5, a.l_clothes_6, a.l_clothes_7, a.l_clothes_8,
+            a.l_accessories_0, a.l_accessories_1, a.l_accessories_2, a.l_accessories_3, a.l_accessories_4,
+            a.l_accessories_5, a.l_accessories_6, a.l_accessories_7, a.l_accessories_8,
+            a.e_neutral_0, a.e_neutral_1, a.e_neutral_2, a.e_neutral_3, a.e_neutral_4,
+            a.e_neutral_5, a.e_neutral_6, a.e_neutral_7, a.e_neutral_8,
+            a.e_happy_0, a.e_happy_1, a.e_happy_2, a.e_happy_3, a.e_happy_4,
+            a.e_happy_5, a.e_happy_6, a.e_happy_7, a.e_happy_8,
+            a.e_sad_0, a.e_sad_1, a.e_sad_2, a.e_sad_3, a.e_sad_4,
+            a.e_sad_5, a.e_sad_6, a.e_sad_7, a.e_sad_8,
+            a.e_angry_0, a.e_angry_1, a.e_angry_2, a.e_angry_3, a.e_angry_4,
+            a.e_angry_5, a.e_angry_6, a.e_angry_7, a.e_angry_8,
+            a.e_surprised_0, a.e_surprised_1, a.e_surprised_2, a.e_surprised_3, a.e_surprised_4,
+            a.e_surprised_5, a.e_surprised_6, a.e_surprised_7, a.e_surprised_8,
+            a.e_thinking_0, a.e_thinking_1, a.e_thinking_2, a.e_thinking_3, a.e_thinking_4,
+            a.e_thinking_5, a.e_thinking_6, a.e_thinking_7, a.e_thinking_8,
+            a.e_laughing_0, a.e_laughing_1, a.e_laughing_2, a.e_laughing_3, a.e_laughing_4,
+            a.e_laughing_5, a.e_laughing_6, a.e_laughing_7, a.e_laughing_8,
+            a.e_crying_0, a.e_crying_1, a.e_crying_2, a.e_crying_3, a.e_crying_4,
+            a.e_crying_5, a.e_crying_6, a.e_crying_7, a.e_crying_8,
+            a.e_love_0, a.e_love_1, a.e_love_2, a.e_love_3, a.e_love_4,
+            a.e_love_5, a.e_love_6, a.e_love_7, a.e_love_8,
+            a.e_confused_0, a.e_confused_1, a.e_confused_2, a.e_confused_3, a.e_confused_4,
+            a.e_confused_5, a.e_confused_6, a.e_confused_7, a.e_confused_8,
+            a.e_sleeping_0, a.e_sleeping_1, a.e_sleeping_2, a.e_sleeping_3, a.e_sleeping_4,
+            a.e_sleeping_5, a.e_sleeping_6, a.e_sleeping_7, a.e_sleeping_8,
+            a.e_wink_0, a.e_wink_1, a.e_wink_2, a.e_wink_3, a.e_wink_4,
+            a.e_wink_5, a.e_wink_6, a.e_wink_7, a.e_wink_8
+        FROM auth.avatars a
+        WHERE a.id = $1
+        "#,
+    )
+    .bind(avatar_id)
+    .bind(current_emotion)
+    .fetch_optional(executor)
+    .await?;
+
+    let Some(avatar) = avatar else {
+        return Ok(None);
+    };
+
+    // Collect all inventory UUIDs
+    let mut uuids: Vec<Uuid> = Vec::new();
+    collect_uuids(
+        &mut uuids,
+        &[
+            avatar.l_skin_0, avatar.l_skin_1, avatar.l_skin_2,
+            avatar.l_skin_3, avatar.l_skin_4, avatar.l_skin_5,
+            avatar.l_skin_6, avatar.l_skin_7, avatar.l_skin_8,
+        ],
+    );
+    collect_uuids(
+        &mut uuids,
+        &[
+            avatar.l_clothes_0, avatar.l_clothes_1, avatar.l_clothes_2,
+            avatar.l_clothes_3, avatar.l_clothes_4, avatar.l_clothes_5,
+            avatar.l_clothes_6, avatar.l_clothes_7, avatar.l_clothes_8,
+        ],
+    );
+    collect_uuids(
+        &mut uuids,
+        &[
+            avatar.l_accessories_0, avatar.l_accessories_1, avatar.l_accessories_2,
+            avatar.l_accessories_3, avatar.l_accessories_4, avatar.l_accessories_5,
+            avatar.l_accessories_6, avatar.l_accessories_7, avatar.l_accessories_8,
+        ],
+    );
+
+    // Get emotion slots for current emotion
+    let emotion_slots: [Option<Uuid>; 9] = match current_emotion {
+        EmotionState::Neutral => [avatar.e_neutral_0, avatar.e_neutral_1, avatar.e_neutral_2,
+              avatar.e_neutral_3, avatar.e_neutral_4, avatar.e_neutral_5,
+              avatar.e_neutral_6, avatar.e_neutral_7, avatar.e_neutral_8],
+        EmotionState::Happy => [avatar.e_happy_0, avatar.e_happy_1, avatar.e_happy_2,
+              avatar.e_happy_3, avatar.e_happy_4, avatar.e_happy_5,
+              avatar.e_happy_6, avatar.e_happy_7, avatar.e_happy_8],
+        EmotionState::Sad => [avatar.e_sad_0, avatar.e_sad_1, avatar.e_sad_2,
+              avatar.e_sad_3, avatar.e_sad_4, avatar.e_sad_5,
+              avatar.e_sad_6, avatar.e_sad_7, avatar.e_sad_8],
+        EmotionState::Angry => [avatar.e_angry_0, avatar.e_angry_1, avatar.e_angry_2,
+              avatar.e_angry_3, avatar.e_angry_4, avatar.e_angry_5,
+              avatar.e_angry_6, avatar.e_angry_7, avatar.e_angry_8],
+        EmotionState::Surprised => [avatar.e_surprised_0, avatar.e_surprised_1, avatar.e_surprised_2,
+              avatar.e_surprised_3, avatar.e_surprised_4, avatar.e_surprised_5,
+              avatar.e_surprised_6, avatar.e_surprised_7, avatar.e_surprised_8],
+        EmotionState::Thinking => [avatar.e_thinking_0, avatar.e_thinking_1, avatar.e_thinking_2,
+              avatar.e_thinking_3, avatar.e_thinking_4, avatar.e_thinking_5,
+              avatar.e_thinking_6, avatar.e_thinking_7, avatar.e_thinking_8],
+        EmotionState::Laughing => [avatar.e_laughing_0, avatar.e_laughing_1, avatar.e_laughing_2,
+              avatar.e_laughing_3, avatar.e_laughing_4, avatar.e_laughing_5,
+              avatar.e_laughing_6, avatar.e_laughing_7, avatar.e_laughing_8],
+        EmotionState::Crying => [avatar.e_crying_0, avatar.e_crying_1, avatar.e_crying_2,
+              avatar.e_crying_3, avatar.e_crying_4, avatar.e_crying_5,
+              avatar.e_crying_6, avatar.e_crying_7, avatar.e_crying_8],
+        EmotionState::Love => [avatar.e_love_0, avatar.e_love_1, avatar.e_love_2,
+              avatar.e_love_3, avatar.e_love_4, avatar.e_love_5,
+              avatar.e_love_6, avatar.e_love_7, avatar.e_love_8],
+        EmotionState::Confused => [avatar.e_confused_0, avatar.e_confused_1, avatar.e_confused_2,
+              avatar.e_confused_3, avatar.e_confused_4, avatar.e_confused_5,
+              avatar.e_confused_6, avatar.e_confused_7, avatar.e_confused_8],
+        EmotionState::Sleeping => [avatar.e_sleeping_0, avatar.e_sleeping_1, avatar.e_sleeping_2,
+               avatar.e_sleeping_3, avatar.e_sleeping_4, avatar.e_sleeping_5,
+               avatar.e_sleeping_6, avatar.e_sleeping_7, avatar.e_sleeping_8],
+        EmotionState::Wink => [avatar.e_wink_0, avatar.e_wink_1, avatar.e_wink_2,
+               avatar.e_wink_3, avatar.e_wink_4, avatar.e_wink_5,
+               avatar.e_wink_6, avatar.e_wink_7, avatar.e_wink_8],
+    };
+    collect_uuids(&mut uuids, &emotion_slots);
+
+    // Bulk resolve inventory UUIDs to asset paths
+    let paths: HashMap<Uuid, String> = if uuids.is_empty() {
+        HashMap::new()
+    } else {
+        sqlx::query_as::<_, (Uuid, String)>(
+            "SELECT id, prop_asset_path FROM auth.inventory WHERE id = ANY($1)",
+        )
+        .bind(&uuids)
+        .fetch_all(executor)
+        .await?
+        .into_iter()
+        .collect()
+    };
+
+    let get_path = |id: Option<Uuid>| -> Option<String> {
+        id.and_then(|id| paths.get(&id).cloned())
+    };
+
+    Ok(Some(crate::models::AvatarRenderData {
+        avatar_id,
+        current_emotion,
+        skin_layer: [
+            get_path(avatar.l_skin_0), get_path(avatar.l_skin_1), get_path(avatar.l_skin_2),
+            get_path(avatar.l_skin_3), get_path(avatar.l_skin_4), get_path(avatar.l_skin_5),
+            get_path(avatar.l_skin_6), get_path(avatar.l_skin_7), get_path(avatar.l_skin_8),
+        ],
+        clothes_layer: [
+            get_path(avatar.l_clothes_0), get_path(avatar.l_clothes_1), get_path(avatar.l_clothes_2),
+            get_path(avatar.l_clothes_3), get_path(avatar.l_clothes_4), get_path(avatar.l_clothes_5),
+            get_path(avatar.l_clothes_6), get_path(avatar.l_clothes_7), get_path(avatar.l_clothes_8),
+        ],
+        accessories_layer: [
+            get_path(avatar.l_accessories_0), get_path(avatar.l_accessories_1), get_path(avatar.l_accessories_2),
+            get_path(avatar.l_accessories_3), get_path(avatar.l_accessories_4), get_path(avatar.l_accessories_5),
+            get_path(avatar.l_accessories_6), get_path(avatar.l_accessories_7), get_path(avatar.l_accessories_8),
+        ],
+        emotion_layer: [
+            get_path(emotion_slots[0]), get_path(emotion_slots[1]), get_path(emotion_slots[2]),
+            get_path(emotion_slots[3]), get_path(emotion_slots[4]), get_path(emotion_slots[5]),
+            get_path(emotion_slots[6]), get_path(emotion_slots[7]), get_path(emotion_slots[8]),
+        ],
+    }))
+}
+
+/// Get the realm default avatar ID based on gender and age preferences.
+async fn get_realm_default_avatar_id<'e>(
+    executor: impl PgExecutor<'e>,
+    realm_id: Uuid,
+    gender: crate::models::GenderPreference,
+    age: crate::models::AgeCategory,
+) -> Result<Option<Uuid>, AppError> {
+    use crate::models::{AgeCategory, GenderPreference};
+
+    // Build column name based on gender and age
+    let column = match (gender, age) {
+        (GenderPreference::GenderNeutral, AgeCategory::Child) => "default_avatar_neutral_child",
+        (GenderPreference::GenderNeutral, AgeCategory::Adult) => "default_avatar_neutral_adult",
+        (GenderPreference::GenderMale, AgeCategory::Child) => "default_avatar_male_child",
+        (GenderPreference::GenderMale, AgeCategory::Adult) => "default_avatar_male_adult",
+        (GenderPreference::GenderFemale, AgeCategory::Child) => "default_avatar_female_child",
+        (GenderPreference::GenderFemale, AgeCategory::Adult) => "default_avatar_female_adult",
+    };
+
+    let query = format!(
+        "SELECT {} FROM realm.realms WHERE id = $1",
+        column
+    );
+
+    let result: Option<(Option<Uuid>,)> = sqlx::query_as(&query)
+        .bind(realm_id)
+        .fetch_optional(executor)
+        .await?;
+
+    Ok(result.and_then(|r| r.0))
+}
+
+/// Get the server default avatar ID based on gender and age preferences.
+async fn get_server_default_avatar_id<'e>(
+    executor: impl PgExecutor<'e>,
+    gender: crate::models::GenderPreference,
+    age: crate::models::AgeCategory,
+) -> Result<Option<Uuid>, AppError> {
+    use crate::models::{AgeCategory, GenderPreference};
+
+    // Build column name based on gender and age
+    let column = match (gender, age) {
+        (GenderPreference::GenderNeutral, AgeCategory::Child) => "default_avatar_neutral_child",
+        (GenderPreference::GenderNeutral, AgeCategory::Adult) => "default_avatar_neutral_adult",
+        (GenderPreference::GenderMale, AgeCategory::Child) => "default_avatar_male_child",
+        (GenderPreference::GenderMale, AgeCategory::Adult) => "default_avatar_male_adult",
+        (GenderPreference::GenderFemale, AgeCategory::Child) => "default_avatar_female_child",
+        (GenderPreference::GenderFemale, AgeCategory::Adult) => "default_avatar_female_adult",
+    };
+
+    let query = format!(
+        "SELECT {} FROM server.config WHERE id = '00000000-0000-0000-0000-000000000001'",
+        column
+    );
+
+    let result: Option<(Option<Uuid>,)> = sqlx::query_as(&query)
+        .fetch_optional(executor)
+        .await?;
+
+    Ok(result.and_then(|r| r.0))
+}
+
+/// Select a server avatar for a user in a realm.
+/// This updates the selected_server_avatar_id in active_avatars.
+/// Uses UPSERT to create the record if it doesn't exist.
+pub async fn select_server_avatar<'e>(
+    executor: impl PgExecutor<'e>,
+    user_id: Uuid,
+    realm_id: Uuid,
+    server_avatar_id: Uuid,
+) -> Result<(), AppError> {
+    sqlx::query(
+        r#"
+        INSERT INTO auth.active_avatars (user_id, realm_id, selected_server_avatar_id, updated_at)
+        VALUES ($1, $2, $3, now())
+        ON CONFLICT (user_id, realm_id) DO UPDATE
+        SET selected_server_avatar_id = EXCLUDED.selected_server_avatar_id,
+            updated_at = EXCLUDED.updated_at
+        "#,
+    )
+    .bind(user_id)
+    .bind(realm_id)
+    .bind(server_avatar_id)
+    .execute(executor)
+    .await?;
+
+    Ok(())
+}
+
+/// Select a realm avatar for a user in a realm.
+/// This updates the selected_realm_avatar_id in active_avatars.
+/// Uses UPSERT to create the record if it doesn't exist.
+pub async fn select_realm_avatar<'e>(
+    executor: impl PgExecutor<'e>,
+    user_id: Uuid,
+    realm_id: Uuid,
+    realm_avatar_id: Uuid,
+) -> Result<(), AppError> {
+    sqlx::query(
+        r#"
+        INSERT INTO auth.active_avatars (user_id, realm_id, selected_realm_avatar_id, updated_at)
+        VALUES ($1, $2, $3, now())
+        ON CONFLICT (user_id, realm_id) DO UPDATE
+        SET selected_realm_avatar_id = EXCLUDED.selected_realm_avatar_id,
+            updated_at = EXCLUDED.updated_at
+        "#,
+    )
+    .bind(user_id)
+    .bind(realm_id)
+    .bind(realm_avatar_id)
+    .execute(executor)
+    .await?;
+
+    Ok(())
+}
+
+/// Clear avatar selection for a user in a realm.
+/// Clears both selected_server_avatar_id and selected_realm_avatar_id.
+/// If no record exists, this is a no-op (clearing nothing is success).
+pub async fn clear_avatar_selection<'e>(
+    executor: impl PgExecutor<'e>,
+    user_id: Uuid,
+    realm_id: Uuid,
+) -> Result<(), AppError> {
+    sqlx::query(
+        r#"
+        UPDATE auth.active_avatars
+        SET
+            selected_server_avatar_id = NULL,
+            selected_realm_avatar_id = NULL,
+            updated_at = now()
+        WHERE user_id = $1 AND realm_id = $2
+        "#,
+    )
+    .bind(user_id)
+    .bind(realm_id)
+    .execute(executor)
+    .await?;
+
+    // No error if record doesn't exist - clearing nothing is success
+    Ok(())
+}

crates/chattyness-db/src/queries/channel_members.rs

@@ -39,7 +39,6 @@ pub async fn join_channel<'e>(
             id,
             instance_id as channel_id,
             user_id,
-            guest_session_id,
             ST_X(position) as position_x,
             ST_Y(position) as position_y,
             facing_direction,
@@ -58,7 +57,8 @@ pub async fn join_channel<'e>(
 }
 
 /// Ensure an active avatar exists for a user in a realm.
-/// Uses the user's default avatar (slot 0) if none exists.
+/// If user has a custom avatar (slot 0), use it. Otherwise, avatar_id is NULL
+/// and the system will use server/realm default avatars based on user preferences.
 pub async fn ensure_active_avatar<'e>(
     executor: impl PgExecutor<'e>,
     user_id: Uuid,
@@ -67,9 +67,9 @@ pub async fn ensure_active_avatar<'e>(
     sqlx::query(
         r#"
         INSERT INTO auth.active_avatars (user_id, realm_id, avatar_id, current_emotion)
-        SELECT $1, $2, id, 1
-        FROM auth.avatars
-        WHERE user_id = $1 AND slot_number = 0
+        SELECT $1, $2,
+            (SELECT id FROM auth.avatars WHERE user_id = $1 AND slot_number = 0),
+            'happy'::server.emotion_state
         ON CONFLICT (user_id, realm_id) DO NOTHING
         "#,
     )
@@ -168,19 +168,17 @@ pub async fn get_channel_members<'e>(
             cm.id,
             cm.instance_id as channel_id,
             cm.user_id,
-            cm.guest_session_id,
-            COALESCE(u.display_name, gs.guest_name, 'Anonymous') as display_name,
+            COALESCE(u.display_name, 'Anonymous') as display_name,
             ST_X(cm.position) as position_x,
             ST_Y(cm.position) as position_y,
             cm.facing_direction,
             cm.is_moving,
             cm.is_afk,
-            COALESCE(aa.current_emotion, 0::smallint) as current_emotion,
+            COALESCE(aa.current_emotion, 'happy'::server.emotion_state) as current_emotion,
             cm.joined_at,
             COALESCE('guest' = ANY(u.tags), false) as is_guest
         FROM scene.instance_members cm
         LEFT JOIN auth.users u ON cm.user_id = u.id
-        LEFT JOIN auth.guest_sessions gs ON cm.guest_session_id = gs.id
         LEFT JOIN auth.active_avatars aa ON cm.user_id = aa.user_id AND aa.realm_id = $2
         WHERE cm.instance_id = $1
         ORDER BY cm.joined_at ASC
@@ -207,14 +205,13 @@ pub async fn get_channel_member<'e>(
             cm.id,
             cm.instance_id as channel_id,
             cm.user_id,
-            cm.guest_session_id,
             COALESCE(u.display_name, 'Anonymous') as display_name,
             ST_X(cm.position) as position_x,
             ST_Y(cm.position) as position_y,
             cm.facing_direction,
             cm.is_moving,
             cm.is_afk,
-            COALESCE(aa.current_emotion, 0::smallint) as current_emotion,
+            COALESCE(aa.current_emotion, 'happy'::server.emotion_state) as current_emotion,
             cm.joined_at,
             COALESCE('guest' = ANY(u.tags), false) as is_guest
         FROM scene.instance_members cm

crates/chattyness-db/src/queries/guests.rs

@@ -1,98 +0,0 @@
-//! Guest session database queries.
-
-use chrono::{DateTime, TimeDelta, Utc};
-use sqlx::PgPool;
-use uuid::Uuid;
-
-use chattyness_error::AppError;
-
-/// Guest session record.
-#[derive(Debug, Clone)]
-#[cfg_attr(feature = "ssr", derive(sqlx::FromRow))]
-pub struct GuestSession {
-    pub id: Uuid,
-    pub guest_name: String,
-    pub current_realm_id: Option<Uuid>,
-    pub expires_at: DateTime<Utc>,
-    pub created_at: DateTime<Utc>,
-}
-
-/// Create a new guest session.
-///
-/// Returns the guest session ID.
-pub async fn create_guest_session(
-    pool: &PgPool,
-    guest_name: &str,
-    realm_id: Uuid,
-    token_hash: &str,
-    user_agent: Option<&str>,
-    ip_address: Option<&str>,
-    expires_at: DateTime<Utc>,
-) -> Result<Uuid, AppError> {
-    let (session_id,): (Uuid,) = sqlx::query_as(
-        r#"
-        INSERT INTO auth.guest_sessions (guest_name, token_hash, user_agent, ip_address, current_realm_id, expires_at)
-        VALUES ($1, $2, $3, $4::inet, $5, $6)
-        RETURNING id
-        "#,
-    )
-    .bind(guest_name)
-    .bind(token_hash)
-    .bind(user_agent)
-    .bind(ip_address)
-    .bind(realm_id)
-    .bind(expires_at)
-    .fetch_one(pool)
-    .await?;
-
-    Ok(session_id)
-}
-
-/// Get a guest session by ID.
-pub async fn get_guest_session(
-    pool: &PgPool,
-    session_id: Uuid,
-) -> Result<Option<GuestSession>, AppError> {
-    let session = sqlx::query_as::<_, GuestSession>(
-        r#"
-        SELECT id, guest_name, current_realm_id, expires_at, created_at
-        FROM auth.guest_sessions
-        WHERE id = $1 AND expires_at > now()
-        "#,
-    )
-    .bind(session_id)
-    .fetch_optional(pool)
-    .await?;
-
-    // Update last activity if session exists
-    if session.is_some() {
-        sqlx::query("UPDATE auth.guest_sessions SET last_activity_at = now() WHERE id = $1")
-            .bind(session_id)
-            .execute(pool)
-            .await?;
-    }
-
-    Ok(session)
-}
-
-/// Delete a guest session.
-pub async fn delete_guest_session(pool: &PgPool, session_id: Uuid) -> Result<(), AppError> {
-    sqlx::query("DELETE FROM auth.guest_sessions WHERE id = $1")
-        .bind(session_id)
-        .execute(pool)
-        .await?;
-    Ok(())
-}
-
-/// Generate a random guest name like "Guest_12345".
-pub fn generate_guest_name() -> String {
-    use rand::Rng;
-    let mut rng = rand::thread_rng();
-    let number: u32 = rng.gen_range(10000..100000);
-    format!("Guest_{}", number)
-}
-
-/// Calculate guest session expiry (24 hours from now).
-pub fn guest_session_expiry() -> DateTime<Utc> {
-    Utc::now() + TimeDelta::hours(24)
-}

crates/chattyness-db/src/queries/memberships.rs

@@ -35,12 +35,30 @@ pub async fn get_user_membership(
 }
 
 /// Create a new membership (join a realm).
+/// This function is idempotent - if the membership already exists, it returns the existing id.
 pub async fn create_membership(
     pool: &PgPool,
     user_id: Uuid,
     realm_id: Uuid,
     role: RealmRole,
 ) -> Result<Uuid, AppError> {
+    // Check if membership already exists
+    let existing: Option<(Uuid,)> = sqlx::query_as(
+        r#"
+        SELECT id FROM realm.memberships
+        WHERE user_id = $1 AND realm_id = $2
+        "#,
+    )
+    .bind(user_id)
+    .bind(realm_id)
+    .fetch_optional(pool)
+    .await?;
+
+    if let Some((id,)) = existing {
+        return Ok(id);
+    }
+
+    // Create new membership
     let (membership_id,): (Uuid,) = sqlx::query_as(
         r#"
         INSERT INTO realm.memberships (realm_id, user_id, role)
@@ -54,7 +72,7 @@ pub async fn create_membership(
     .fetch_one(pool)
     .await?;
 
-    // Update member count on the realm
+    // Only increment count for new memberships
     sqlx::query("UPDATE realm.realms SET member_count = member_count + 1 WHERE id = $1")
         .bind(realm_id)
         .execute(pool)
@@ -64,12 +82,30 @@ pub async fn create_membership(
 }
 
 /// Create a new membership using a connection (for RLS support).
+/// This function is idempotent - if the membership already exists, it returns the existing id.
 pub async fn create_membership_conn(
     conn: &mut sqlx::PgConnection,
     user_id: Uuid,
     realm_id: Uuid,
     role: RealmRole,
 ) -> Result<Uuid, AppError> {
+    // Check if membership already exists
+    let existing: Option<(Uuid,)> = sqlx::query_as(
+        r#"
+        SELECT id FROM realm.memberships
+        WHERE user_id = $1 AND realm_id = $2
+        "#,
+    )
+    .bind(user_id)
+    .bind(realm_id)
+    .fetch_optional(&mut *conn)
+    .await?;
+
+    if let Some((id,)) = existing {
+        return Ok(id);
+    }
+
+    // Create new membership
     let (membership_id,): (Uuid,) = sqlx::query_as(
         r#"
         INSERT INTO realm.memberships (realm_id, user_id, role)
@@ -83,7 +119,7 @@ pub async fn create_membership_conn(
     .fetch_one(&mut *conn)
     .await?;
 
-    // Update member count on the realm
+    // Only increment count for new memberships
     sqlx::query("UPDATE realm.realms SET member_count = member_count + 1 WHERE id = $1")
         .bind(realm_id)
         .execute(&mut *conn)

crates/chattyness-db/src/queries/users.rs

@@ -3,7 +3,7 @@
 use sqlx::{PgConnection, PgPool};
 use uuid::Uuid;
 
-use crate::models::{StaffMember, User, UserWithAuth};
+use crate::models::{AgeCategory, GenderPreference, StaffMember, User, UserWithAuth};
 use chattyness_error::AppError;
 
 /// Get a user by their ID.
@@ -17,6 +17,9 @@ pub async fn get_user_by_id(pool: &PgPool, id: Uuid) -> Result<Option<User>, App
             display_name,
             bio,
             avatar_url,
+            birthday,
+            gender_preference,
+            age_category,
             reputation_tier,
             status,
             email_verified,
@@ -45,6 +48,9 @@ pub async fn get_user_by_username(pool: &PgPool, username: &str) -> Result<Optio
             display_name,
             bio,
             avatar_url,
+            birthday,
+            gender_preference,
+            age_category,
             reputation_tier,
             status,
             email_verified,
@@ -73,6 +79,9 @@ pub async fn get_user_by_email(pool: &PgPool, email: &str) -> Result<Option<User
             display_name,
             bio,
             avatar_url,
+            birthday,
+            gender_preference,
+            age_category,
             reputation_tier,
             status,
             email_verified,
@@ -182,6 +191,9 @@ pub async fn get_user_by_session(
             u.display_name,
             u.bio,
             u.avatar_url,
+            u.birthday,
+            u.gender_preference,
+            u.age_category,
             u.reputation_tier,
             u.status,
             u.email_verified,
@@ -440,6 +452,20 @@ pub async fn create_user_conn(
     email: Option<&str>,
     display_name: &str,
     password: &str,
+) -> Result<Uuid, AppError> {
+    create_user_with_preferences_conn(conn, username, email, display_name, password, None, None, None).await
+}
+
+/// Create a new user with preferences using a connection (for RLS support).
+pub async fn create_user_with_preferences_conn(
+    conn: &mut sqlx::PgConnection,
+    username: &str,
+    email: Option<&str>,
+    display_name: &str,
+    password: &str,
+    birthday: Option<chrono::NaiveDate>,
+    gender_preference: Option<GenderPreference>,
+    age_category: Option<AgeCategory>,
 ) -> Result<Uuid, AppError> {
     use argon2::{
         Argon2, PasswordHasher,
@@ -455,8 +481,11 @@ pub async fn create_user_conn(
 
     let (user_id,): (Uuid,) = sqlx::query_as(
         r#"
-        INSERT INTO auth.users (username, email, password_hash, display_name, auth_provider, status)
-        VALUES ($1, $2, $3, $4, 'local', 'active')
+        INSERT INTO auth.users (
+            username, email, password_hash, display_name, auth_provider, status,
+            birthday, gender_preference, age_category
+        )
+        VALUES ($1, $2, $3, $4, 'local', 'active', $5, COALESCE($6, 'gender_neutral'), COALESCE($7, 'adult'))
         RETURNING id
         "#,
     )
@@ -464,6 +493,9 @@ pub async fn create_user_conn(
     .bind(email)
     .bind(&password_hash)
     .bind(display_name)
+    .bind(birthday)
+    .bind(gender_preference)
+    .bind(age_category)
     .fetch_one(conn)
     .await?;
 
@@ -590,3 +622,105 @@ pub async fn create_guest_user(pool: &PgPool, guest_name: &str) -> Result<Uuid,
 
     Ok(user_id)
 }
+
+/// Update a user's preferences (birthday, gender_preference, age_category).
+pub async fn update_user_preferences(
+    pool: &PgPool,
+    user_id: Uuid,
+    birthday: Option<chrono::NaiveDate>,
+    gender_preference: Option<crate::models::GenderPreference>,
+    age_category: Option<crate::models::AgeCategory>,
+) -> Result<(), AppError> {
+    // Build dynamic update based on provided fields
+    let mut set_clauses = vec!["updated_at = now()".to_string()];
+
+    if birthday.is_some() {
+        set_clauses.push(format!("birthday = ${}", set_clauses.len() + 1));
+    }
+    if gender_preference.is_some() {
+        set_clauses.push(format!("gender_preference = ${}", set_clauses.len() + 1));
+    }
+    if age_category.is_some() {
+        set_clauses.push(format!("age_category = ${}", set_clauses.len() + 1));
+    }
+
+    if set_clauses.len() == 1 {
+        // Only updated_at, nothing to update
+        return Ok(());
+    }
+
+    let query = format!(
+        "UPDATE auth.users SET {} WHERE id = $1",
+        set_clauses.join(", ")
+    );
+
+    let mut q = sqlx::query(&query).bind(user_id);
+    if let Some(b) = birthday {
+        q = q.bind(b);
+    }
+    if let Some(g) = gender_preference {
+        q = q.bind(g);
+    }
+    if let Some(a) = age_category {
+        q = q.bind(a);
+    }
+
+    q.execute(pool).await?;
+
+    Ok(())
+}
+
+/// Update a user's preferences using a connection (for RLS support).
+pub async fn update_user_preferences_conn(
+    conn: &mut PgConnection,
+    user_id: Uuid,
+    birthday: Option<chrono::NaiveDate>,
+    gender_preference: Option<crate::models::GenderPreference>,
+    age_category: Option<crate::models::AgeCategory>,
+) -> Result<(), AppError> {
+    // Build dynamic update based on provided fields
+    let mut set_clauses = vec!["updated_at = now()".to_string()];
+
+    if birthday.is_some() {
+        set_clauses.push(format!("birthday = ${}", set_clauses.len() + 1));
+    }
+    if gender_preference.is_some() {
+        set_clauses.push(format!("gender_preference = ${}", set_clauses.len() + 1));
+    }
+    if age_category.is_some() {
+        set_clauses.push(format!("age_category = ${}", set_clauses.len() + 1));
+    }
+
+    if set_clauses.len() == 1 {
+        // Only updated_at, nothing to update
+        return Ok(());
+    }
+
+    let query = format!(
+        "UPDATE auth.users SET {} WHERE id = $1",
+        set_clauses.join(", ")
+    );
+
+    let mut q = sqlx::query(&query).bind(user_id);
+    if let Some(b) = birthday {
+        q = q.bind(b);
+    }
+    if let Some(g) = gender_preference {
+        q = q.bind(g);
+    }
+    if let Some(a) = age_category {
+        q = q.bind(a);
+    }
+
+    q.execute(conn).await?;
+
+    Ok(())
+}
+
+/// Generate a random guest name like "Guest_12345".
+pub fn generate_guest_name() -> String {
+    use rand::Rng;
+    let mut rng = rand::thread_rng();
+    let number: u32 = rng.gen_range(10000..100000);
+    format!("Guest_{}", number)
+}

crates/chattyness-db/src/ws_messages.rs

@@ -5,7 +5,7 @@
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::models::{AvatarRenderData, ChannelMemberInfo, ChannelMemberWithAvatar, LooseProp};
+use crate::models::{AvatarRenderData, ChannelMemberInfo, ChannelMemberWithAvatar, ForcedAvatarReason, LooseProp};
 
 /// Default function for serde that returns true (for is_same_scene field).
 /// Must be pub for serde derive macro to access via full path.
@@ -26,6 +26,8 @@ pub mod close_codes {
     pub const SCENE_CHANGE: u16 = 4000;
     /// Server timeout (no message received within timeout period).
     pub const SERVER_TIMEOUT: u16 = 4001;
+    /// User explicitly logged out.
+    pub const LOGOUT: u16 = 4003;
 }
 
 /// Reason for member disconnect.
@@ -126,20 +128,16 @@ pub enum ServerMessage {
 
     /// A member left the channel.
     MemberLeft {
-        /// User ID (if authenticated user).
-        user_id: Option<Uuid>,
-        /// Guest session ID (if guest).
-        guest_session_id: Option<Uuid>,
+        /// User ID of the member who left.
+        user_id: Uuid,
         /// Reason for disconnect.
         reason: DisconnectReason,
     },
 
     /// A member updated their position.
     PositionUpdated {
-        /// User ID (if authenticated user).
-        user_id: Option<Uuid>,
-        /// Guest session ID (if guest).
-        guest_session_id: Option<Uuid>,
+        /// User ID of the member.
+        user_id: Uuid,
         /// New X coordinate.
         x: f64,
         /// New Y coordinate.
@@ -148,10 +146,8 @@ pub enum ServerMessage {
 
     /// A member changed their emotion.
     EmotionUpdated {
-        /// User ID (if authenticated user).
-        user_id: Option<Uuid>,
-        /// Guest session ID (if guest).
-        guest_session_id: Option<Uuid>,
+        /// User ID of the member.
+        user_id: Uuid,
         /// Emotion name (e.g., "happy", "sad", "neutral").
         emotion: String,
         /// Asset paths for all 9 positions of the new emotion layer.
@@ -173,10 +169,8 @@ pub enum ServerMessage {
     ChatMessageReceived {
         /// Unique message ID.
         message_id: Uuid,
-        /// User ID of sender (if authenticated user).
-        user_id: Option<Uuid>,
-        /// Guest session ID (if guest).
-        guest_session_id: Option<Uuid>,
+        /// User ID of sender.
+        user_id: Uuid,
         /// Display name of sender.
         display_name: String,
         /// Message content.
@@ -217,10 +211,8 @@ pub enum ServerMessage {
     PropPickedUp {
         /// ID of the prop that was picked up.
         prop_id: Uuid,
-        /// User ID who picked it up (if authenticated).
-        picked_up_by_user_id: Option<Uuid>,
-        /// Guest session ID who picked it up (if guest).
-        picked_up_by_guest_id: Option<Uuid>,
+        /// User ID who picked it up.
+        picked_up_by_user_id: Uuid,
     },
 
     /// A prop expired and was removed.
@@ -231,10 +223,8 @@ pub enum ServerMessage {
 
     /// A member updated their avatar appearance.
     AvatarUpdated {
-        /// User ID (if authenticated user).
-        user_id: Option<Uuid>,
-        /// Guest session ID (if guest).
-        guest_session_id: Option<Uuid>,
+        /// User ID of the member.
+        user_id: Uuid,
         /// Updated avatar render data.
         avatar: AvatarRenderData,
     },
@@ -274,4 +264,26 @@ pub enum ServerMessage {
         /// Whether the member is still a guest.
         is_guest: bool,
     },
+
+    /// A user's avatar was forcibly changed (by moderator or scene entry).
+    AvatarForced {
+        /// User ID whose avatar was forced.
+        user_id: Uuid,
+        /// The forced avatar render data.
+        avatar: AvatarRenderData,
+        /// Why the avatar was forced.
+        reason: ForcedAvatarReason,
+        /// Display name of who forced the avatar (if mod command).
+        forced_by: Option<String>,
+    },
+
+    /// A user's forced avatar was cleared (returned to their chosen avatar).
+    AvatarCleared {
+        /// User ID whose forced avatar was cleared.
+        user_id: Uuid,
+        /// The user's original avatar render data (restored).
+        avatar: AvatarRenderData,
+        /// Display name of who cleared the forced avatar (if mod command).
+        cleared_by: Option<String>,
+    },
 }

crates/chattyness-shared/src/config.rs

@@ -16,6 +16,8 @@ pub struct AppConfig {
     pub websocket: WebSocketConfig,
     /// Stale member cleanup configuration.
     pub cleanup: CleanupConfig,
+    /// Signup form configuration.
+    pub signup: SignupConfig,
 }
 
 /// WebSocket configuration.
@@ -40,11 +42,62 @@ pub struct CleanupConfig {
     pub clear_on_startup: bool,
 }
 
+/// Signup form configuration.
+/// Controls what fields are shown during user registration.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(default)]
+pub struct SignupConfig {
+    /// Whether to show birthday field during signup.
+    /// None = don't ask, Some("ask") = show field
+    pub birthday: Option<SignupField>,
+    /// How to determine user's age category.
+    pub age: AgeConfig,
+    /// How to determine user's gender preference.
+    pub gender: GenderConfig,
+}
+
+/// Signup field option.
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum SignupField {
+    /// Show the field during signup
+    Ask,
+}
+
+/// Age category configuration.
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum AgeConfig {
+    /// Ask user to select their age category
+    Ask,
+    /// Infer age category from birthday (requires birthday = "ask")
+    Infer,
+    /// Default to adult without asking
+    DefaultAdult,
+    /// Default to child without asking
+    DefaultChild,
+}
+
+/// Gender preference configuration.
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum GenderConfig {
+    /// Ask user to select their gender preference
+    Ask,
+    /// Default to neutral without asking
+    DefaultNeutral,
+    /// Default to male without asking
+    DefaultMale,
+    /// Default to female without asking
+    DefaultFemale,
+}
+
 impl Default for AppConfig {
     fn default() -> Self {
         Self {
             websocket: WebSocketConfig::default(),
             cleanup: CleanupConfig::default(),
+            signup: SignupConfig::default(),
         }
     }
 }
@@ -68,6 +121,28 @@ impl Default for CleanupConfig {
     }
 }
 
+impl Default for SignupConfig {
+    fn default() -> Self {
+        Self {
+            birthday: None,
+            age: AgeConfig::default(),
+            gender: GenderConfig::default(),
+        }
+    }
+}
+
+impl Default for AgeConfig {
+    fn default() -> Self {
+        Self::DefaultAdult
+    }
+}
+
+impl Default for GenderConfig {
+    fn default() -> Self {
+        Self::DefaultNeutral
+    }
+}
+
 impl AppConfig {
     /// Load configuration from a TOML file.
     ///

crates/chattyness-user-ui/src/api/auth.rs

@@ -6,14 +6,16 @@ use tower_sessions::Session;
 
 use chattyness_db::{
     models::{
-        AccountStatus, AuthenticatedUser, CurrentUserResponse, GuestLoginRequest,
-        GuestLoginResponse, JoinRealmRequest, JoinRealmResponse, LoginRequest, LoginResponse,
-        LoginType, PasswordResetRequest, PasswordResetResponse, RealmRole, RealmSummary,
-        RegisterGuestRequest, RegisterGuestResponse, SignupRequest, SignupResponse, UserSummary,
+        AccountStatus, AgeCategory, AuthenticatedUser, CurrentUserResponse, GenderPreference,
+        GuestLoginRequest, GuestLoginResponse, JoinRealmRequest, JoinRealmResponse, LoginRequest,
+        LoginResponse, LoginType, PasswordResetRequest, PasswordResetResponse, RealmRole,
+        RealmSummary, RegisterGuestRequest, RegisterGuestResponse, SignupRequest, SignupResponse,
+        UserSummary,
     },
-    queries::{guests, memberships, realms, users},
+    queries::{memberships, realms, users},
 };
 use chattyness_error::AppError;
+use chattyness_shared::{AgeConfig, GenderConfig, SignupConfig};
 
 use crate::auth::{
     AuthUser, OptionalAuthUser,
@@ -249,6 +251,7 @@ pub async fn logout(session: Session) -> Result<Json<LogoutResponse>, AppError>
 pub async fn signup(
     rls_conn: crate::auth::RlsConn,
     State(pool): State<PgPool>,
+    State(signup_config): State<SignupConfig>,
     session: Session,
     Json(req): Json<SignupRequest>,
 ) -> Result<Json<SignupResponse>, AppError> {
@@ -273,6 +276,29 @@ pub async fn signup(
         .await?
         .ok_or_else(|| AppError::NotFound(format!("Realm '{}' not found", req.realm_slug)))?;
 
+    // Determine gender preference based on config
+    let gender_preference = match signup_config.gender {
+        GenderConfig::Ask => req.gender_preference,
+        GenderConfig::DefaultNeutral => Some(GenderPreference::GenderNeutral),
+        GenderConfig::DefaultMale => Some(GenderPreference::GenderMale),
+        GenderConfig::DefaultFemale => Some(GenderPreference::GenderFemale),
+    };
+
+    // Determine age category based on config
+    let age_category = match signup_config.age {
+        AgeConfig::Ask => req.age_category,
+        AgeConfig::Infer => {
+            // Infer age from birthday if provided
+            if let Some(birthday) = req.birthday {
+                Some(infer_age_category_from_birthday(birthday))
+            } else {
+                Some(AgeCategory::Adult) // Default to adult if no birthday
+            }
+        }
+        AgeConfig::DefaultAdult => Some(AgeCategory::Adult),
+        AgeConfig::DefaultChild => Some(AgeCategory::Child),
+    };
+
     // Create the user using RLS connection
     let email_opt = req.email.as_ref().and_then(|e| {
         let trimmed = e.trim();
@@ -284,12 +310,15 @@ pub async fn signup(
     });
 
     let mut conn = rls_conn.acquire().await;
-    let user_id = users::create_user_conn(
+    let user_id = users::create_user_with_preferences_conn(
         &mut *conn,
         &req.username,
         email_opt,
         req.display_name.trim(),
         &req.password,
+        req.birthday,
+        gender_preference,
+        age_category,
     )
     .await?;
     drop(conn);
@@ -339,6 +368,7 @@ pub async fn signup(
 /// Creates a real user account with the 'guest' tag. Guests are regular users
 /// with limited capabilities (no prop pickup, etc.) that can be reaped after 24 hours.
 pub async fn guest_login(
+    rls_conn: crate::auth::RlsConn,
     State(pool): State<PgPool>,
     session: Session,
     Json(req): Json<GuestLoginRequest>,
@@ -359,11 +389,22 @@ pub async fn guest_login(
     }
 
     // Generate guest name
-    let guest_name = guests::generate_guest_name();
+    let guest_name = users::generate_guest_name();
 
     // Create guest user (no password) - trigger creates avatar automatically
     let user_id = users::create_guest_user(&pool, &guest_name).await?;
 
+    // Set RLS context to the new guest user for membership creation
+    rls_conn
+        .set_user_id(user_id)
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to set RLS context: {}", e)))?;
+
+    // Create membership for the guest so their position can be persisted
+    let mut conn = rls_conn.acquire().await;
+    memberships::create_membership_conn(&mut *conn, user_id, realm.id, RealmRole::Member).await?;
+    drop(conn);
+
     // Set up tower session (same as regular user login)
     session
         .insert(SESSION_USER_ID_KEY, user_id)
@@ -530,3 +571,65 @@ pub async fn register_guest(
         username: req.username,
     }))
 }
+
+/// Request to update user preferences.
+#[derive(Debug, serde::Deserialize)]
+pub struct UpdatePreferencesRequest {
+    #[serde(default)]
+    pub birthday: Option<chrono::NaiveDate>,
+    #[serde(default)]
+    pub gender_preference: Option<chattyness_db::models::GenderPreference>,
+    #[serde(default)]
+    pub age_category: Option<chattyness_db::models::AgeCategory>,
+}
+
+/// Response after updating preferences.
+#[derive(Debug, serde::Serialize)]
+pub struct UpdatePreferencesResponse {
+    pub success: bool,
+}
+
+/// Update user preferences handler.
+///
+/// Updates the user's birthday, gender preference, and/or age category.
+/// These preferences are used for default avatar selection.
+pub async fn update_preferences(
+    rls_conn: crate::auth::RlsConn,
+    AuthUser(user): AuthUser,
+    Json(req): Json<UpdatePreferencesRequest>,
+) -> Result<Json<UpdatePreferencesResponse>, AppError> {
+    let mut conn = rls_conn.acquire().await;
+
+    // Update user preferences (requires RLS for auth.users UPDATE policy)
+    users::update_user_preferences_conn(
+        &mut *conn,
+        user.id,
+        req.birthday,
+        req.gender_preference,
+        req.age_category,
+    )
+    .await?;
+
+    Ok(Json(UpdatePreferencesResponse { success: true }))
+}
+
+/// Infer age category from birthday.
+///
+/// Returns `Adult` if 18 years or older, `Child` otherwise.
+fn infer_age_category_from_birthday(birthday: chrono::NaiveDate) -> AgeCategory {
+    use chrono::Datelike;
+    let today = chrono::Utc::now().date_naive();
+    let age = today.year() - birthday.year();
+    let had_birthday_this_year =
+        (today.month(), today.day()) >= (birthday.month(), birthday.day());
+    let actual_age = if had_birthday_this_year {
+        age
+    } else {
+        age - 1
+    };
+    if actual_age >= 18 {
+        AgeCategory::Adult
+    } else {
+        AgeCategory::Child
+    }
+}

crates/chattyness-user-ui/src/api/avatars.rs

@@ -7,10 +7,13 @@ use axum::Json;
 use axum::extract::Path;
 
 use chattyness_db::{
-    models::{AssignSlotRequest, AvatarWithPaths, ClearSlotRequest},
-    queries::{avatars, realms},
+    models::{AssignSlotRequest, AvatarWithPaths, ClearSlotRequest, RealmAvatarWithPaths, ServerAvatarWithPaths},
+    queries::{avatars, realm_avatars, realms, server_avatars},
 };
 use chattyness_error::AppError;
+use sqlx::PgPool;
+use axum::extract::State;
+use uuid::Uuid;
 
 use crate::auth::{AuthUser, RlsConn};
 
@@ -127,3 +130,138 @@ pub async fn clear_slot(
 
     Ok(Json(avatar))
 }
+
+// =============================================================================
+// Avatar Store Endpoints
+// =============================================================================
+
+/// List public server avatars with resolved paths.
+///
+/// GET /api/server/avatars
+///
+/// Returns all public, active server avatars that users can select from.
+/// Includes resolved asset paths for client-side rendering.
+pub async fn list_server_avatars(
+    State(pool): State<PgPool>,
+) -> Result<Json<Vec<ServerAvatarWithPaths>>, AppError> {
+    let avatars = server_avatars::list_public_server_avatars_with_paths(&pool).await?;
+    Ok(Json(avatars))
+}
+
+/// List public realm avatars with resolved paths.
+///
+/// GET /api/realms/{slug}/avatars
+///
+/// Returns all public, active realm avatars for the specified realm.
+/// Includes resolved asset paths for client-side rendering.
+pub async fn list_realm_avatars(
+    State(pool): State<PgPool>,
+    Path(slug): Path<String>,
+) -> Result<Json<Vec<RealmAvatarWithPaths>>, AppError> {
+    // Get realm
+    let realm = realms::get_realm_by_slug(&pool, &slug)
+        .await?
+        .ok_or_else(|| AppError::NotFound(format!("Realm '{}' not found", slug)))?;
+
+    let avatars = realm_avatars::list_public_realm_avatars_with_paths(&pool, realm.id).await?;
+    Ok(Json(avatars))
+}
+
+/// Request to select an avatar from the store.
+#[derive(Debug, serde::Deserialize)]
+pub struct SelectAvatarRequest {
+    /// The avatar ID to select
+    pub avatar_id: Uuid,
+    /// Source: "server" or "realm"
+    pub source: AvatarSelectionSource,
+}
+
+/// Avatar selection source.
+#[derive(Debug, serde::Deserialize, Clone, Copy)]
+#[serde(rename_all = "snake_case")]
+pub enum AvatarSelectionSource {
+    Server,
+    Realm,
+}
+
+/// Response after selecting an avatar.
+#[derive(Debug, serde::Serialize)]
+pub struct SelectAvatarResponse {
+    pub success: bool,
+}
+
+/// Select an avatar from the store.
+///
+/// POST /api/realms/{slug}/avatar/select
+///
+/// Selects a server or realm avatar to use. This has lower priority than
+/// a custom avatar but higher priority than default avatars.
+pub async fn select_avatar(
+    rls_conn: RlsConn,
+    AuthUser(user): AuthUser,
+    Path(slug): Path<String>,
+    Json(req): Json<SelectAvatarRequest>,
+) -> Result<Json<SelectAvatarResponse>, AppError> {
+    let mut conn = rls_conn.acquire().await;
+
+    // Get realm
+    let realm = realms::get_realm_by_slug(&mut *conn, &slug)
+        .await?
+        .ok_or_else(|| AppError::NotFound(format!("Realm '{}' not found", slug)))?;
+
+    // Verify the avatar exists and is public
+    match req.source {
+        AvatarSelectionSource::Server => {
+            let avatar = server_avatars::get_server_avatar_by_id(&mut *conn, req.avatar_id)
+                .await?
+                .ok_or_else(|| AppError::NotFound("Server avatar not found".to_string()))?;
+            if !avatar.is_public || !avatar.is_active {
+                return Err(AppError::NotFound("Server avatar not available".to_string()));
+            }
+            avatars::select_server_avatar(&mut *conn, user.id, realm.id, req.avatar_id).await?;
+        }
+        AvatarSelectionSource::Realm => {
+            let avatar = realm_avatars::get_realm_avatar_by_id(&mut *conn, req.avatar_id)
+                .await?
+                .ok_or_else(|| AppError::NotFound("Realm avatar not found".to_string()))?;
+            if avatar.realm_id != realm.id {
+                return Err(AppError::NotFound("Realm avatar not found in this realm".to_string()));
+            }
+            if !avatar.is_public || !avatar.is_active {
+                return Err(AppError::NotFound("Realm avatar not available".to_string()));
+            }
+            avatars::select_realm_avatar(&mut *conn, user.id, realm.id, req.avatar_id).await?;
+        }
+    }
+
+    Ok(Json(SelectAvatarResponse { success: true }))
+}
+
+/// Clear avatar selection response.
+#[derive(Debug, serde::Serialize)]
+pub struct ClearAvatarSelectionResponse {
+    pub success: bool,
+}
+
+/// Clear avatar selection.
+///
+/// DELETE /api/realms/{slug}/avatar/selection
+///
+/// Clears both server and realm avatar selections, reverting to default
+/// avatar behavior (custom avatar if available, otherwise defaults).
+pub async fn clear_avatar_selection(
+    rls_conn: RlsConn,
+    AuthUser(user): AuthUser,
+    Path(slug): Path<String>,
+) -> Result<Json<ClearAvatarSelectionResponse>, AppError> {
+    let mut conn = rls_conn.acquire().await;
+
+    // Get realm
+    let realm = realms::get_realm_by_slug(&mut *conn, &slug)
+        .await?
+        .ok_or_else(|| AppError::NotFound(format!("Realm '{}' not found", slug)))?;
+
+    avatars::clear_avatar_selection(&mut *conn, user.id, realm.id).await?;
+
+    Ok(Json(ClearAvatarSelectionResponse { success: true }))
+}

crates/chattyness-user-ui/src/api/routes.rs

@@ -31,6 +31,10 @@ pub fn api_router() -> Router<AppState> {
             "/auth/register-guest",
             axum::routing::post(auth::register_guest),
         )
+        .route(
+            "/auth/preferences",
+            axum::routing::put(auth::update_preferences),
+        )
         // Realm routes (READ-ONLY)
         .route("/realms", get(realms::list_realms))
         .route("/realms/{slug}", get(realms::get_realm))
@@ -62,6 +66,17 @@ pub fn api_router() -> Router<AppState> {
             "/realms/{slug}/avatar/slot",
             axum::routing::put(avatars::assign_slot).delete(avatars::clear_slot),
         )
+        // Avatar store routes
+        .route("/server/avatars", get(avatars::list_server_avatars))
+        .route("/realms/{slug}/avatars", get(avatars::list_realm_avatars))
+        .route(
+            "/realms/{slug}/avatar/select",
+            axum::routing::post(avatars::select_avatar),
+        )
+        .route(
+            "/realms/{slug}/avatar/selection",
+            axum::routing::delete(avatars::clear_avatar_selection),
+        )
         // User inventory routes
         .route("/user/{uuid}/inventory", get(inventory::get_user_inventory))
         .route(

crates/chattyness-user-ui/src/api/websocket.rs

@@ -18,14 +18,33 @@ use tokio::sync::{broadcast, mpsc};
 use uuid::Uuid;
 
 use chattyness_db::{
-    models::{ActionType, AvatarRenderData, ChannelMemberWithAvatar, EmotionState, User},
-    queries::{avatars, channel_members, loose_props, memberships, moderation, realms, scenes, users},
+    models::{ActionType, AvatarRenderData, ChannelMemberWithAvatar, EmotionState, ForcedAvatarReason, User},
+    queries::{avatars, channel_members, loose_props, memberships, moderation, realm_avatars, realms, scenes, server_avatars, users},
     ws_messages::{close_codes, ClientMessage, DisconnectReason, ServerMessage, WsConfig},
 };
 use chattyness_error::AppError;
 use chattyness_shared::WebSocketConfig;
 
 use crate::auth::AuthUser;
+use chrono::Duration as ChronoDuration;
+
+/// Parse a duration string like "30m", "2h", "7d" into a chrono::Duration.
+fn parse_duration(s: &str) -> Option<ChronoDuration> {
+    let s = s.trim().to_lowercase();
+    if s.is_empty() {
+        return None;
+    }
+
+    let (num_str, unit) = s.split_at(s.len() - 1);
+    let num: i64 = num_str.parse().ok()?;
+
+    match unit {
+        "m" => Some(ChronoDuration::minutes(num)),
+        "h" => Some(ChronoDuration::hours(num)),
+        "d" => Some(ChronoDuration::days(num)),
+        _ => None,
+    }
+}
 
 /// Channel state for broadcasting updates.
 pub struct ChannelState {
@@ -271,8 +290,22 @@ async fn handle_socket(
     }
     tracing::info!("[WS] Channel joined");
 
+    // Check if scene has forced avatar
+    if let Ok(Some(scene_forced)) = realm_avatars::get_scene_forced_avatar(&pool, channel_id).await {
+        tracing::info!("[WS] Scene has forced avatar: {:?}", scene_forced.forced_avatar_id);
+        // Apply scene-forced avatar to user
+        if let Err(e) = realm_avatars::apply_scene_forced_avatar(
+            &pool,
+            user.id,
+            realm_id,
+            scene_forced.forced_avatar_id,
+        ).await {
+            tracing::warn!("[WS] Failed to apply scene forced avatar: {:?}", e);
+        }
+    }
+
     // Get initial state
-    let members = match get_members_with_avatars(&mut conn, channel_id, realm_id).await {
+    let members = match get_members_with_avatars(&mut conn, &pool, channel_id, realm_id).await {
         Ok(m) => m,
         Err(e) => {
             tracing::error!("[WS] Failed to get members: {:?}", e);
@@ -338,11 +371,13 @@ async fn handle_socket(
     let member_display_name = member.display_name.clone();
 
     // Broadcast join to others
-    let avatar = avatars::get_avatar_with_paths_conn(&mut *conn, user.id, realm_id)
+    // Use effective avatar resolution to handle priority chain:
+    // forced > custom > selected realm > selected server > realm default > server default
+    let avatar = avatars::get_effective_avatar_render_data(&pool, user.id, realm_id)
         .await
         .ok()
         .flatten()
-        .map(|a| a.to_render_data())
+        .map(|(render_data, _source)| render_data)
         .unwrap_or_default();
     let join_msg = ServerMessage::MemberJoined {
         member: ChannelMemberWithAvatar { member, avatar },
@@ -350,7 +385,7 @@ async fn handle_socket(
     let _ = channel_state.tx.send(join_msg);
 
     let user_id = user.id;
-    let is_guest = user.is_guest();
+    let mut is_guest = user.is_guest();
     let tx = channel_state.tx.clone();
 
     // Acquire a second dedicated connection for the receive task
@@ -437,8 +472,7 @@ async fn handle_socket(
                                         continue;
                                     }
                                     let _ = tx.send(ServerMessage::PositionUpdated {
-                                        user_id: Some(user_id),
-                                        guest_session_id: None,
+                                        user_id,
                                         x,
                                         y,
                                     });
@@ -458,6 +492,7 @@ async fn handle_socket(
                                     };
                                     let emotion_layer = match avatars::set_emotion(
                                         &mut *recv_conn,
+                                        &pool,
                                         user_id,
                                         realm_id,
                                         emotion_state,
@@ -472,8 +507,7 @@ async fn handle_socket(
                                         }
                                     };
                                     let _ = tx.send(ServerMessage::EmotionUpdated {
-                                        user_id: Some(user_id),
-                                        guest_session_id: None,
+                                        user_id,
                                         emotion,
                                         emotion_layer,
                                     });
@@ -537,8 +571,7 @@ async fn handle_socket(
 
                                                 let msg = ServerMessage::ChatMessageReceived {
                                                     message_id: Uuid::new_v4(),
-                                                    user_id: Some(user_id),
-                                                    guest_session_id: None,
+                                                    user_id,
                                                     display_name: member.display_name.clone(),
                                                     content: content.clone(),
                                                     emotion: emotion_name.clone(),
@@ -559,8 +592,7 @@ async fn handle_socket(
                                                 let sender_msg =
                                                     ServerMessage::ChatMessageReceived {
                                                         message_id: Uuid::new_v4(),
-                                                        user_id: Some(user_id),
-                                                        guest_session_id: None,
+                                                        user_id,
                                                         display_name: member.display_name.clone(),
                                                         content,
                                                         emotion: emotion_name,
@@ -591,8 +623,7 @@ async fn handle_socket(
                                             // Broadcast: send to all users in the channel
                                             let msg = ServerMessage::ChatMessageReceived {
                                                 message_id: Uuid::new_v4(),
-                                                user_id: Some(user_id),
-                                                guest_session_id: None,
+                                                user_id,
                                                 display_name: member.display_name.clone(),
                                                 content,
                                                 emotion: emotion_name,
@@ -697,8 +728,7 @@ async fn handle_socket(
                                             );
                                             let _ = tx.send(ServerMessage::PropPickedUp {
                                                 prop_id: loose_prop_id,
-                                                picked_up_by_user_id: Some(user_id),
-                                                picked_up_by_guest_id: None,
+                                                picked_up_by_user_id: user_id,
                                             });
                                         }
                                         Err(e) => {
@@ -711,24 +741,23 @@ async fn handle_socket(
                                     }
                                 }
                                 ClientMessage::SyncAvatar => {
-                                    // Fetch current avatar from database and broadcast to channel
-                                    match avatars::get_avatar_with_paths_conn(
-                                        &mut *recv_conn,
+                                    // Fetch current effective avatar from database and broadcast to channel
+                                    // Uses the priority chain: forced > custom > selected realm > selected server > realm default > server default
+                                    match avatars::get_effective_avatar_render_data(
+                                        &pool,
                                         user_id,
                                         realm_id,
                                     )
                                     .await
                                     {
-                                        Ok(Some(avatar_with_paths)) => {
-                                            let render_data = avatar_with_paths.to_render_data();
+                                        Ok(Some((render_data, _source))) => {
                                             #[cfg(debug_assertions)]
                                             tracing::debug!(
                                                 "[WS] User {} syncing avatar to channel",
                                                 user_id
                                             );
                                             let _ = tx.send(ServerMessage::AvatarUpdated {
-                                                user_id: Some(user_id),
-                                                guest_session_id: None,
+                                                user_id,
                                                 avatar: render_data,
                                             });
                                         }
@@ -1066,6 +1095,278 @@ async fn handle_socket(
                                                 }).await;
                                             }
                                         }
+                                        "dress" => {
+                                            // /mod dress [nick] [avatar-slug] [duration?]
+                                            // Duration format: 30m, 2h, 7d (minutes/hours/days)
+                                            if args.len() < 2 {
+                                                let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                    success: false,
+                                                    message: "Usage: /mod dress [nick] [avatar-slug] [duration?]".to_string(),
+                                                }).await;
+                                                continue;
+                                            }
+
+                                            let target_nick = &args[0];
+                                            let avatar_slug = &args[1];
+                                            let duration_str = args.get(2).map(|s| s.as_str());
+
+                                            // Parse duration if provided
+                                            let duration = if let Some(dur_str) = duration_str {
+                                                match parse_duration(dur_str) {
+                                                    Some(d) => Some(d),
+                                                    None => {
+                                                        let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                            success: false,
+                                                            message: "Invalid duration format. Use: 30m, 2h, 7d".to_string(),
+                                                        }).await;
+                                                        continue;
+                                                    }
+                                                }
+                                            } else {
+                                                None // Permanent until undressed
+                                            };
+
+                                            // Find target user
+                                            if let Some((target_user_id, target_conn)) = ws_state
+                                                .find_user_by_display_name(realm_id, target_nick)
+                                            {
+                                                // Try realm avatars first, then server avatars
+                                                let avatar_result = realm_avatars::get_realm_avatar_by_slug(&pool, realm_id, avatar_slug).await;
+                                                let (avatar_render_data, avatar_id, source) = match avatar_result {
+                                                    Ok(Some(realm_avatar)) => {
+                                                        // Resolve realm avatar to render data
+                                                        match realm_avatars::resolve_realm_avatar_to_render_data(&pool, &realm_avatar, EmotionState::default()).await {
+                                                            Ok(render_data) => (render_data, realm_avatar.id, "realm"),
+                                                            Err(e) => {
+                                                                let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                                    success: false,
+                                                                    message: format!("Failed to resolve avatar: {:?}", e),
+                                                                }).await;
+                                                                continue;
+                                                            }
+                                                        }
+                                                    }
+                                                    Ok(None) => {
+                                                        // Try server avatars
+                                                        match server_avatars::get_server_avatar_by_slug(&pool, avatar_slug).await {
+                                                            Ok(Some(server_avatar)) => {
+                                                                match server_avatars::resolve_server_avatar_to_render_data(&pool, &server_avatar, EmotionState::default()).await {
+                                                                    Ok(render_data) => (render_data, server_avatar.id, "server"),
+                                                                    Err(e) => {
+                                                                        let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                                            success: false,
+                                                                            message: format!("Failed to resolve avatar: {:?}", e),
+                                                                        }).await;
+                                                                        continue;
+                                                                    }
+                                                                }
+                                                            }
+                                                            Ok(None) => {
+                                                                let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                                    success: false,
+                                                                    message: format!("Avatar '{}' not found", avatar_slug),
+                                                                }).await;
+                                                                continue;
+                                                            }
+                                                            Err(e) => {
+                                                                let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                                    success: false,
+                                                                    message: format!("Failed to lookup avatar: {:?}", e),
+                                                                }).await;
+                                                                continue;
+                                                            }
+                                                        }
+                                                    }
+                                                    Err(e) => {
+                                                        let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                            success: false,
+                                                            message: format!("Failed to lookup avatar: {:?}", e),
+                                                        }).await;
+                                                        continue;
+                                                    }
+                                                };
+
+                                                // Acquire connection and set RLS context for the update
+                                                let mut rls_conn = match pool.acquire().await {
+                                                    Ok(c) => c,
+                                                    Err(e) => {
+                                                        let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                            success: false,
+                                                            message: format!("Database connection error: {:?}", e),
+                                                        }).await;
+                                                        continue;
+                                                    }
+                                                };
+                                                if let Err(e) = set_rls_user_id(&mut rls_conn, user_id).await {
+                                                    let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                        success: false,
+                                                        message: format!("Failed to set RLS context: {:?}", e),
+                                                    }).await;
+                                                    continue;
+                                                }
+
+                                                // Apply forced avatar using connection with RLS context
+                                                let apply_result = if source == "server" {
+                                                    server_avatars::apply_forced_server_avatar(
+                                                        &mut *rls_conn,
+                                                        target_user_id,
+                                                        realm_id,
+                                                        avatar_id,
+                                                        Some(user_id),
+                                                        duration,
+                                                    ).await
+                                                } else {
+                                                    realm_avatars::apply_forced_realm_avatar(
+                                                        &mut *rls_conn,
+                                                        target_user_id,
+                                                        realm_id,
+                                                        avatar_id,
+                                                        Some(user_id),
+                                                        duration,
+                                                    ).await
+                                                };
+
+                                                if let Err(e) = apply_result {
+                                                    let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                        success: false,
+                                                        message: format!("Failed to apply forced avatar: {:?}", e),
+                                                    }).await;
+                                                    continue;
+                                                }
+
+                                                // Log moderation action
+                                                let metadata = serde_json::json!({
+                                                    "avatar_slug": avatar_slug,
+                                                    "avatar_id": avatar_id.to_string(),
+                                                    "source": source,
+                                                    "duration": duration_str,
+                                                });
+                                                let _ = moderation::log_moderation_action(
+                                                    &pool,
+                                                    realm_id,
+                                                    user_id,
+                                                    ActionType::DressUser,
+                                                    Some(target_user_id),
+                                                    &format!("Forced {} to wear avatar '{}'", target_nick, avatar_slug),
+                                                    metadata,
+                                                ).await;
+
+                                                // Send AvatarForced to target user
+                                                let _ = target_conn.direct_tx.send(ServerMessage::AvatarForced {
+                                                    user_id: target_user_id,
+                                                    avatar: avatar_render_data.clone(),
+                                                    reason: ForcedAvatarReason::ModCommand,
+                                                    forced_by: Some(mod_member.display_name.clone()),
+                                                }).await;
+
+                                                // Broadcast avatar update to channel
+                                                let _ = tx.send(ServerMessage::AvatarUpdated {
+                                                    user_id: target_user_id,
+                                                    avatar: avatar_render_data,
+                                                });
+
+                                                let duration_msg = match duration_str {
+                                                    Some(d) => format!(" for {}", d),
+                                                    None => " permanently".to_string(),
+                                                };
+                                                let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                    success: true,
+                                                    message: format!("Forced {} to wear '{}'{}", target_nick, avatar_slug, duration_msg),
+                                                }).await;
+                                            } else {
+                                                let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                    success: false,
+                                                    message: format!("User '{}' is not online in this realm", target_nick),
+                                                }).await;
+                                            }
+                                        }
+                                        "undress" => {
+                                            // /mod undress [nick]
+                                            if args.is_empty() {
+                                                let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                    success: false,
+                                                    message: "Usage: /mod undress [nick]".to_string(),
+                                                }).await;
+                                                continue;
+                                            }
+
+                                            let target_nick = &args[0];
+
+                                            // Find target user
+                                            if let Some((target_user_id, target_conn)) = ws_state
+                                                .find_user_by_display_name(realm_id, target_nick)
+                                            {
+                                                // Acquire connection and set RLS context for the update
+                                                let mut rls_conn = match pool.acquire().await {
+                                                    Ok(c) => c,
+                                                    Err(e) => {
+                                                        let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                            success: false,
+                                                            message: format!("Database connection error: {:?}", e),
+                                                        }).await;
+                                                        continue;
+                                                    }
+                                                };
+                                                if let Err(e) = set_rls_user_id(&mut rls_conn, user_id).await {
+                                                    let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                        success: false,
+                                                        message: format!("Failed to set RLS context: {:?}", e),
+                                                    }).await;
+                                                    continue;
+                                                }
+
+                                                // Clear forced avatar using connection with RLS context
+                                                if let Err(e) = server_avatars::clear_forced_avatar(&mut *rls_conn, target_user_id, realm_id).await {
+                                                    let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                        success: false,
+                                                        message: format!("Failed to clear forced avatar: {:?}", e),
+                                                    }).await;
+                                                    continue;
+                                                }
+
+                                                // Get the user's original avatar
+                                                let original_avatar = match avatars::get_avatar_with_paths(&pool, target_user_id, realm_id).await {
+                                                    Ok(Some(avatar)) => avatar.to_render_data(),
+                                                    Ok(None) => AvatarRenderData::default(),
+                                                    Err(_) => AvatarRenderData::default(),
+                                                };
+
+                                                // Log moderation action
+                                                let metadata = serde_json::json!({});
+                                                let _ = moderation::log_moderation_action(
+                                                    &pool,
+                                                    realm_id,
+                                                    user_id,
+                                                    ActionType::UndressUser,
+                                                    Some(target_user_id),
+                                                    &format!("Cleared forced avatar for {}", target_nick),
+                                                    metadata,
+                                                ).await;
+
+                                                // Send AvatarCleared to target user
+                                                let _ = target_conn.direct_tx.send(ServerMessage::AvatarCleared {
+                                                    user_id: target_user_id,
+                                                    avatar: original_avatar.clone(),
+                                                    cleared_by: Some(mod_member.display_name.clone()),
+                                                }).await;
+
+                                                // Broadcast avatar update to channel
+                                                let _ = tx.send(ServerMessage::AvatarUpdated {
+                                                    user_id: target_user_id,
+                                                    avatar: original_avatar,
+                                                });
+
+                                                let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                    success: true,
+                                                    message: format!("Cleared forced avatar for {}", target_nick),
+                                                }).await;
+                                            } else {
+                                                let _ = direct_tx.send(ServerMessage::ModCommandResult {
+                                                    success: false,
+                                                    message: format!("User '{}' is not online in this realm", target_nick),
+                                                }).await;
+                                            }
+                                        }
                                         _ => {
                                             let _ = direct_tx.send(ServerMessage::ModCommandResult {
                                                 success: false,
@@ -1078,7 +1379,9 @@ async fn handle_socket(
                                     // Fetch updated user info from database
                                     match users::get_user_by_id(&pool, user_id).await {
                                         Ok(Some(updated_user)) => {
-                                            let is_guest: bool = updated_user.is_guest();
+                                            // Update the is_guest flag - critical for allowing
+                                            // newly registered users to send whispers
+                                            is_guest = updated_user.is_guest();
                                             let display_name = updated_user.display_name.clone();
 
                                             tracing::info!(
@@ -1088,6 +1391,19 @@ async fn handle_socket(
                                                 is_guest
                                             );
 
+                                            // Update WebSocket state with the new display name
+                                            // This is critical for whispers and mod commands to find
+                                            // the user by their new name after registration
+                                            if let Some(conn) = ws_state.get_user(user_id) {
+                                                ws_state.register_user(
+                                                    user_id,
+                                                    conn.direct_tx.clone(),
+                                                    conn.realm_id,
+                                                    conn.channel_id,
+                                                    display_name.clone(),
+                                                );
+                                            }
+
                                             // Broadcast identity update to all channel members
                                             let _ = tx.send(ServerMessage::MemberIdentityUpdated {
                                                 user_id,
@@ -1106,10 +1422,15 @@ async fn handle_socket(
                             }
                         }
                         Message::Close(close_frame) => {
-                            // Check close code for scene change
+                            // Check close code for scene change or logout
                             if let Some(CloseFrame { code, .. }) = close_frame {
                                 if code == close_codes::SCENE_CHANGE {
                                     disconnect_reason = DisconnectReason::SceneChange;
+                                } else if code == close_codes::LOGOUT {
+                                    // Explicit logout - treat as graceful disconnect
+                                    #[cfg(debug_assertions)]
+                                    tracing::debug!("[WS] User {} logged out", user_id);
+                                    disconnect_reason = DisconnectReason::Graceful;
                                 } else {
                                     disconnect_reason = DisconnectReason::Graceful;
                                 }
@@ -1224,8 +1545,7 @@ async fn handle_socket(
 
     // Broadcast departure with reason
     let _ = channel_state.tx.send(ServerMessage::MemberLeft {
-        user_id: Some(user_id),
-        guest_session_id: None,
+        user_id,
         reason: disconnect_reason,
     });
 }
@@ -1233,28 +1553,25 @@ async fn handle_socket(
 /// Helper: Get all channel members with their avatar render data.
 async fn get_members_with_avatars(
     conn: &mut sqlx::pool::PoolConnection<sqlx::Postgres>,
+    pool: &PgPool,
     channel_id: Uuid,
     realm_id: Uuid,
 ) -> Result<Vec<ChannelMemberWithAvatar>, AppError> {
     // Get members first
     let members = channel_members::get_channel_members(&mut **conn, channel_id, realm_id).await?;
 
-    // Fetch avatar data for each member using full avatar with paths
-    // This avoids the CASE statement approach and handles all emotions correctly
+    // Fetch avatar data for each member using the effective avatar resolution
+    // This handles the priority chain: forced > custom > selected realm > selected server > realm default > server default
     let mut result = Vec::with_capacity(members.len());
     for member in members {
-        let avatar = if let Some(user_id) = member.user_id {
-            // Get full avatar and convert to render data for current emotion
-            avatars::get_avatar_with_paths_conn(&mut **conn, user_id, realm_id)
-                .await
-                .ok()
-                .flatten()
-                .map(|a| a.to_render_data())
-                .unwrap_or_default()
-        } else {
-            // Guest users don't have avatars
-            AvatarRenderData::default()
-        };
+        // All members now have a user_id (guests are regular users with the 'guest' tag)
+        // Use the effective avatar resolution which handles all priority levels
+        let avatar = avatars::get_effective_avatar_render_data(pool, member.user_id, realm_id)
+            .await
+            .ok()
+            .flatten()
+            .map(|(render_data, _source)| render_data)
+            .unwrap_or_default();
         result.push(ChannelMemberWithAvatar { member, avatar });
     }
 

crates/chattyness-user-ui/src/app.rs

@@ -13,7 +13,7 @@ use std::sync::Arc;
 use crate::api::WebSocketState;
 
 #[cfg(feature = "ssr")]
-use chattyness_shared::WebSocketConfig;
+use chattyness_shared::{SignupConfig, WebSocketConfig};
 
 /// Application state for the public app.
 #[cfg(feature = "ssr")]
@@ -23,6 +23,7 @@ pub struct AppState {
     pub leptos_options: LeptosOptions,
     pub ws_state: Arc<WebSocketState>,
     pub ws_config: WebSocketConfig,
+    pub signup_config: SignupConfig,
 }
 
 #[cfg(feature = "ssr")]
@@ -53,6 +54,13 @@ impl axum::extract::FromRef<AppState> for WebSocketConfig {
     }
 }
 
+#[cfg(feature = "ssr")]
+impl axum::extract::FromRef<AppState> for SignupConfig {
+    fn from_ref(state: &AppState) -> Self {
+        state.signup_config.clone()
+    }
+}
+
 /// Shell component for SSR.
 pub fn shell(options: LeptosOptions) -> impl IntoView {
     view! {

crates/chattyness-user-ui/src/auth/rls.rs

@@ -19,7 +19,7 @@ use tower::{Layer, Service};
 use tower_sessions::Session;
 use uuid::Uuid;
 
-use super::session::{SESSION_GUEST_ID_KEY, SESSION_USER_ID_KEY};
+use super::session::SESSION_USER_ID_KEY;
 use chattyness_error::ErrorResponse;
 
 // =============================================================================
@@ -39,9 +39,6 @@ impl Drop for RlsConnectionInner {
                 let _ = sqlx::query("SELECT public.set_current_user_id(NULL)")
                     .execute(&mut *conn)
                     .await;
-                let _ = sqlx::query("SELECT public.set_current_guest_session_id(NULL)")
-                    .execute(&mut *conn)
-                    .await;
                 drop(conn);
                 drop(pool);
             });
@@ -218,9 +215,9 @@ where
         let session = request.extensions().get::<Session>().cloned();
 
         Box::pin(async move {
-            let (user_id, guest_session_id) = get_session_ids(session).await;
+            let user_id = get_session_user_id(session).await;
 
-            match acquire_rls_connection(&pool, user_id, guest_session_id).await {
+            match acquire_rls_connection(&pool, user_id).await {
                 Ok(rls_conn) => {
                     request.extensions_mut().insert(rls_conn);
                     inner.call(request).await
@@ -234,43 +231,30 @@ where
     }
 }
 
-async fn get_session_ids(session: Option<Session>) -> (Option<Uuid>, Option<Uuid>) {
+/// Get the user ID from the session if present.
+async fn get_session_user_id(session: Option<Session>) -> Option<Uuid> {
     let Some(session) = session else {
-        return (None, None);
+        return None;
     };
 
-    let user_id = session
+    session
         .get::<Uuid>(SESSION_USER_ID_KEY)
         .await
         .ok()
-        .flatten();
-    let guest_session_id = session
-        .get::<Uuid>(SESSION_GUEST_ID_KEY)
-        .await
-        .ok()
-        .flatten();
-
-    (user_id, guest_session_id)
+        .flatten()
 }
 
+/// Acquire an RLS connection with the user context set.
+/// Guests are now regular users with the 'guest' tag, so they use the same user_id path.
 async fn acquire_rls_connection(
     pool: &PgPool,
     user_id: Option<Uuid>,
-    guest_session_id: Option<Uuid>,
 ) -> Result<RlsConnection, sqlx::Error> {
     let mut conn = pool.acquire().await?;
 
-    if user_id.is_some() {
+    if let Some(id) = user_id {
         sqlx::query("SELECT public.set_current_user_id($1)")
-            .bind(user_id)
-            .execute(&mut *conn)
-            .await?;
-    } else if guest_session_id.is_some() {
-        sqlx::query("SELECT public.set_current_user_id(NULL)")
-            .execute(&mut *conn)
-            .await?;
-        sqlx::query("SELECT public.set_current_guest_session_id($1)")
-            .bind(guest_session_id)
+            .bind(id)
             .execute(&mut *conn)
             .await?;
     } else {

crates/chattyness-user-ui/src/auth/session.rs

@@ -19,9 +19,6 @@ pub const SESSION_CURRENT_REALM_KEY: &str = "current_realm_id";
 /// Session original destination key (for password reset redirect).
 pub const SESSION_ORIGINAL_DEST_KEY: &str = "original_destination";
 
-/// Session guest ID key (for guest sessions).
-pub const SESSION_GUEST_ID_KEY: &str = "guest_id";
-
 /// Create the session management layer.
 pub async fn create_session_layer(
     pool: PgPool,

crates/chattyness-user-ui/src/components.rs

@@ -2,6 +2,8 @@
 
 pub mod avatar_canvas;
 pub mod avatar_editor;
+pub mod avatar_store;
+pub mod avatar_thumbnail;
 pub mod chat;
 pub mod chat_types;
 pub mod context_menu;
@@ -28,6 +30,8 @@ pub mod ws_client;
 
 pub use avatar_canvas::*;
 pub use avatar_editor::*;
+pub use avatar_store::*;
+pub use avatar_thumbnail::*;
 pub use chat::*;
 pub use chat_types::*;
 pub use context_menu::*;

crates/chattyness-user-ui/src/components/avatar_canvas.rs

@@ -7,7 +7,7 @@
 use leptos::prelude::*;
 use uuid::Uuid;
 
-use chattyness_db::models::ChannelMemberWithAvatar;
+use chattyness_db::models::{ChannelMemberWithAvatar, EmotionState};
 
 use super::chat_types::{ActiveBubble, emotion_bubble_colors};
 
@@ -456,8 +456,9 @@ impl CanvasLayout {
 }
 
 /// Get a unique key for a member (for Leptos For keying).
-pub fn member_key(m: &ChannelMemberWithAvatar) -> (Option<Uuid>, Option<Uuid>) {
-    (m.member.user_id, m.member.guest_session_id)
+/// Note: Guests are now regular users with the 'guest' tag, so user_id is always present.
+pub fn member_key(m: &ChannelMemberWithAvatar) -> Uuid {
+    m.member.user_id
 }
 
 /// Individual avatar canvas component.
@@ -736,7 +737,7 @@ pub fn AvatarCanvas(
 
             // Draw emotion badge if non-neutral
             let current_emotion = m.member.current_emotion;
-            if current_emotion > 0 {
+            if current_emotion != EmotionState::Neutral {
                 let badge_size = 16.0 * layout.text_scale;
                 let badge_x = layout.avatar_cx + layout.avatar_size / 2.0 - badge_size / 2.0;
                 let badge_y = layout.avatar_cy - layout.avatar_size / 2.0 - badge_size / 2.0;
@@ -789,11 +790,7 @@ pub fn AvatarCanvas(
     // Compute data-member-id reactively
     let data_member_id = move || {
         let m = member.get();
-        m.member
-            .user_id
-            .map(|u| u.to_string())
-            .or_else(|| m.member.guest_session_id.map(|g| g.to_string()))
-            .unwrap_or_default()
+        m.member.user_id.to_string()
     };
 
     view! {

crates/chattyness-user-ui/src/components/avatar_editor.rs

@@ -294,7 +294,7 @@ pub fn AvatarEditorPopup(
             set_inventory_loading.set(true);
 
             spawn_local(async move {
-                let response = Request::get("/api/inventory").send().await;
+                let response = Request::get("/api/user/me/inventory").send().await;
                 match response {
                     Ok(resp) if resp.ok() => {
                         if let Ok(data) = resp

crates/chattyness-user-ui/src/components/avatar_store.rs

@@ -0,0 +1,544 @@
+//! Avatar store popup component.
+//!
+//! Allows users to browse and select pre-configured server and realm avatars.
+
+use leptos::prelude::*;
+use uuid::Uuid;
+
+use chattyness_db::models::{RealmAvatarWithPaths, ServerAvatarWithPaths};
+
+use super::avatar_thumbnail::AvatarThumbnail;
+use super::modals::{GuestLockedOverlay, Modal};
+use super::tabs::{Tab, TabBar};
+
+/// Avatar store popup component.
+///
+/// Shows a tabbed interface with:
+/// - Server Avatars: Public server-wide pre-configured avatars
+/// - Realm Avatars: Public realm-specific pre-configured avatars
+///
+/// Props:
+/// - `open`: Signal controlling visibility
+/// - `on_close`: Callback when popup should close
+/// - `realm_slug`: Current realm slug for API calls
+/// - `is_guest`: Whether the current user is a guest (shows locked overlay)
+/// - `on_avatar_selected`: Callback when an avatar is successfully selected
+#[component]
+pub fn AvatarStorePopup(
+    #[prop(into)] open: Signal<bool>,
+    on_close: Callback<()>,
+    #[prop(into)] realm_slug: Signal<String>,
+    /// Whether the current user is a guest. Guests see a locked overlay.
+    #[prop(optional, into)]
+    is_guest: Option<Signal<bool>>,
+    /// Callback fired when an avatar is successfully selected (for refreshing avatar state).
+    #[prop(optional, into)]
+    on_avatar_selected: Option<Callback<()>>,
+) -> impl IntoView {
+    let is_guest = is_guest.unwrap_or_else(|| Signal::derive(|| false));
+
+    // Tab state
+    let (active_tab, set_active_tab) = signal("server");
+
+    // Server avatars state
+    let (server_avatars, set_server_avatars) = signal(Vec::<ServerAvatarWithPaths>::new());
+    let (server_loading, set_server_loading) = signal(false);
+    let (server_error, set_server_error) = signal(Option::<String>::None);
+    let (selected_server_avatar, set_selected_server_avatar) = signal(Option::<Uuid>::None);
+
+    // Realm avatars state
+    let (realm_avatars, set_realm_avatars) = signal(Vec::<RealmAvatarWithPaths>::new());
+    let (realm_loading, set_realm_loading) = signal(false);
+    let (realm_error, set_realm_error) = signal(Option::<String>::None);
+    let (selected_realm_avatar, set_selected_realm_avatar) = signal(Option::<Uuid>::None);
+
+    // Track if tabs have been loaded
+    let (server_loaded, set_server_loaded) = signal(false);
+    let (realm_loaded, set_realm_loaded) = signal(false);
+
+    // Selection state
+    let (selecting, set_selecting) = signal(false);
+    let (selection_error, set_selection_error) = signal(Option::<String>::None);
+
+    // Fetch server avatars when popup opens or tab is selected
+    #[cfg(feature = "hydrate")]
+    {
+        use gloo_net::http::Request;
+        use leptos::task::spawn_local;
+
+        Effect::new(move |_| {
+            if !open.get() {
+                // Reset state when closing
+                set_selected_server_avatar.set(None);
+                set_selected_realm_avatar.set(None);
+                set_server_loaded.set(false);
+                set_realm_loaded.set(false);
+                set_selection_error.set(None);
+                return;
+            }
+
+            // Only fetch if on server tab and not already loaded
+            if active_tab.get() != "server" || server_loaded.get() {
+                return;
+            }
+
+            set_server_loading.set(true);
+            set_server_error.set(None);
+
+            spawn_local(async move {
+                let response = Request::get("/api/server/avatars").send().await;
+                match response {
+                    Ok(resp) if resp.ok() => {
+                        if let Ok(data) = resp.json::<Vec<ServerAvatarWithPaths>>().await {
+                            set_server_avatars.set(data);
+                            set_server_loaded.set(true);
+                        } else {
+                            set_server_error.set(Some("Failed to parse server avatars".to_string()));
+                        }
+                    }
+                    Ok(resp) => {
+                        set_server_error.set(Some(format!(
+                            "Failed to load server avatars: {}",
+                            resp.status()
+                        )));
+                    }
+                    Err(e) => {
+                        set_server_error.set(Some(format!("Network error: {}", e)));
+                    }
+                }
+                set_server_loading.set(false);
+            });
+        });
+    }
+
+    // Fetch realm avatars when realm tab is selected
+    #[cfg(feature = "hydrate")]
+    {
+        use gloo_net::http::Request;
+        use leptos::task::spawn_local;
+
+        Effect::new(move |_| {
+            if !open.get() || active_tab.get() != "realm" || realm_loaded.get() {
+                return;
+            }
+
+            let slug = realm_slug.get();
+            if slug.is_empty() {
+                set_realm_error.set(Some("No realm selected".to_string()));
+                return;
+            }
+
+            set_realm_loading.set(true);
+            set_realm_error.set(None);
+
+            spawn_local(async move {
+                let response = Request::get(&format!("/api/realms/{}/avatars", slug))
+                    .send()
+                    .await;
+                match response {
+                    Ok(resp) if resp.ok() => {
+                        if let Ok(data) = resp.json::<Vec<RealmAvatarWithPaths>>().await {
+                            set_realm_avatars.set(data);
+                            set_realm_loaded.set(true);
+                        } else {
+                            set_realm_error.set(Some("Failed to parse realm avatars".to_string()));
+                        }
+                    }
+                    Ok(resp) => {
+                        set_realm_error.set(Some(format!(
+                            "Failed to load realm avatars: {}",
+                            resp.status()
+                        )));
+                    }
+                    Err(e) => {
+                        set_realm_error.set(Some(format!("Network error: {}", e)));
+                    }
+                }
+                set_realm_loading.set(false);
+            });
+        });
+    }
+
+    // Handle avatar selection
+    #[cfg(feature = "hydrate")]
+    let select_avatar = {
+        let on_avatar_selected = on_avatar_selected.clone();
+        Callback::new(move |(avatar_id, source): (Uuid, &'static str)| {
+            set_selecting.set(true);
+            set_selection_error.set(None);
+
+            let slug = realm_slug.get();
+            let on_avatar_selected = on_avatar_selected.clone();
+
+            leptos::task::spawn_local(async move {
+                use gloo_net::http::Request;
+
+                let body = serde_json::json!({
+                    "avatar_id": avatar_id,
+                    "source": source
+                });
+
+                let response = Request::post(&format!("/api/realms/{}/avatar/select", slug))
+                    .header("Content-Type", "application/json")
+                    .body(body.to_string())
+                    .unwrap()
+                    .send()
+                    .await;
+
+                match response {
+                    Ok(resp) if resp.ok() => {
+                        // Notify parent of successful selection
+                        if let Some(callback) = on_avatar_selected {
+                            callback.run(());
+                        }
+                        set_selection_error.set(None);
+                    }
+                    Ok(resp) => {
+                        if let Ok(error_json) = resp.json::<serde_json::Value>().await {
+                            let error_msg = error_json
+                                .get("error")
+                                .and_then(|e| e.as_str())
+                                .unwrap_or("Unknown error");
+                            set_selection_error.set(Some(error_msg.to_string()));
+                        } else {
+                            set_selection_error.set(Some(format!(
+                                "Failed to select avatar: {}",
+                                resp.status()
+                            )));
+                        }
+                    }
+                    Err(e) => {
+                        set_selection_error.set(Some(format!("Network error: {}", e)));
+                    }
+                }
+                set_selecting.set(false);
+            });
+        })
+    };
+
+    #[cfg(not(feature = "hydrate"))]
+    let select_avatar = Callback::new(|_: (Uuid, &'static str)| {});
+
+    // Handle clear selection
+    #[cfg(feature = "hydrate")]
+    let clear_selection = {
+        let on_avatar_selected = on_avatar_selected.clone();
+        Callback::new(move |_: ()| {
+            set_selecting.set(true);
+            set_selection_error.set(None);
+
+            let slug = realm_slug.get();
+            let on_avatar_selected = on_avatar_selected.clone();
+
+            leptos::task::spawn_local(async move {
+                use gloo_net::http::Request;
+
+                let response = Request::delete(&format!("/api/realms/{}/avatar/selection", slug))
+                    .send()
+                    .await;
+
+                match response {
+                    Ok(resp) if resp.ok() => {
+                        // Notify parent of successful clear
+                        if let Some(callback) = on_avatar_selected {
+                            callback.run(());
+                        }
+                        set_selection_error.set(None);
+                    }
+                    Ok(resp) => {
+                        set_selection_error.set(Some(format!(
+                            "Failed to clear selection: {}",
+                            resp.status()
+                        )));
+                    }
+                    Err(e) => {
+                        set_selection_error.set(Some(format!("Network error: {}", e)));
+                    }
+                }
+                set_selecting.set(false);
+            });
+        })
+    };
+
+    #[cfg(not(feature = "hydrate"))]
+    let clear_selection = Callback::new(|_: ()| {});
+
+    view! {
+        <Modal
+            open=open
+            on_close=on_close
+            title="Avatar Store"
+            title_id="avatar-store-modal-title"
+            max_width="max-w-2xl"
+            class="max-h-[80vh] flex flex-col"
+        >
+            <div class="relative flex-1 flex flex-col">
+                // Tab bar
+                <TabBar
+                    tabs=vec![
+                        Tab::new("server", "Server Avatars"),
+                        Tab::new("realm", "Realm Avatars"),
+                    ]
+                    active=Signal::derive(move || active_tab.get())
+                    on_select=Callback::new(move |id| set_active_tab.set(id))
+                />
+
+                // Selection error message
+                <Show when=move || selection_error.get().is_some()>
+                    <div class="bg-red-900/20 border border-red-600 rounded p-3 mx-4 mb-2">
+                        <p class="text-red-400 text-sm">{move || selection_error.get().unwrap_or_default()}</p>
+                    </div>
+                </Show>
+
+                // Tab content
+                <div class="flex-1 overflow-y-auto min-h-[300px]">
+                    // Server Avatars tab
+                    <Show when=move || active_tab.get() == "server">
+                        <AvatarsTab
+                            avatars=Signal::derive(move || server_avatars.get().into_iter().map(|a| AvatarInfo {
+                                id: a.id,
+                                name: a.name,
+                                description: a.description,
+                                skin_layer: a.skin_layer,
+                                clothes_layer: a.clothes_layer,
+                                accessories_layer: a.accessories_layer,
+                                emotion_layer: a.emotion_layer,
+                            }).collect())
+                            loading=server_loading
+                            error=server_error
+                            selected_id=selected_server_avatar
+                            set_selected_id=set_selected_server_avatar
+                            source="server"
+                            tab_name="Server"
+                            empty_message="No public server avatars available"
+                            is_guest=is_guest
+                            selecting=selecting
+                            on_select=select_avatar.clone()
+                            on_clear=clear_selection.clone()
+                        />
+                    </Show>
+
+                    // Realm Avatars tab
+                    <Show when=move || active_tab.get() == "realm">
+                        <AvatarsTab
+                            avatars=Signal::derive(move || realm_avatars.get().into_iter().map(|a| AvatarInfo {
+                                id: a.id,
+                                name: a.name,
+                                description: a.description,
+                                skin_layer: a.skin_layer,
+                                clothes_layer: a.clothes_layer,
+                                accessories_layer: a.accessories_layer,
+                                emotion_layer: a.emotion_layer,
+                            }).collect())
+                            loading=realm_loading
+                            error=realm_error
+                            selected_id=selected_realm_avatar
+                            set_selected_id=set_selected_realm_avatar
+                            source="realm"
+                            tab_name="Realm"
+                            empty_message="No public realm avatars available"
+                            is_guest=is_guest
+                            selecting=selecting
+                            on_select=select_avatar.clone()
+                            on_clear=clear_selection.clone()
+                        />
+                    </Show>
+                </div>
+
+                // Guest locked overlay
+                <Show when=move || is_guest.get()>
+                    <GuestLockedOverlay />
+                </Show>
+            </div>
+        </Modal>
+    }
+}
+
+/// Simplified avatar info for the grid with resolved paths for rendering.
+#[derive(Clone)]
+struct AvatarInfo {
+    id: Uuid,
+    name: String,
+    description: Option<String>,
+    /// Asset paths for skin layer positions 0-8
+    skin_layer: [Option<String>; 9],
+    /// Asset paths for clothes layer positions 0-8
+    clothes_layer: [Option<String>; 9],
+    /// Asset paths for accessories layer positions 0-8
+    accessories_layer: [Option<String>; 9],
+    /// Asset paths for emotion layer positions 0-8
+    emotion_layer: [Option<String>; 9],
+}
+
+/// Avatars tab content with selection functionality.
+#[component]
+fn AvatarsTab(
+    #[prop(into)] avatars: Signal<Vec<AvatarInfo>>,
+    #[prop(into)] loading: Signal<bool>,
+    #[prop(into)] error: Signal<Option<String>>,
+    #[prop(into)] selected_id: Signal<Option<Uuid>>,
+    set_selected_id: WriteSignal<Option<Uuid>>,
+    source: &'static str,
+    tab_name: &'static str,
+    empty_message: &'static str,
+    #[prop(into)] is_guest: Signal<bool>,
+    #[prop(into)] selecting: Signal<bool>,
+    on_select: Callback<(Uuid, &'static str)>,
+    on_clear: Callback<()>,
+) -> impl IntoView {
+    view! {
+        // Loading state
+        <Show when=move || loading.get()>
+            <div class="flex items-center justify-center py-12">
+                <p class="text-gray-400">{format!("Loading {} avatars...", tab_name.to_lowercase())}</p>
+            </div>
+        </Show>
+
+        // Error state
+        <Show when=move || error.get().is_some()>
+            <div class="bg-red-900/20 border border-red-600 rounded p-4 mb-4 mx-4">
+                <p class="text-red-400">{move || error.get().unwrap_or_default()}</p>
+            </div>
+        </Show>
+
+        // Empty state
+        <Show when=move || !loading.get() && error.get().is_none() && avatars.get().is_empty()>
+            <div class="flex flex-col items-center justify-center py-12 text-center">
+                <div class="w-16 h-16 rounded-full bg-gray-700/50 flex items-center justify-center mb-4">
+                    <svg class="w-8 h-8 text-gray-500" fill="none" stroke="currentColor" viewBox="0 0 24 24" aria-hidden="true">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M16 7a4 4 0 11-8 0 4 4 0 018 0zM12 14a7 7 0 00-7 7h14a7 7 0 00-7-7z"/>
+                    </svg>
+                </div>
+                <p class="text-gray-400">{empty_message}</p>
+                <p class="text-gray-500 text-sm mt-1">"Pre-configured avatars will appear here when available"</p>
+            </div>
+        </Show>
+
+        // Grid of avatars
+        <Show when=move || !loading.get() && !avatars.get().is_empty()>
+            <div class="p-4">
+                <div
+                    class="grid grid-cols-4 sm:grid-cols-6 gap-3"
+                    role="listbox"
+                    aria-label=format!("{} avatars", tab_name)
+                >
+                    <For
+                        each=move || avatars.get()
+                        key=|avatar| avatar.id
+                        children=move |avatar: AvatarInfo| {
+                            let avatar_id = avatar.id;
+                            let avatar_name = avatar.name.clone();
+                            let is_selected = move || selected_id.get() == Some(avatar_id);
+
+                            // Create signals for the layer data
+                            let skin_layer = Signal::derive({
+                                let layers = avatar.skin_layer.clone();
+                                move || layers.clone()
+                            });
+                            let clothes_layer = Signal::derive({
+                                let layers = avatar.clothes_layer.clone();
+                                move || layers.clone()
+                            });
+                            let accessories_layer = Signal::derive({
+                                let layers = avatar.accessories_layer.clone();
+                                move || layers.clone()
+                            });
+                            let emotion_layer = Signal::derive({
+                                let layers = avatar.emotion_layer.clone();
+                                move || layers.clone()
+                            });
+
+                            view! {
+                                <button
+                                    type="button"
+                                    class=move || format!(
+                                        "aspect-square rounded-lg border-2 transition-all p-1 focus:outline-none focus:ring-2 focus:ring-blue-500 {}",
+                                        if is_selected() {
+                                            "border-blue-500 bg-blue-900/30"
+                                        } else {
+                                            "border-gray-600 hover:border-gray-500 bg-gray-700/50"
+                                        }
+                                    )
+                                    on:click=move |_| {
+                                        set_selected_id.set(Some(avatar_id));
+                                    }
+                                    role="option"
+                                    aria-selected=is_selected
+                                    aria-label=avatar_name
+                                >
+                                    <AvatarThumbnail
+                                        skin_layer=skin_layer
+                                        clothes_layer=clothes_layer
+                                        accessories_layer=accessories_layer
+                                        emotion_layer=emotion_layer
+                                        size=72
+                                    />
+                                </button>
+                            }
+                        }
+                    />
+                </div>
+
+                // Selected avatar details and actions
+                {move || {
+                    let avatar_id = selected_id.get()?;
+                    let avatar = avatars.get().into_iter().find(|a| a.id == avatar_id)?;
+                    let guest = is_guest.get();
+                    let is_selecting = selecting.get();
+
+                    let (button_text, button_class, button_disabled, button_title) = if guest {
+                        ("Sign in to Select", "bg-gray-600 text-gray-400 cursor-not-allowed", true, "Guests cannot select avatars")
+                    } else if is_selecting {
+                        ("Selecting...", "bg-blue-600 text-white opacity-50", true, "")
+                    } else {
+                        ("Select This Avatar", "bg-blue-600 hover:bg-blue-700 text-white", false, "Use this pre-configured avatar")
+                    };
+
+                    let avatar_name = avatar.name.clone();
+                    let avatar_description = avatar.description.clone();
+                    let on_select = on_select.clone();
+                    let on_clear = on_clear.clone();
+
+                    Some(view! {
+                        <div class="mt-4 pt-4 border-t border-gray-700">
+                            <div class="flex items-start justify-between gap-4">
+                                <div class="flex-1 min-w-0">
+                                    <h3 class="text-white font-medium truncate">{avatar_name}</h3>
+                                    {avatar_description.map(|desc| view! {
+                                        <p class="text-gray-400 text-sm mt-1 line-clamp-2">{desc}</p>
+                                    })}
+                                </div>
+                                <div class="flex gap-2 flex-shrink-0">
+                                    <button
+                                        type="button"
+                                        class="px-3 py-2 bg-gray-600 hover:bg-gray-700 text-white rounded-lg transition-colors text-sm disabled:opacity-50"
+                                        on:click=move |_| {
+                                            on_clear.run(());
+                                        }
+                                        disabled=is_selecting || guest
+                                        title="Clear selection and use custom/default avatar"
+                                    >
+                                        "Clear"
+                                    </button>
+                                    <button
+                                        type="button"
+                                        class=format!("px-4 py-2 rounded-lg transition-colors {}", button_class)
+                                        on:click=move |_| {
+                                            if !button_disabled {
+                                                on_select.run((avatar_id, source));
+                                            }
+                                        }
+                                        disabled=button_disabled
+                                        title=button_title
+                                    >
+                                        {button_text}
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+                    })
+                }}
+            </div>
+        </Show>
+    }
+}

crates/chattyness-user-ui/src/components/avatar_thumbnail.rs

@@ -0,0 +1,145 @@
+//! Avatar thumbnail component for rendering avatar previews.
+//!
+//! A simplified canvas-based component for rendering avatars in the
+//! avatar store grid. Uses the same layer compositing as the main
+//! avatar renderer but at thumbnail size.
+
+use leptos::prelude::*;
+use leptos::web_sys;
+
+/// Avatar thumbnail component for the avatar store.
+///
+/// Renders a small preview of an avatar using canvas compositing.
+/// Takes layer paths directly as props.
+///
+/// Props:
+/// - `skin_layer`: Asset paths for skin layer positions 0-8
+/// - `clothes_layer`: Asset paths for clothes layer positions 0-8
+/// - `accessories_layer`: Asset paths for accessories layer positions 0-8
+/// - `emotion_layer`: Asset paths for emotion layer positions 0-8
+/// - `size`: Optional canvas size in pixels (default: 80)
+#[component]
+pub fn AvatarThumbnail(
+    #[prop(into)] skin_layer: Signal<[Option<String>; 9]>,
+    #[prop(into)] clothes_layer: Signal<[Option<String>; 9]>,
+    #[prop(into)] accessories_layer: Signal<[Option<String>; 9]>,
+    #[prop(into)] emotion_layer: Signal<[Option<String>; 9]>,
+    #[prop(default = 80)] size: u32,
+) -> impl IntoView {
+    let canvas_ref = NodeRef::<leptos::html::Canvas>::new();
+    let cell_size = size / 3;
+
+    #[cfg(feature = "hydrate")]
+    {
+        use std::cell::RefCell;
+        use std::collections::HashMap;
+        use std::rc::Rc;
+        use wasm_bindgen::JsCast;
+        use wasm_bindgen::closure::Closure;
+
+        use crate::utils::normalize_asset_path;
+
+        // Image cache for this thumbnail
+        let image_cache: Rc<RefCell<HashMap<String, web_sys::HtmlImageElement>>> =
+            Rc::new(RefCell::new(HashMap::new()));
+
+        // Redraw trigger - incremented when images load
+        let (redraw_trigger, set_redraw_trigger) = signal(0u32);
+
+        Effect::new(move |_| {
+            // Subscribe to redraw trigger
+            let _ = redraw_trigger.get();
+
+            let Some(canvas) = canvas_ref.get() else {
+                return;
+            };
+
+            let skin = skin_layer.get();
+            let clothes = clothes_layer.get();
+            let accessories = accessories_layer.get();
+            let emotion = emotion_layer.get();
+
+            let canvas_el: &web_sys::HtmlCanvasElement = &canvas;
+            canvas_el.set_width(size);
+            canvas_el.set_height(size);
+
+            let Ok(Some(ctx)) = canvas_el.get_context("2d") else {
+                return;
+            };
+            let ctx: web_sys::CanvasRenderingContext2d = ctx.dyn_into().unwrap();
+
+            // Clear canvas
+            ctx.clear_rect(0.0, 0.0, size as f64, size as f64);
+
+            // Draw background
+            ctx.set_fill_style_str("#374151");
+            ctx.fill_rect(0.0, 0.0, size as f64, size as f64);
+
+            // Helper to load and draw an image at a grid position
+            let draw_at_position =
+                |path: &str,
+                 pos: usize,
+                 cache: &Rc<RefCell<HashMap<String, web_sys::HtmlImageElement>>>,
+                 ctx: &web_sys::CanvasRenderingContext2d| {
+                    let normalized_path = normalize_asset_path(path);
+                    let mut cache_borrow = cache.borrow_mut();
+                    let row = pos / 3;
+                    let col = pos % 3;
+                    let x = (col * cell_size as usize) as f64;
+                    let y = (row * cell_size as usize) as f64;
+                    let sz = cell_size as f64;
+
+                    if let Some(img) = cache_borrow.get(&normalized_path) {
+                        if img.complete() && img.natural_width() > 0 {
+                            let _ = ctx.draw_image_with_html_image_element_and_dw_and_dh(
+                                img, x, y, sz, sz,
+                            );
+                        }
+                    } else {
+                        let img = web_sys::HtmlImageElement::new().unwrap();
+                        let trigger = set_redraw_trigger;
+                        let onload = Closure::once(Box::new(move || {
+                            trigger.update(|v| *v += 1);
+                        }) as Box<dyn FnOnce()>);
+                        img.set_onload(Some(onload.as_ref().unchecked_ref()));
+                        onload.forget();
+                        img.set_src(&normalized_path);
+                        cache_borrow.insert(normalized_path, img);
+                    }
+                };
+
+            // Draw layers in order: skin -> clothes -> accessories -> emotion
+            for (pos, path) in skin.iter().enumerate() {
+                if let Some(p) = path {
+                    draw_at_position(p, pos, &image_cache, &ctx);
+                }
+            }
+
+            for (pos, path) in clothes.iter().enumerate() {
+                if let Some(p) = path {
+                    draw_at_position(p, pos, &image_cache, &ctx);
+                }
+            }
+
+            for (pos, path) in accessories.iter().enumerate() {
+                if let Some(p) = path {
+                    draw_at_position(p, pos, &image_cache, &ctx);
+                }
+            }
+
+            for (pos, path) in emotion.iter().enumerate() {
+                if let Some(p) = path {
+                    draw_at_position(p, pos, &image_cache, &ctx);
+                }
+            }
+        });
+    }
+
+    view! {
+        <canvas
+            node_ref=canvas_ref
+            style=format!("width: {}px; height: {}px;", size, size)
+            class="rounded"
+        />
+    }
+}

crates/chattyness-user-ui/src/components/chat.rs

@@ -903,6 +903,12 @@ pub fn ChatInput(
                     <span class="text-purple-600">" | "</span>
                     <span class="text-purple-300">"teleport"</span>
                     <span class="text-purple-500">" [nick] [slug]"</span>
+                    <span class="text-purple-600">" | "</span>
+                    <span class="text-purple-300">"dress"</span>
+                    <span class="text-purple-500">" [nick] [avatar] [dur?]"</span>
+                    <span class="text-purple-600">" | "</span>
+                    <span class="text-purple-300">"undress"</span>
+                    <span class="text-purple-500">" [nick]"</span>
                 </div>
             </Show>
 

crates/chattyness-user-ui/src/components/chat_types.rs

@@ -11,11 +11,12 @@ pub const MAX_MESSAGE_LOG_SIZE: usize = 2000;
 pub const DEFAULT_BUBBLE_TIMEOUT_MS: i64 = 60_000;
 
 /// A chat message for display and logging.
+/// Note: Guests are now regular users with the 'guest' tag, so all messages have a user_id.
+/// System messages use Uuid::nil() as the user_id.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct ChatMessage {
     pub message_id: Uuid,
-    pub user_id: Option<Uuid>,
-    pub guest_session_id: Option<Uuid>,
+    pub user_id: Uuid,
     pub display_name: String,
     pub content: String,
     /// Emotion name (e.g., "happy", "sad", "neutral").
@@ -70,15 +71,8 @@ impl MessageLog {
     }
 
     /// Get the latest message from a specific user.
-    pub fn latest_from_user(
-        &self,
-        user_id: Option<Uuid>,
-        guest_id: Option<Uuid>,
-    ) -> Option<&ChatMessage> {
-        self.messages
-            .iter()
-            .rev()
-            .find(|m| m.user_id == user_id && m.guest_session_id == guest_id)
+    pub fn latest_from_user(&self, user_id: Uuid) -> Option<&ChatMessage> {
+        self.messages.iter().rev().find(|m| m.user_id == user_id)
     }
 
     /// Get all messages.

crates/chattyness-user-ui/src/components/hotkey_help.rs

@@ -50,6 +50,7 @@ pub fn HotkeyHelp(
                     <HotkeyRow key="i" description="Inventory" />
                     <HotkeyRow key="k" description="Keybindings" />
                     <HotkeyRow key="a" description="Avatar editor" />
+                    <HotkeyRow key="t" description="Avatar store" />
                     <HotkeyRow key="l" description="Message log" />
 
                     // Emotions

crates/chattyness-user-ui/src/components/scene_viewer.rs

@@ -37,7 +37,7 @@ pub fn RealmSceneViewer(
     scene: Scene,
     realm_slug: String,
     #[prop(into)] members: Signal<Vec<ChannelMemberWithAvatar>>,
-    #[prop(into)] active_bubbles: Signal<HashMap<(Option<Uuid>, Option<Uuid>), ActiveBubble>>,
+    #[prop(into)] active_bubbles: Signal<HashMap<Uuid, ActiveBubble>>,
     #[prop(into)] loose_props: Signal<Vec<LooseProp>>,
     #[prop(into)] on_move: Callback<(f64, f64)>,
     #[prop(into)] on_prop_click: Callback<Uuid>,
@@ -51,11 +51,9 @@ pub fn RealmSceneViewer(
     #[prop(optional, into)]
     fading_members: Option<Signal<Vec<FadingMember>>>,
     /// Current user's user_id (for context menu filtering).
+    /// Note: Guests are now regular users with the 'guest' tag.
     #[prop(optional, into)]
     current_user_id: Option<Signal<Option<Uuid>>>,
-    /// Current user's guest_session_id (for context menu filtering).
-    #[prop(optional, into)]
-    current_guest_session_id: Option<Signal<Option<Uuid>>>,
     /// Whether the current user is a guest (guests cannot use context menu).
     #[prop(optional, into)]
     is_guest: Option<Signal<bool>>,
@@ -183,7 +181,6 @@ pub fn RealmSceneViewer(
     #[cfg(feature = "hydrate")]
     let on_overlay_contextmenu = {
         let current_user_id = current_user_id.clone();
-        let current_guest_session_id = current_guest_session_id.clone();
         move |ev: web_sys::MouseEvent| {
             use wasm_bindgen::JsCast;
 
@@ -194,7 +191,6 @@ pub fn RealmSceneViewer(
 
             // Get current user identity for filtering
             let my_user_id = current_user_id.map(|s| s.get()).flatten();
-            let my_guest_session_id = current_guest_session_id.map(|s| s.get()).flatten();
 
             // Get click position
             let client_x = ev.client_x() as f64;
@@ -215,22 +211,17 @@ pub fn RealmSceneViewer(
                             if let Some(member_id_str) = canvas.get_attribute("data-member-id") {
                                 // Check if click hits a non-transparent pixel
                                 if hit_test_canvas(&canvas, client_x, client_y) {
-                                    // Parse the member ID to determine if it's a user_id or guest_session_id
+                                    // Parse the member ID (now always user_id since guests are users)
                                     if let Ok(member_id) = member_id_str.parse::<Uuid>() {
                                         // Check if this is the current user's avatar
-                                        let is_current_user = my_user_id == Some(member_id)
-                                            || my_guest_session_id == Some(member_id);
+                                        let is_current_user = my_user_id == Some(member_id);
 
                                         if !is_current_user {
                                             // Find the display name for this member
                                             let display_name = members
                                                 .get()
                                                 .iter()
-                                                .find(|m| {
-                                                    m.member.user_id == Some(member_id)
-                                                        || m.member.guest_session_id
-                                                            == Some(member_id)
-                                                })
+                                                .find(|m| m.member.user_id == member_id)
                                                 .map(|m| m.member.display_name.clone());
 
                                             if let Some(name) = display_name {

crates/chattyness-user-ui/src/components/ws_client.rs

@@ -58,12 +58,11 @@ pub type WsSender = Box<dyn Fn(ClientMessage)>;
 pub type WsSenderStorage = StoredValue<Option<WsSender>, LocalStorage>;
 
 /// Information about the current channel member (received on Welcome).
+/// Note: Guests are now regular users with the 'guest' tag, so all members have a user_id.
 #[derive(Clone, Debug)]
 pub struct ChannelMemberInfo {
-    /// The user's user_id (if authenticated user).
-    pub user_id: Option<uuid::Uuid>,
-    /// The user's guest_session_id (if guest).
-    pub guest_session_id: Option<uuid::Uuid>,
+    /// The user's user_id.
+    pub user_id: uuid::Uuid,
     /// The user's display name.
     pub display_name: String,
     /// Whether this user is a guest (has the 'guest' tag).
@@ -99,6 +98,12 @@ pub struct SummonInfo {
     pub summoned_by: String,
 }
 
+/// Close function type for WebSocket (takes close code and reason).
+pub type WsCloser = Box<dyn Fn(u16, String)>;
+
+/// Local stored value type for the closer (non-Send, WASM-compatible).
+pub type WsCloserStorage = StoredValue<Option<WsCloser>, LocalStorage>;
+
 /// Result of a moderator command.
 #[derive(Clone, Debug)]
 pub struct ModCommandResultInfo {
@@ -119,48 +124,92 @@ pub struct MemberIdentityInfo {
     pub is_guest: bool,
 }
 
+/// Consolidated WebSocket event enum.
+///
+/// All WebSocket events are routed through this enum for a cleaner API.
+#[derive(Clone, Debug)]
+pub enum WsEvent {
+    /// Members list updated.
+    MembersUpdated(Vec<ChannelMemberWithAvatar>),
+    /// Chat message received.
+    ChatMessage(ChatMessage),
+    /// Loose props synchronized (initial list).
+    LoosePropsSync(Vec<LooseProp>),
+    /// A prop was dropped.
+    PropDropped(LooseProp),
+    /// A prop was picked up (by prop ID).
+    PropPickedUp(uuid::Uuid),
+    /// A member started fading out (timeout disconnect).
+    MemberFading(FadingMember),
+    /// Welcome message received with current user info.
+    Welcome(ChannelMemberInfo),
+    /// Error from server.
+    Error(WsError),
+    /// Teleport approved - navigate to new scene.
+    TeleportApproved(TeleportInfo),
+    /// Summoned by moderator.
+    Summoned(SummonInfo),
+    /// Moderator command result.
+    ModCommandResult(ModCommandResultInfo),
+    /// Member identity updated (e.g., guest → user).
+    MemberIdentityUpdated(MemberIdentityInfo),
+}
+
+/// Consolidated internal state to reduce Rc<RefCell<>> proliferation.
+#[cfg(feature = "hydrate")]
+struct WsInternalState {
+    ws: Option<web_sys::WebSocket>,
+    members: Vec<ChannelMemberWithAvatar>,
+    current_user_id: Option<uuid::Uuid>,
+    is_intentional_close: bool,
+    heartbeat_handle: Option<gloo_timers::callback::Interval>,
+}
+
+#[cfg(feature = "hydrate")]
+impl Default for WsInternalState {
+    fn default() -> Self {
+        Self {
+            ws: None,
+            members: Vec::new(),
+            current_user_id: None,
+            is_intentional_close: false,
+            heartbeat_handle: None,
+        }
+    }
+}
+
 /// Hook to manage WebSocket connection for a channel.
 ///
 /// Returns a tuple of:
 /// - `Signal<WsState>` - The current connection state
 /// - `WsSenderStorage` - A stored sender function to send messages
+/// - `WsCloserStorage` - A stored close function to close the WebSocket with a specific code
 #[cfg(feature = "hydrate")]
 pub fn use_channel_websocket(
     realm_slug: Signal<String>,
     channel_id: Signal<Option<uuid::Uuid>>,
     reconnect_trigger: RwSignal<u32>,
-    on_members_update: Callback<Vec<ChannelMemberWithAvatar>>,
-    on_chat_message: Callback<ChatMessage>,
-    on_loose_props_sync: Callback<Vec<LooseProp>>,
-    on_prop_dropped: Callback<LooseProp>,
-    on_prop_picked_up: Callback<uuid::Uuid>,
-    on_member_fading: Callback<FadingMember>,
-    on_welcome: Option<Callback<ChannelMemberInfo>>,
-    on_error: Option<Callback<WsError>>,
-    on_teleport_approved: Option<Callback<TeleportInfo>>,
-    on_summoned: Option<Callback<SummonInfo>>,
-    on_mod_command_result: Option<Callback<ModCommandResultInfo>>,
-    on_member_identity_updated: Option<Callback<MemberIdentityInfo>>,
-) -> (Signal<WsState>, WsSenderStorage) {
+    on_event: Callback<WsEvent>,
+) -> (Signal<WsState>, WsSenderStorage, WsCloserStorage) {
     use std::cell::RefCell;
     use std::rc::Rc;
+    use std::sync::Arc;
+    use std::sync::atomic::{AtomicBool, Ordering};
     use wasm_bindgen::{JsCast, closure::Closure};
     use web_sys::{CloseEvent, ErrorEvent, MessageEvent, WebSocket};
 
     let (ws_state, set_ws_state) = signal(WsState::Disconnected);
-    let ws_ref: Rc<RefCell<Option<WebSocket>>> = Rc::new(RefCell::new(None));
-    let members: Rc<RefCell<Vec<ChannelMemberWithAvatar>>> = Rc::new(RefCell::new(Vec::new()));
-    // Track current user's ID to ignore self MemberLeft during reconnection
-    let current_user_id: Rc<RefCell<Option<uuid::Uuid>>> = Rc::new(RefCell::new(None));
-    // Flag to track intentional closes (teleport, scene change) - guarantees local state
-    // even if close code doesn't arrive correctly due to browser/server quirks
-    let is_intentional_close: Rc<RefCell<bool>> = Rc::new(RefCell::new(false));
+
+    let state: Rc<RefCell<WsInternalState>> = Rc::new(RefCell::new(WsInternalState::default()));
+    // Flag to prevent accessing disposed reactive values after component unmount
+    let is_disposed: Arc<AtomicBool> = Arc::new(AtomicBool::new(false));
 
     // Create a stored sender function (using new_local for WASM single-threaded environment)
-    let ws_ref_for_send = ws_ref.clone();
+    let state_for_send = state.clone();
     let sender: WsSenderStorage =
         StoredValue::new_local(Some(Box::new(move |msg: ClientMessage| {
-            if let Some(ws) = ws_ref_for_send.borrow().as_ref() {
+            let state = state_for_send.borrow();
+            if let Some(ws) = state.ws.as_ref() {
                 if ws.ready_state() == WebSocket::OPEN {
                     if let Ok(json) = serde_json::to_string(&msg) {
                         #[cfg(debug_assertions)]
@@ -171,10 +220,18 @@ pub fn use_channel_websocket(
             }
         })));
 
+    // Clone for closer callback (must be done before Effect captures state)
+    let state_for_close = state.clone();
+
+    // Set disposed flag on cleanup to prevent accessing disposed reactive values
+    let is_disposed_for_cleanup = is_disposed.clone();
+    on_cleanup(move || {
+        is_disposed_for_cleanup.store(true, Ordering::Relaxed);
+    });
+
     // Effect to manage WebSocket lifecycle
-    let ws_ref_clone = ws_ref.clone();
-    let members_clone = members.clone();
-    let is_intentional_close_for_cleanup = is_intentional_close.clone();
+    let state_for_effect = state.clone();
+    let is_disposed_for_effect = is_disposed.clone();
 
     Effect::new(move |_| {
         let slug = realm_slug.get();
@@ -183,15 +240,20 @@ pub fn use_channel_websocket(
         let _trigger = reconnect_trigger.get();
 
         // Cleanup previous connection
-        if let Some(old_ws) = ws_ref_clone.borrow_mut().take() {
-            #[cfg(debug_assertions)]
-            web_sys::console::log_1(
-                &format!("[WS] Closing old connection, readyState={}", old_ws.ready_state()).into(),
-            );
-            // Set flag BEFORE closing - guarantees local state even if close code doesn't arrive
-            *is_intentional_close_for_cleanup.borrow_mut() = true;
-            // Close with SCENE_CHANGE code so onclose handler knows this was intentional
-            let _ = old_ws.close_with_code_and_reason(close_codes::SCENE_CHANGE, "scene change");
+        {
+            let mut state = state_for_effect.borrow_mut();
+            if let Some(old_ws) = state.ws.take() {
+                #[cfg(debug_assertions)]
+                web_sys::console::log_1(
+                    &format!("[WS] Closing old connection, readyState={}", old_ws.ready_state()).into(),
+                );
+                // Set flag BEFORE closing - guarantees local state even if close code doesn't arrive
+                state.is_intentional_close = true;
+                // Cancel existing heartbeat
+                state.heartbeat_handle = None;
+                // Close with SCENE_CHANGE code so onclose handler knows this was intentional
+                let _ = old_ws.close_with_code_and_reason(close_codes::SCENE_CHANGE, "scene change");
+            }
         }
 
         let Some(ch_id) = ch_id else {
@@ -244,26 +306,14 @@ pub fn use_channel_websocket(
         onopen.forget();
 
         // onmessage
-        let members_for_msg = members_clone.clone();
-        let on_members_update_clone = on_members_update.clone();
-        let on_chat_message_clone = on_chat_message.clone();
-        let on_loose_props_sync_clone = on_loose_props_sync.clone();
-        let on_prop_dropped_clone = on_prop_dropped.clone();
-        let on_prop_picked_up_clone = on_prop_picked_up.clone();
-        let on_member_fading_clone = on_member_fading.clone();
-        let on_welcome_clone = on_welcome.clone();
-        let on_error_clone = on_error.clone();
-        let on_teleport_approved_clone = on_teleport_approved.clone();
-        let on_summoned_clone = on_summoned.clone();
-        let on_mod_command_result_clone = on_mod_command_result.clone();
-        let on_member_identity_updated_clone = on_member_identity_updated.clone();
-        // For starting heartbeat on Welcome
-        let ws_ref_for_heartbeat = ws_ref.clone();
-        let heartbeat_started: Rc<RefCell<bool>> = Rc::new(RefCell::new(false));
-        let heartbeat_started_clone = heartbeat_started.clone();
-        // For tracking current user ID to ignore self MemberLeft during reconnection
-        let current_user_id_for_msg = current_user_id.clone();
+        let state_for_msg = state_for_effect.clone();
+        let on_event_for_msg = on_event.clone();
+        let is_disposed_for_msg = is_disposed_for_effect.clone();
         let onmessage = Closure::wrap(Box::new(move |e: MessageEvent| {
+            // Skip if component has been disposed
+            if is_disposed_for_msg.load(Ordering::Relaxed) {
+                return;
+            }
             if let Ok(text) = e.data().dyn_into::<js_sys::JsString>() {
                 let text: String = text.into();
                 #[cfg(debug_assertions)]
@@ -278,12 +328,13 @@ pub fn use_channel_websocket(
                     } = msg
                     {
                         // Track current user ID for MemberLeft filtering
-                        *current_user_id_for_msg.borrow_mut() = member.user_id;
+                        state_for_msg.borrow_mut().current_user_id = Some(member.user_id);
 
-                        if !*heartbeat_started_clone.borrow() {
-                            *heartbeat_started_clone.borrow_mut() = true;
+                        // Start heartbeat if not already running
+                        let needs_heartbeat = state_for_msg.borrow().heartbeat_handle.is_none();
+                        if needs_heartbeat {
                             let ping_interval_ms = config.ping_interval_secs * 1000;
-                            let ws_ref_ping = ws_ref_for_heartbeat.clone();
+                            let state_for_ping = state_for_msg.clone();
                             #[cfg(debug_assertions)]
                             web_sys::console::log_1(
                                 &format!(
@@ -295,7 +346,8 @@ pub fn use_channel_websocket(
                             let heartbeat = gloo_timers::callback::Interval::new(
                                 ping_interval_ms as u32,
                                 move || {
-                                    if let Some(ws) = ws_ref_ping.borrow().as_ref() {
+                                    let state = state_for_ping.borrow();
+                                    if let Some(ws) = state.ws.as_ref() {
                                         if ws.ready_state() == WebSocket::OPEN {
                                             if let Ok(json) =
                                                 serde_json::to_string(&ClientMessage::Ping)
@@ -306,35 +358,17 @@ pub fn use_channel_websocket(
                                     }
                                 },
                             );
-                            std::mem::forget(heartbeat);
+                            state_for_msg.borrow_mut().heartbeat_handle = Some(heartbeat);
                         }
                         // Call on_welcome callback with current user info
-                        if let Some(ref callback) = on_welcome_clone {
-                            let info = ChannelMemberInfo {
-                                user_id: member.user_id,
-                                guest_session_id: member.guest_session_id,
-                                display_name: member.display_name.clone(),
-                                is_guest: member.is_guest,
-                            };
-                            callback.run(info);
-                        }
+                        let info = ChannelMemberInfo {
+                            user_id: member.user_id,
+                            display_name: member.display_name.clone(),
+                            is_guest: member.is_guest,
+                        };
+                        on_event_for_msg.run(WsEvent::Welcome(info));
                     }
-                    handle_server_message(
-                        msg,
-                        &members_for_msg,
-                        &on_members_update_clone,
-                        &on_chat_message_clone,
-                        &on_loose_props_sync_clone,
-                        &on_prop_dropped_clone,
-                        &on_prop_picked_up_clone,
-                        &on_member_fading_clone,
-                        &on_error_clone,
-                        &on_teleport_approved_clone,
-                        &on_summoned_clone,
-                        &on_mod_command_result_clone,
-                        &on_member_identity_updated_clone,
-                        &current_user_id_for_msg,
-                    );
+                    handle_server_message(msg, &state_for_msg, &on_event_for_msg);
                 }
             }
         }) as Box<dyn FnMut(MessageEvent)>);
@@ -345,7 +379,12 @@ pub fn use_channel_websocket(
         let set_ws_state_err = set_ws_state;
         let ws_state_for_err = ws_state;
         let reconnect_trigger_for_error = reconnect_trigger;
+        let is_disposed_for_err = is_disposed_for_effect.clone();
         let onerror = Closure::wrap(Box::new(move |e: ErrorEvent| {
+            // Skip if component has been disposed
+            if is_disposed_for_err.load(Ordering::Relaxed) {
+                return;
+            }
             #[cfg(debug_assertions)]
             web_sys::console::error_1(&format!("[WS] Error: {:?}", e.message()).into());
 
@@ -386,16 +425,27 @@ pub fn use_channel_websocket(
         onerror.forget();
 
         // onclose
+        let state_for_close = state_for_effect.clone();
         let set_ws_state_close = set_ws_state;
         let reconnect_trigger_for_close = reconnect_trigger;
-        let is_intentional_close_for_onclose = is_intentional_close.clone();
+        let is_disposed_for_close = is_disposed_for_effect.clone();
         let onclose = Closure::wrap(Box::new(move |e: CloseEvent| {
+            // Skip if component has been disposed
+            if is_disposed_for_close.load(Ordering::Relaxed) {
+                return;
+            }
             let code = e.code();
             #[cfg(debug_assertions)]
             web_sys::console::log_1(
                 &format!("[WS] Closed: code={}, reason={}", code, e.reason()).into(),
             );
 
+            // Cancel heartbeat on close
+            state_for_close.borrow_mut().heartbeat_handle = None;
+
+            // Check if this was an intentional close
+            let is_intentional = state_for_close.borrow().is_intentional_close;
+
             // Handle based on close code with defense-in-depth using flag
             if code == close_codes::SERVER_TIMEOUT {
                 // Server timeout - attempt silent reconnection (highest priority)
@@ -408,13 +458,16 @@ pub fn use_channel_websocket(
                     reconnect_trigger.update(|v| *v = v.wrapping_add(1));
                 })
                 .forget();
-            } else if code == close_codes::SCENE_CHANGE || *is_intentional_close_for_onclose.borrow() {
-                // Intentional close (scene change/teleport) - don't show disconnection
+            } else if code == close_codes::SCENE_CHANGE
+                || code == close_codes::LOGOUT
+                || is_intentional
+            {
+                // Intentional close (scene change/teleport/logout) - don't show disconnection
                 // Check both code AND flag for defense-in-depth (flag is guaranteed local state)
                 #[cfg(debug_assertions)]
                 web_sys::console::log_1(&"[WS] Intentional close, not setting Disconnected".into());
                 // Reset the flag for future connections
-                *is_intentional_close_for_onclose.borrow_mut() = false;
+                state_for_close.borrow_mut().is_intentional_close = false;
             } else {
                 // Other close codes - treat as disconnection
                 set_ws_state_close.set(WsState::Disconnected);
@@ -423,153 +476,148 @@ pub fn use_channel_websocket(
         ws.set_onclose(Some(onclose.as_ref().unchecked_ref()));
         onclose.forget();
 
-        *ws_ref_clone.borrow_mut() = Some(ws);
+        state_for_effect.borrow_mut().ws = Some(ws);
     });
 
-    (Signal::derive(move || ws_state.get()), sender)
+    // Create closer function for explicit WebSocket closure (e.g., logout)
+    let closer: WsCloserStorage = StoredValue::new_local(Some(Box::new(move |code: u16, reason: String| {
+        let mut state = state_for_close.borrow_mut();
+        // Set intentional close flag BEFORE closing
+        state.is_intentional_close = true;
+        // Cancel heartbeat
+        state.heartbeat_handle = None;
+        // Get the WebSocket (if any) and close it
+        if let Some(ws) = state.ws.as_ref() {
+            #[cfg(debug_assertions)]
+            web_sys::console::log_1(
+                &format!("[WS] Closing with code={}, reason={}", code, reason).into(),
+            );
+            let _ = ws.close_with_code_and_reason(code, &reason);
+        }
+    })));
+
+    (Signal::derive(move || ws_state.get()), sender, closer)
 }
 
 /// Handle a message received from the server.
 #[cfg(feature = "hydrate")]
 fn handle_server_message(
     msg: ServerMessage,
-    members: &std::rc::Rc<std::cell::RefCell<Vec<ChannelMemberWithAvatar>>>,
-    on_update: &Callback<Vec<ChannelMemberWithAvatar>>,
-    on_chat_message: &Callback<ChatMessage>,
-    on_loose_props_sync: &Callback<Vec<LooseProp>>,
-    on_prop_dropped: &Callback<LooseProp>,
-    on_prop_picked_up: &Callback<uuid::Uuid>,
-    on_member_fading: &Callback<FadingMember>,
-    on_error: &Option<Callback<WsError>>,
-    on_teleport_approved: &Option<Callback<TeleportInfo>>,
-    on_summoned: &Option<Callback<SummonInfo>>,
-    on_mod_command_result: &Option<Callback<ModCommandResultInfo>>,
-    on_member_identity_updated: &Option<Callback<MemberIdentityInfo>>,
-    current_user_id: &std::rc::Rc<std::cell::RefCell<Option<uuid::Uuid>>>,
+    state: &std::rc::Rc<std::cell::RefCell<WsInternalState>>,
+    on_event: &Callback<WsEvent>,
 ) {
-    let mut members_vec = members.borrow_mut();
+    // Process message and collect any events to emit AFTER releasing the borrow
+    enum PostAction {
+        None,
+        UpdateMembers(Vec<ChannelMemberWithAvatar>),
+        UpdateMembersAndFade(Vec<ChannelMemberWithAvatar>, FadingMember),
+        UpdateMembersAndIdentity(Vec<ChannelMemberWithAvatar>, MemberIdentityInfo),
+        ChatMessage(ChatMessage),
+        LoosePropsSync(Vec<LooseProp>),
+        PropDropped(LooseProp),
+        PropPickedUp(uuid::Uuid),
+        Error(WsError),
+        TeleportApproved(TeleportInfo),
+        Summoned(SummonInfo),
+        ModCommandResult(ModCommandResultInfo),
+    }
 
-    match msg {
-        ServerMessage::Welcome {
-            member: _,
-            members: initial_members,
-            config: _, // Config is handled in the caller for heartbeat setup
-        } => {
-            *members_vec = initial_members;
-            on_update.run(members_vec.clone());
-        }
-        ServerMessage::MemberJoined { member } => {
-            // Remove if exists (rejoin case), then add
-            members_vec.retain(|m| {
-                m.member.user_id != member.member.user_id
-                    || m.member.guest_session_id != member.member.guest_session_id
-            });
-            members_vec.push(member);
-            on_update.run(members_vec.clone());
-        }
-        ServerMessage::MemberLeft {
-            user_id,
-            guest_session_id,
-            reason,
-        } => {
-            // Check if this is our own MemberLeft due to timeout - ignore it during reconnection
-            // so we don't see our own avatar fade out
-            let own_user_id = *current_user_id.borrow();
-            let is_self = own_user_id.is_some() && user_id == own_user_id;
-            if is_self && reason == DisconnectReason::Timeout {
-                #[cfg(debug_assertions)]
-                web_sys::console::log_1(
-                    &"[WS] Ignoring self MemberLeft during reconnection".into(),
-                );
-                return;
+    let action = {
+        let mut state = state.borrow_mut();
+        let own_user_id = state.current_user_id;
+
+        match msg {
+            ServerMessage::Welcome {
+                member: _,
+                members: initial_members,
+                config: _, // Config is handled in the caller for heartbeat setup
+            } => {
+                state.members = initial_members;
+                PostAction::UpdateMembers(state.members.clone())
             }
+            ServerMessage::MemberJoined { member } => {
+                // Remove if exists (rejoin case), then add
+                state.members.retain(|m| m.member.user_id != member.member.user_id);
+                state.members.push(member);
+                PostAction::UpdateMembers(state.members.clone())
+            }
+            ServerMessage::MemberLeft { user_id, reason } => {
+                // Check if this is our own MemberLeft due to timeout - ignore it during reconnection
+                // so we don't see our own avatar fade out
+                let is_self = own_user_id.is_some_and(|id| user_id == id);
+                if is_self && reason == DisconnectReason::Timeout {
+                    #[cfg(debug_assertions)]
+                    web_sys::console::log_1(
+                        &"[WS] Ignoring self MemberLeft during reconnection".into(),
+                    );
+                    return;
+                }
 
-            // Find the member before removing
-            let leaving_member = members_vec
-                .iter()
-                .find(|m| {
-                    m.member.user_id == user_id && m.member.guest_session_id == guest_session_id
-                })
-                .cloned();
+                // Find the member before removing
+                let leaving_member = state.members
+                    .iter()
+                    .find(|m| m.member.user_id == user_id)
+                    .cloned();
 
-            // Always remove from active members list
-            members_vec.retain(|m| {
-                m.member.user_id != user_id || m.member.guest_session_id != guest_session_id
-            });
-            on_update.run(members_vec.clone());
+                // Always remove from active members list
+                state.members.retain(|m| m.member.user_id != user_id);
+                let updated = state.members.clone();
 
-            // For timeout disconnects, trigger fading animation
-            if reason == DisconnectReason::Timeout {
-                if let Some(member) = leaving_member {
-                    let fading = FadingMember {
-                        member,
-                        fade_start: js_sys::Date::now() as i64,
-                        fade_duration: FADE_DURATION_MS,
-                    };
-                    on_member_fading.run(fading);
+                // For timeout disconnects, trigger fading animation
+                if reason == DisconnectReason::Timeout {
+                    if let Some(member) = leaving_member {
+                        let fading = FadingMember {
+                            member,
+                            fade_start: js_sys::Date::now() as i64,
+                            fade_duration: FADE_DURATION_MS,
+                        };
+                        PostAction::UpdateMembersAndFade(updated, fading)
+                    } else {
+                        PostAction::UpdateMembers(updated)
+                    }
+                } else {
+                    PostAction::UpdateMembers(updated)
                 }
             }
-        }
-        ServerMessage::PositionUpdated {
-            user_id,
-            guest_session_id,
-            x,
-            y,
-        } => {
-            if let Some(m) = members_vec.iter_mut().find(|m| {
-                m.member.user_id == user_id && m.member.guest_session_id == guest_session_id
-            }) {
-                m.member.position_x = x;
-                m.member.position_y = y;
+            ServerMessage::PositionUpdated { user_id, x, y } => {
+                if let Some(m) = state.members
+                    .iter_mut()
+                    .find(|m| m.member.user_id == user_id)
+                {
+                    m.member.position_x = x;
+                    m.member.position_y = y;
+                }
+                PostAction::UpdateMembers(state.members.clone())
             }
-            on_update.run(members_vec.clone());
-        }
-        ServerMessage::EmotionUpdated {
-            user_id,
-            guest_session_id,
-            emotion,
-            emotion_layer,
-        } => {
-            if let Some(m) = members_vec.iter_mut().find(|m| {
-                m.member.user_id == user_id && m.member.guest_session_id == guest_session_id
-            }) {
-                // Convert emotion name to index for internal state
-                m.member.current_emotion = emotion
-                    .parse::<EmotionState>()
-                    .map(|e| e.to_index() as i16)
-                    .unwrap_or(0);
-                m.avatar.emotion_layer = emotion_layer;
+            ServerMessage::EmotionUpdated {
+                user_id,
+                emotion,
+                emotion_layer,
+            } => {
+                if let Some(m) = state.members
+                    .iter_mut()
+                    .find(|m| m.member.user_id == user_id)
+                {
+                    // Parse emotion name to EmotionState
+                    m.member.current_emotion = emotion
+                        .parse::<EmotionState>()
+                        .unwrap_or_default();
+                    m.avatar.emotion_layer = emotion_layer;
+                }
+                PostAction::UpdateMembers(state.members.clone())
             }
-            on_update.run(members_vec.clone());
-        }
-        ServerMessage::Pong => {
-            // Heartbeat acknowledged - nothing to do
-        }
-        ServerMessage::Error { code, message } => {
-            // Always log errors to console (not just debug mode)
-            web_sys::console::error_1(&format!("[WS] Server error: {} - {}", code, message).into());
-            // Call error callback if provided
-            if let Some(callback) = on_error {
-                callback.run(WsError { code, message });
+            ServerMessage::Pong => {
+                // Heartbeat acknowledged - nothing to do
+                PostAction::None
             }
-        }
-        ServerMessage::ChatMessageReceived {
-            message_id,
-            user_id,
-            guest_session_id,
-            display_name,
-            content,
-            emotion,
-            x,
-            y,
-            timestamp,
-            is_whisper,
-            is_same_scene,
-        } => {
-            let chat_msg = ChatMessage {
+            ServerMessage::Error { code, message } => {
+                // Always log errors to console (not just debug mode)
+                web_sys::console::error_1(&format!("[WS] Server error: {} - {}", code, message).into());
+                PostAction::Error(WsError { code, message })
+            }
+            ServerMessage::ChatMessageReceived {
                 message_id,
                 user_id,
-                guest_session_id,
                 display_name,
                 content,
                 emotion,
@@ -578,90 +626,161 @@ fn handle_server_message(
                 timestamp,
                 is_whisper,
                 is_same_scene,
-                is_system: false,
-            };
-            on_chat_message.run(chat_msg);
-        }
-        ServerMessage::LoosePropsSync { props } => {
-            on_loose_props_sync.run(props);
-        }
-        ServerMessage::PropDropped { prop } => {
-            on_prop_dropped.run(prop);
-        }
-        ServerMessage::PropPickedUp { prop_id, .. } => {
-            on_prop_picked_up.run(prop_id);
-        }
-        ServerMessage::PropExpired { prop_id } => {
-            // Treat expired props the same as picked up (remove from display)
-            on_prop_picked_up.run(prop_id);
-        }
-        ServerMessage::AvatarUpdated {
-            user_id,
-            guest_session_id,
-            avatar,
-        } => {
-            // Find member and update their avatar layers
-            if let Some(m) = members_vec.iter_mut().find(|m| {
-                m.member.user_id == user_id && m.member.guest_session_id == guest_session_id
-            }) {
-                m.avatar.skin_layer = avatar.skin_layer.clone();
-                m.avatar.clothes_layer = avatar.clothes_layer.clone();
-                m.avatar.accessories_layer = avatar.accessories_layer.clone();
-                m.avatar.emotion_layer = avatar.emotion_layer.clone();
+            } => {
+                PostAction::ChatMessage(ChatMessage {
+                    message_id,
+                    user_id,
+                    display_name,
+                    content,
+                    emotion,
+                    x,
+                    y,
+                    timestamp,
+                    is_whisper,
+                    is_same_scene,
+                    is_system: false,
+                })
             }
-            on_update.run(members_vec.clone());
-        }
-        ServerMessage::TeleportApproved {
-            scene_id,
-            scene_slug,
-        } => {
-            if let Some(callback) = on_teleport_approved {
-                callback.run(TeleportInfo {
+            ServerMessage::LoosePropsSync { props } => {
+                PostAction::LoosePropsSync(props)
+            }
+            ServerMessage::PropDropped { prop } => {
+                PostAction::PropDropped(prop)
+            }
+            ServerMessage::PropPickedUp { prop_id, .. } => {
+                PostAction::PropPickedUp(prop_id)
+            }
+            ServerMessage::PropExpired { prop_id } => {
+                // Treat expired props the same as picked up (remove from display)
+                PostAction::PropPickedUp(prop_id)
+            }
+            ServerMessage::AvatarUpdated { user_id, avatar } => {
+                // Find member and update their avatar layers
+                if let Some(m) = state.members
+                    .iter_mut()
+                    .find(|m| m.member.user_id == user_id)
+                {
+                    m.avatar.skin_layer = avatar.skin_layer.clone();
+                    m.avatar.clothes_layer = avatar.clothes_layer.clone();
+                    m.avatar.accessories_layer = avatar.accessories_layer.clone();
+                    m.avatar.emotion_layer = avatar.emotion_layer.clone();
+                }
+                PostAction::UpdateMembers(state.members.clone())
+            }
+            ServerMessage::TeleportApproved {
+                scene_id,
+                scene_slug,
+            } => {
+                PostAction::TeleportApproved(TeleportInfo {
                     scene_id,
                     scene_slug,
-                });
+                })
             }
-        }
-        ServerMessage::Summoned {
-            scene_id,
-            scene_slug,
-            summoned_by,
-        } => {
-            if let Some(callback) = on_summoned {
-                callback.run(SummonInfo {
+            ServerMessage::Summoned {
+                scene_id,
+                scene_slug,
+                summoned_by,
+            } => {
+                PostAction::Summoned(SummonInfo {
                     scene_id,
                     scene_slug,
                     summoned_by,
-                });
+                })
+            }
+            ServerMessage::ModCommandResult { success, message } => {
+                PostAction::ModCommandResult(ModCommandResultInfo { success, message })
+            }
+            ServerMessage::MemberIdentityUpdated {
+                user_id,
+                display_name,
+                is_guest,
+            } => {
+                // Update the internal members list so subsequent updates don't overwrite
+                if let Some(member) = state.members
+                    .iter_mut()
+                    .find(|m| m.member.user_id == user_id)
+                {
+                    member.member.display_name = display_name.clone();
+                    member.member.is_guest = is_guest;
+                }
+                PostAction::UpdateMembersAndIdentity(
+                    state.members.clone(),
+                    MemberIdentityInfo {
+                        user_id,
+                        display_name,
+                        is_guest,
+                    },
+                )
+            }
+            ServerMessage::AvatarForced {
+                user_id,
+                avatar,
+                reason: _,
+                forced_by: _,
+            } => {
+                // Update the forced user's avatar
+                if let Some(m) = state.members.iter_mut().find(|m| m.member.user_id == user_id) {
+                    m.avatar.skin_layer = avatar.skin_layer.clone();
+                    m.avatar.clothes_layer = avatar.clothes_layer.clone();
+                    m.avatar.accessories_layer = avatar.accessories_layer.clone();
+                    m.avatar.emotion_layer = avatar.emotion_layer.clone();
+                }
+                PostAction::UpdateMembers(state.members.clone())
+            }
+            ServerMessage::AvatarCleared {
+                user_id,
+                avatar,
+                cleared_by: _,
+            } => {
+                // Restore the user's original avatar
+                if let Some(m) = state.members.iter_mut().find(|m| m.member.user_id == user_id) {
+                    m.avatar.skin_layer = avatar.skin_layer.clone();
+                    m.avatar.clothes_layer = avatar.clothes_layer.clone();
+                    m.avatar.accessories_layer = avatar.accessories_layer.clone();
+                    m.avatar.emotion_layer = avatar.emotion_layer.clone();
+                }
+                PostAction::UpdateMembers(state.members.clone())
             }
         }
-        ServerMessage::ModCommandResult { success, message } => {
-            if let Some(callback) = on_mod_command_result {
-                callback.run(ModCommandResultInfo { success, message });
-            }
-        }
-        ServerMessage::MemberIdentityUpdated {
-            user_id,
-            display_name,
-            is_guest,
-        } => {
-            // Update the internal members list so subsequent updates don't overwrite
-            if let Some(member) = members_vec
-                .iter_mut()
-                .find(|m| m.member.user_id == Some(user_id))
-            {
-                member.member.display_name = display_name.clone();
-                member.member.is_guest = is_guest;
-            }
-            on_update.run(members_vec.clone());
+    }; // state borrow is dropped here
 
-            if let Some(callback) = on_member_identity_updated {
-                callback.run(MemberIdentityInfo {
-                    user_id,
-                    display_name,
-                    is_guest,
-                });
-            }
+    // Now emit events without holding any borrows
+    match action {
+        PostAction::None => {}
+        PostAction::UpdateMembers(members) => {
+            on_event.run(WsEvent::MembersUpdated(members));
+        }
+        PostAction::UpdateMembersAndFade(members, fading) => {
+            on_event.run(WsEvent::MembersUpdated(members));
+            on_event.run(WsEvent::MemberFading(fading));
+        }
+        PostAction::UpdateMembersAndIdentity(members, info) => {
+            on_event.run(WsEvent::MembersUpdated(members));
+            on_event.run(WsEvent::MemberIdentityUpdated(info));
+        }
+        PostAction::ChatMessage(msg) => {
+            on_event.run(WsEvent::ChatMessage(msg));
+        }
+        PostAction::LoosePropsSync(props) => {
+            on_event.run(WsEvent::LoosePropsSync(props));
+        }
+        PostAction::PropDropped(prop) => {
+            on_event.run(WsEvent::PropDropped(prop));
+        }
+        PostAction::PropPickedUp(prop_id) => {
+            on_event.run(WsEvent::PropPickedUp(prop_id));
+        }
+        PostAction::Error(err) => {
+            on_event.run(WsEvent::Error(err));
+        }
+        PostAction::TeleportApproved(info) => {
+            on_event.run(WsEvent::TeleportApproved(info));
+        }
+        PostAction::Summoned(info) => {
+            on_event.run(WsEvent::Summoned(info));
+        }
+        PostAction::ModCommandResult(info) => {
+            on_event.run(WsEvent::ModCommandResult(info));
         }
     }
 }
@@ -672,20 +791,10 @@ pub fn use_channel_websocket(
     _realm_slug: Signal<String>,
     _channel_id: Signal<Option<uuid::Uuid>>,
     _reconnect_trigger: RwSignal<u32>,
-    _on_members_update: Callback<Vec<ChannelMemberWithAvatar>>,
-    _on_chat_message: Callback<ChatMessage>,
-    _on_loose_props_sync: Callback<Vec<LooseProp>>,
-    _on_prop_dropped: Callback<LooseProp>,
-    _on_prop_picked_up: Callback<uuid::Uuid>,
-    _on_member_fading: Callback<FadingMember>,
-    _on_welcome: Option<Callback<ChannelMemberInfo>>,
-    _on_error: Option<Callback<WsError>>,
-    _on_teleport_approved: Option<Callback<TeleportInfo>>,
-    _on_summoned: Option<Callback<SummonInfo>>,
-    _on_mod_command_result: Option<Callback<ModCommandResultInfo>>,
-    _on_member_identity_updated: Option<Callback<MemberIdentityInfo>>,
-) -> (Signal<WsState>, WsSenderStorage) {
+    _on_event: Callback<WsEvent>,
+) -> (Signal<WsState>, WsSenderStorage, WsCloserStorage) {
     let (ws_state, _) = signal(WsState::Disconnected);
     let sender: WsSenderStorage = StoredValue::new_local(None);
-    (Signal::derive(move || ws_state.get()), sender)
+    let closer: WsCloserStorage = StoredValue::new_local(None);
+    (Signal::derive(move || ws_state.get()), sender, closer)
 }

crates/chattyness-user-ui/src/pages/realm.rs

@@ -12,15 +12,14 @@ use leptos_router::hooks::use_params_map;
 use uuid::Uuid;
 
 use crate::components::{
-    ActiveBubble, AvatarEditorPopup, Card, ChatInput, ConversationModal, EmotionKeybindings,
-    FadingMember, HotkeyHelp, InventoryPopup, KeybindingsPopup, LogPopup, MessageLog,
-    NotificationMessage, NotificationToast, RealmHeader, RealmSceneViewer, ReconnectionOverlay,
-    RegisterModal, SettingsPopup, ViewerSettings,
+    ActiveBubble, AvatarEditorPopup, AvatarStorePopup, Card, ChatInput, ConversationModal,
+    EmotionKeybindings, FadingMember, HotkeyHelp, InventoryPopup, KeybindingsPopup, LogPopup,
+    MessageLog, NotificationMessage, NotificationToast, RealmHeader, RealmSceneViewer,
+    ReconnectionOverlay, RegisterModal, SettingsPopup, ViewerSettings,
 };
 #[cfg(feature = "hydrate")]
 use crate::components::{
-    ChannelMemberInfo, ChatMessage, DEFAULT_BUBBLE_TIMEOUT_MS, FADE_DURATION_MS,
-    MemberIdentityInfo, ModCommandResultInfo, SummonInfo, TeleportInfo, WsError,
+    ChatMessage, DEFAULT_BUBBLE_TIMEOUT_MS, FADE_DURATION_MS, WsEvent,
     add_whisper_to_history, use_channel_websocket,
 };
 use crate::utils::LocalStoragePersist;
@@ -31,7 +30,7 @@ use chattyness_db::models::{
     RealmWithUserRole, Scene, SceneSummary,
 };
 #[cfg(feature = "hydrate")]
-use chattyness_db::ws_messages::ClientMessage;
+use chattyness_db::ws_messages::{close_codes, ClientMessage};
 
 #[cfg(not(feature = "hydrate"))]
 use crate::components::ws_client::WsSender;
@@ -65,8 +64,8 @@ pub fn RealmPage() -> impl IntoView {
     // Chat message state - use StoredValue for WASM compatibility (single-threaded)
     let message_log: StoredValue<MessageLog, LocalStorage> =
         StoredValue::new_local(MessageLog::new());
-    let (active_bubbles, set_active_bubbles) =
-        signal(HashMap::<(Option<Uuid>, Option<Uuid>), ActiveBubble>::new());
+    // Bubble key is now just user_id since guests are regular users with the 'guest' tag
+    let (active_bubbles, set_active_bubbles) = signal(HashMap::<Uuid, ActiveBubble>::new());
 
     // Inventory popup state
     let (inventory_open, set_inventory_open) = signal(false);
@@ -90,6 +89,9 @@ pub fn RealmPage() -> impl IntoView {
     // Store full avatar data for the editor
     let (full_avatar, set_full_avatar) = signal(Option::<AvatarWithPaths>::None);
 
+    // Avatar store popup state
+    let (avatar_store_open, set_avatar_store_open) = signal(false);
+
     // Register modal state (for guest-to-user conversion)
     let (register_modal_open, set_register_modal_open) = signal(false);
 
@@ -109,8 +111,8 @@ pub fn RealmPage() -> impl IntoView {
     let (current_position, set_current_position) = signal((400.0_f64, 300.0_f64));
 
     // Current user identity (received from WebSocket Welcome message)
+    // Note: Guests are now regular users with the 'guest' tag, so everyone has a user_id
     let (current_user_id, set_current_user_id) = signal(Option::<Uuid>::None);
-    let (current_guest_session_id, set_current_guest_session_id) = signal(Option::<Uuid>::None);
     // Whether the current user is a guest (has the 'guest' tag)
     let (is_guest, set_is_guest) = signal(false);
 
@@ -235,365 +237,254 @@ pub fn RealmPage() -> impl IntoView {
         });
     }
 
-    // WebSocket connection for real-time updates
+    // Helper to navigate to a new scene (used by teleport and summon)
     #[cfg(feature = "hydrate")]
-    let on_members_update = Callback::new(move |new_members: Vec<ChannelMemberWithAvatar>| {
-        // When members are updated (including rejoins), remove any matching fading members
-        set_fading_members.update(|fading| {
-            fading.retain(|f| {
-                !new_members.iter().any(|m| {
-                    m.member.user_id == f.member.member.user_id
-                        && m.member.guest_session_id == f.member.member.guest_session_id
-                })
-            });
-        });
-        set_members.set(new_members);
-    });
+    let navigate_to_scene = {
+        let slug = slug.clone();
+        move |scene_id: Uuid, scene_slug: String| {
+            let realm_slug = slug.get_untracked();
+            let scene_slug_for_url = scene_slug.clone();
+            let realm_slug_for_url = realm_slug.clone();
 
-    // Chat message callback
-    #[cfg(feature = "hydrate")]
-    let on_chat_message = Callback::new(move |msg: ChatMessage| {
-        // Add to message log
-        message_log.update_value(|log| log.push(msg.clone()));
+            spawn_local(async move {
+                use gloo_net::http::Request;
+                let response = Request::get(&format!(
+                    "/api/realms/{}/scenes/{}",
+                    realm_slug, scene_slug
+                ))
+                .send()
+                .await;
 
-        // Handle whispers
-        if msg.is_whisper {
-            // Track whisper for conversation view
-            whisper_messages.update_value(|msgs| {
-                msgs.push(msg.clone());
-                // Keep last 100 whisper messages
-                if msgs.len() > 100 {
-                    msgs.remove(0);
+                if let Ok(resp) = response {
+                    if resp.ok() {
+                        if let Ok(scene) = resp.json::<Scene>().await {
+                            if let Some((w, h)) = parse_bounds_dimensions(&scene.bounds_wkt) {
+                                set_scene_dimensions.set((w as f64, h as f64));
+                            }
+
+                            if let Some(window) = web_sys::window() {
+                                if let Ok(history) = window.history() {
+                                    let new_url = if scene.is_entry_point {
+                                        format!("/realms/{}", realm_slug_for_url)
+                                    } else {
+                                        format!("/realms/{}/scenes/{}", realm_slug_for_url, scene_slug_for_url)
+                                    };
+                                    let _ = history.replace_state_with_url(
+                                        &wasm_bindgen::JsValue::NULL,
+                                        "",
+                                        Some(&new_url),
+                                    );
+                                }
+                            }
+
+                            set_current_scene.set(Some(scene));
+                        }
+                    }
                 }
+
+                set_channel_id.set(Some(scene_id));
+                set_members.set(Vec::new());
+                reconnect_trigger.update(|t| *t += 1);
             });
+        }
+    };
 
-            // Add to persistent whisper history in LocalStorage
-            add_whisper_to_history(msg.clone());
-
-            if msg.is_same_scene {
-                // Same scene whisper: show as italic bubble (handled by bubble rendering)
-                let key = (msg.user_id, msg.guest_session_id);
-                let expires_at = msg.timestamp + DEFAULT_BUBBLE_TIMEOUT_MS;
-                set_active_bubbles.update(|bubbles| {
-                    bubbles.insert(
-                        key,
-                        ActiveBubble {
-                            message: msg,
-                            expires_at,
-                        },
-                    );
+    // Consolidated WebSocket event handler
+    #[cfg(feature = "hydrate")]
+    let navigate_to_scene_for_event = navigate_to_scene.clone();
+    #[cfg(feature = "hydrate")]
+    let on_ws_event = Callback::new(move |event: WsEvent| {
+        match event {
+            WsEvent::MembersUpdated(new_members) => {
+                // When members are updated (including rejoins), remove any matching fading members
+                set_fading_members.update(|fading| {
+                    fading.retain(|f| {
+                        !new_members.iter().any(|m| {
+                            m.member.user_id == f.member.member.user_id
+                        })
+                    });
+                });
+                set_members.set(new_members);
+            }
+            WsEvent::ChatMessage(msg) => {
+                // Add to message log
+                message_log.update_value(|log| log.push(msg.clone()));
+
+                // Handle whispers
+                if msg.is_whisper {
+                    // Track whisper for conversation view
+                    whisper_messages.update_value(|msgs| {
+                        msgs.push(msg.clone());
+                        // Keep last 100 whisper messages
+                        if msgs.len() > 100 {
+                            msgs.remove(0);
+                        }
+                    });
+
+                    // Add to persistent whisper history in LocalStorage
+                    add_whisper_to_history(msg.clone());
+
+                    if msg.is_same_scene {
+                        // Same scene whisper: show as italic bubble (handled by bubble rendering)
+                        let key = msg.user_id;
+                        let expires_at = msg.timestamp + DEFAULT_BUBBLE_TIMEOUT_MS;
+                        set_active_bubbles.update(|bubbles| {
+                            bubbles.insert(
+                                key,
+                                ActiveBubble {
+                                    message: msg,
+                                    expires_at,
+                                },
+                            );
+                        });
+                    } else {
+                        // Cross-scene whisper: show as notification toast
+                        set_current_notification.set(Some(NotificationMessage::from_chat_message(msg)));
+                    }
+                } else {
+                    // Regular broadcast: show as bubble
+                    let key = msg.user_id;
+                    let expires_at = msg.timestamp + DEFAULT_BUBBLE_TIMEOUT_MS;
+                    set_active_bubbles.update(|bubbles| {
+                        bubbles.insert(
+                            key,
+                            ActiveBubble {
+                                message: msg,
+                                expires_at,
+                            },
+                        );
+                    });
+                }
+            }
+            WsEvent::LoosePropsSync(props) => {
+                set_loose_props.set(props);
+            }
+            WsEvent::PropDropped(prop) => {
+                set_loose_props.update(|props| {
+                    props.push(prop);
+                });
+            }
+            WsEvent::PropPickedUp(prop_id) => {
+                set_loose_props.update(|props| {
+                    props.retain(|p| p.id != prop_id);
+                });
+            }
+            WsEvent::MemberFading(fading) => {
+                set_fading_members.update(|members| {
+                    // Remove any existing entry for this user (shouldn't happen, but be safe)
+                    members.retain(|m| {
+                        m.member.member.user_id != fading.member.member.user_id
+                    });
+                    members.push(fading);
+                });
+            }
+            WsEvent::Welcome(info) => {
+                set_current_user_id.set(Some(info.user_id));
+                set_current_display_name.set(info.display_name.clone());
+                set_is_guest.set(info.is_guest);
+            }
+            WsEvent::Error(error) => {
+                // Display user-friendly error message
+                let msg = match error.code.as_str() {
+                    "WHISPER_TARGET_NOT_FOUND" => error.message,
+                    "TELEPORT_DISABLED" => error.message,
+                    "SCENE_NOT_FOUND" => error.message,
+                    _ => format!("Error: {}", error.message),
+                };
+                set_error_message.set(Some(msg));
+                // Auto-dismiss after 5 seconds
+                gloo_timers::callback::Timeout::new(5000, move || {
+                    set_error_message.set(None);
+                })
+                .forget();
+            }
+            WsEvent::TeleportApproved(info) => {
+                let teleport_msg = ChatMessage {
+                    message_id: Uuid::new_v4(),
+                    user_id: Uuid::nil(),
+                    display_name: "[SYSTEM]".to_string(),
+                    content: format!("Teleported to scene: {}", info.scene_slug),
+                    emotion: "neutral".to_string(),
+                    x: 0.0,
+                    y: 0.0,
+                    timestamp: js_sys::Date::now() as i64,
+                    is_whisper: false,
+                    is_same_scene: true,
+                    is_system: true,
+                };
+                message_log.update_value(|log| log.push(teleport_msg));
+                navigate_to_scene_for_event(info.scene_id, info.scene_slug);
+            }
+            WsEvent::Summoned(info) => {
+                let summon_msg = ChatMessage {
+                    message_id: Uuid::new_v4(),
+                    user_id: Uuid::nil(),
+                    display_name: "[MOD]".to_string(),
+                    content: format!("Summoned by {} to scene: {}", info.summoned_by, info.scene_slug),
+                    emotion: "neutral".to_string(),
+                    x: 0.0,
+                    y: 0.0,
+                    timestamp: js_sys::Date::now() as i64,
+                    is_whisper: false,
+                    is_same_scene: true,
+                    is_system: true,
+                };
+                message_log.update_value(|log| log.push(summon_msg));
+
+                set_mod_notification.set(Some((true, format!("Summoned by {}", info.summoned_by))));
+                gloo_timers::callback::Timeout::new(3000, move || {
+                    set_mod_notification.set(None);
+                })
+                .forget();
+
+                navigate_to_scene_for_event(info.scene_id, info.scene_slug);
+            }
+            WsEvent::ModCommandResult(info) => {
+                // Log mod command result to message log
+                let status = if info.success { "OK" } else { "FAILED" };
+                let mod_msg = ChatMessage {
+                    message_id: Uuid::new_v4(),
+                    user_id: Uuid::nil(),  // System/mod message
+                    display_name: "[MOD]".to_string(),
+                    content: format!("[{}] {}", status, info.message),
+                    emotion: "neutral".to_string(),
+                    x: 0.0,
+                    y: 0.0,
+                    timestamp: js_sys::Date::now() as i64,
+                    is_whisper: false,
+                    is_same_scene: true,
+                    is_system: true,
+                };
+                message_log.update_value(|log| log.push(mod_msg));
+
+                set_mod_notification.set(Some((info.success, info.message)));
+
+                // Auto-dismiss notification after 3 seconds
+                gloo_timers::callback::Timeout::new(3000, move || {
+                    set_mod_notification.set(None);
+                })
+                .forget();
+            }
+            WsEvent::MemberIdentityUpdated(info) => {
+                // Update the member's display name in the members list
+                set_members.update(|members| {
+                    if let Some(member) = members
+                        .iter_mut()
+                        .find(|m| m.member.user_id == info.user_id)
+                    {
+                        member.member.display_name = info.display_name.clone();
+                    }
                 });
-            } else {
-                // Cross-scene whisper: show as notification toast
-                set_current_notification.set(Some(NotificationMessage::from_chat_message(msg)));
             }
-        } else {
-            // Regular broadcast: show as bubble
-            let key = (msg.user_id, msg.guest_session_id);
-            let expires_at = msg.timestamp + DEFAULT_BUBBLE_TIMEOUT_MS;
-            set_active_bubbles.update(|bubbles| {
-                bubbles.insert(
-                    key,
-                    ActiveBubble {
-                        message: msg,
-                        expires_at,
-                    },
-                );
-            });
         }
     });
 
-    // Loose props callbacks
     #[cfg(feature = "hydrate")]
-    let on_loose_props_sync = Callback::new(move |props: Vec<LooseProp>| {
-        set_loose_props.set(props);
-    });
-
-    #[cfg(feature = "hydrate")]
-    let on_prop_dropped = Callback::new(move |prop: LooseProp| {
-        set_loose_props.update(|props| {
-            props.push(prop);
-        });
-    });
-
-    #[cfg(feature = "hydrate")]
-    let on_prop_picked_up = Callback::new(move |prop_id: Uuid| {
-        set_loose_props.update(|props| {
-            props.retain(|p| p.id != prop_id);
-        });
-    });
-
-    // Callback when a member starts fading (timeout disconnect)
-    #[cfg(feature = "hydrate")]
-    let on_member_fading = Callback::new(move |fading: FadingMember| {
-        set_fading_members.update(|members| {
-            // Remove any existing entry for this user (shouldn't happen, but be safe)
-            members.retain(|m| {
-                m.member.member.user_id != fading.member.member.user_id
-                    || m.member.member.guest_session_id != fading.member.member.guest_session_id
-            });
-            members.push(fading);
-        });
-    });
-
-    // Callback to capture current user identity from Welcome message
-    #[cfg(feature = "hydrate")]
-    let on_welcome = Callback::new(move |info: ChannelMemberInfo| {
-        set_current_user_id.set(info.user_id);
-        set_current_guest_session_id.set(info.guest_session_id);
-        set_current_display_name.set(info.display_name.clone());
-        set_is_guest.set(info.is_guest);
-    });
-
-    // Callback for WebSocket errors (whisper failures, etc.)
-    #[cfg(feature = "hydrate")]
-    let on_ws_error = Callback::new(move |error: WsError| {
-        // Display user-friendly error message
-        let msg = match error.code.as_str() {
-            "WHISPER_TARGET_NOT_FOUND" => error.message,
-            "TELEPORT_DISABLED" => error.message,
-            "SCENE_NOT_FOUND" => error.message,
-            _ => format!("Error: {}", error.message),
-        };
-        set_error_message.set(Some(msg));
-        // Auto-dismiss after 5 seconds
-        use gloo_timers::callback::Timeout;
-        Timeout::new(5000, move || {
-            set_error_message.set(None);
-        })
-        .forget();
-    });
-
-    // Callback for teleport approval - navigate to new scene
-    #[cfg(feature = "hydrate")]
-    let on_teleport_approved = Callback::new(move |info: TeleportInfo| {
-        // Log teleport to message log
-        let teleport_msg = ChatMessage {
-            message_id: Uuid::new_v4(),
-            user_id: None,
-            guest_session_id: None,
-            display_name: "[SYSTEM]".to_string(),
-            content: format!("Teleported to scene: {}", info.scene_slug),
-            emotion: "neutral".to_string(),
-            x: 0.0,
-            y: 0.0,
-            timestamp: js_sys::Date::now() as i64,
-            is_whisper: false,
-            is_same_scene: true,
-            is_system: true,
-        };
-        message_log.update_value(|log| log.push(teleport_msg));
-
-        let scene_id = info.scene_id;
-        let scene_slug = info.scene_slug.clone();
-        let realm_slug = slug.get_untracked();
-
-        // Fetch the new scene data to update the canvas background
-        let scene_slug_for_url = scene_slug.clone();
-        let realm_slug_for_url = realm_slug.clone();
-        spawn_local(async move {
-            use gloo_net::http::Request;
-            let response = Request::get(&format!(
-                "/api/realms/{}/scenes/{}",
-                realm_slug, scene_slug
-            ))
-            .send()
-            .await;
-
-            if let Ok(resp) = response {
-                if resp.ok() {
-                    if let Ok(scene) = resp.json::<Scene>().await {
-                        // Update scene dimensions from the new scene
-                        if let Some((w, h)) = parse_bounds_dimensions(&scene.bounds_wkt) {
-                            set_scene_dimensions.set((w as f64, h as f64));
-                        }
-
-                        // Update URL to reflect new scene
-                        if let Some(window) = web_sys::window() {
-                            if let Ok(history) = window.history() {
-                                let new_url = if scene.is_entry_point {
-                                    format!("/realms/{}", realm_slug_for_url)
-                                } else {
-                                    format!(
-                                        "/realms/{}/scenes/{}",
-                                        realm_slug_for_url, scene_slug_for_url
-                                    )
-                                };
-                                let _ = history.replace_state_with_url(
-                                    &wasm_bindgen::JsValue::NULL,
-                                    "",
-                                    Some(&new_url),
-                                );
-                            }
-                        }
-
-                        // Update the current scene for the viewer
-                        set_current_scene.set(Some(scene));
-                    }
-                }
-            }
-
-            // Update channel_id to trigger WebSocket reconnection
-            set_channel_id.set(Some(scene_id));
-
-            // Clear members since we're switching scenes
-            set_members.set(Vec::new());
-
-            // Trigger a reconnect to ensure fresh connection
-            reconnect_trigger.update(|t| *t += 1);
-        });
-    });
-
-    // Callback for being summoned by a moderator - show notification and teleport
-    #[cfg(feature = "hydrate")]
-    let on_summoned = Callback::new(move |info: SummonInfo| {
-        // Log summon to message log
-        let summon_msg = ChatMessage {
-            message_id: Uuid::new_v4(),
-            user_id: None,
-            guest_session_id: None,
-            display_name: "[MOD]".to_string(),
-            content: format!("Summoned by {} to scene: {}", info.summoned_by, info.scene_slug),
-            emotion: "neutral".to_string(),
-            x: 0.0,
-            y: 0.0,
-            timestamp: js_sys::Date::now() as i64,
-            is_whisper: false,
-            is_same_scene: true,
-            is_system: true,
-        };
-        message_log.update_value(|log| log.push(summon_msg));
-
-        // Show notification
-        set_mod_notification.set(Some((true, format!("Summoned by {}", info.summoned_by))));
-
-        // Auto-dismiss notification after 3 seconds
-        let timeout = gloo_timers::callback::Timeout::new(3000, move || {
-            set_mod_notification.set(None);
-        });
-        timeout.forget();
-
-        let scene_id = info.scene_id;
-        let scene_slug = info.scene_slug.clone();
-        let realm_slug = slug.get_untracked();
-
-        // Fetch the new scene data (same as teleport approval)
-        let scene_slug_for_url = scene_slug.clone();
-        let realm_slug_for_url = realm_slug.clone();
-        spawn_local(async move {
-            use gloo_net::http::Request;
-            let response = Request::get(&format!(
-                "/api/realms/{}/scenes/{}",
-                realm_slug, scene_slug
-            ))
-            .send()
-            .await;
-
-            if let Ok(resp) = response {
-                if resp.ok() {
-                    if let Ok(scene) = resp.json::<Scene>().await {
-                        // Update scene dimensions from the new scene
-                        if let Some((w, h)) = parse_bounds_dimensions(&scene.bounds_wkt) {
-                            set_scene_dimensions.set((w as f64, h as f64));
-                        }
-
-                        // Update URL to reflect new scene
-                        if let Some(window) = web_sys::window() {
-                            if let Ok(history) = window.history() {
-                                let new_url = if scene.is_entry_point {
-                                    format!("/realms/{}", realm_slug_for_url)
-                                } else {
-                                    format!(
-                                        "/realms/{}/scenes/{}",
-                                        realm_slug_for_url, scene_slug_for_url
-                                    )
-                                };
-                                let _ = history.replace_state_with_url(
-                                    &wasm_bindgen::JsValue::NULL,
-                                    "",
-                                    Some(&new_url),
-                                );
-                            }
-                        }
-
-                        // Update the current scene for the viewer
-                        set_current_scene.set(Some(scene));
-                    }
-                }
-            }
-
-            // Update channel_id to trigger WebSocket reconnection
-            set_channel_id.set(Some(scene_id));
-
-            // Clear members since we're switching scenes
-            set_members.set(Vec::new());
-
-            // Trigger a reconnect to ensure fresh connection
-            reconnect_trigger.update(|t| *t += 1);
-        });
-    });
-
-    // Callback for mod command result - show notification
-    #[cfg(feature = "hydrate")]
-    let on_mod_command_result = Callback::new(move |info: ModCommandResultInfo| {
-        // Log mod command result to message log
-        let status = if info.success { "OK" } else { "FAILED" };
-        let mod_msg = ChatMessage {
-            message_id: Uuid::new_v4(),
-            user_id: None,
-            guest_session_id: None,
-            display_name: "[MOD]".to_string(),
-            content: format!("[{}] {}", status, info.message),
-            emotion: "neutral".to_string(),
-            x: 0.0,
-            y: 0.0,
-            timestamp: js_sys::Date::now() as i64,
-            is_whisper: false,
-            is_same_scene: true,
-            is_system: true,
-        };
-        message_log.update_value(|log| log.push(mod_msg));
-
-        set_mod_notification.set(Some((info.success, info.message)));
-
-        // Auto-dismiss notification after 3 seconds
-        let timeout = gloo_timers::callback::Timeout::new(3000, move || {
-            set_mod_notification.set(None);
-        });
-        timeout.forget();
-    });
-
-    // Callback for member identity updates (e.g., guest registered as user)
-    #[cfg(feature = "hydrate")]
-    let on_member_identity_updated = Callback::new(move |info: MemberIdentityInfo| {
-        // Update the member's display name in the members list
-        set_members.update(|members| {
-            if let Some(member) = members
-                .iter_mut()
-                .find(|m| m.member.user_id == Some(info.user_id))
-            {
-                member.member.display_name = info.display_name.clone();
-            }
-        });
-    });
-
-    #[cfg(feature = "hydrate")]
-    let (ws_state, ws_sender) = use_channel_websocket(
+    let (ws_state, ws_sender, ws_close) = use_channel_websocket(
         slug,
         Signal::derive(move || channel_id.get()),
         reconnect_trigger,
-        on_members_update,
-        on_chat_message,
-        on_loose_props_sync,
-        on_prop_dropped,
-        on_prop_picked_up,
-        on_member_fading,
-        Some(on_welcome),
-        Some(on_ws_error),
-        Some(on_teleport_approved),
-        Some(on_summoned),
-        Some(on_mod_command_result),
-        Some(on_member_identity_updated),
+        on_ws_event,
     );
 
     // Set channel ID, current scene, and scene dimensions when entry scene loads
@@ -823,8 +714,17 @@ pub fn RealmPage() -> impl IntoView {
             Rc::new(RefCell::new(None));
         let closure_holder_clone = closure_holder.clone();
 
+        // Holder for keyup closure (for hotkey help dismissal)
+        let keyup_closure_holder: Rc<RefCell<Option<Closure<dyn Fn(web_sys::KeyboardEvent)>>>> =
+            Rc::new(RefCell::new(None));
+        let keyup_closure_holder_clone = keyup_closure_holder.clone();
+
+        // StoredValue to hold js_sys::Function references for cleanup (Send+Sync compatible)
+        let keydown_fn: StoredValue<Option<js_sys::Function>, LocalStorage> = StoredValue::new_local(None);
+        let keyup_fn: StoredValue<Option<js_sys::Function>, LocalStorage> = StoredValue::new_local(None);
+
         Effect::new(move |_| {
-            // Cleanup previous closure if any
+            // Cleanup previous keydown closure if any
             if let Some(old_closure) = closure_holder_clone.borrow_mut().take() {
                 if let Some(window) = web_sys::window() {
                     let _ = window.remove_event_listener_with_callback(
@@ -834,6 +734,16 @@ pub fn RealmPage() -> impl IntoView {
                 }
             }
 
+            // Cleanup previous keyup closure if any
+            if let Some(old_closure) = keyup_closure_holder_clone.borrow_mut().take() {
+                if let Some(window) = web_sys::window() {
+                    let _ = window.remove_event_listener_with_callback(
+                        "keyup",
+                        old_closure.as_ref().unchecked_ref(),
+                    );
+                }
+            }
+
             let current_slug = slug.get();
             if current_slug.is_empty() {
                 return;
@@ -870,6 +780,7 @@ pub fn RealmPage() -> impl IntoView {
                     || log_open.get_untracked()
                     || keybindings_open.get_untracked()
                     || avatar_editor_open.get_untracked()
+                    || avatar_store_open.get_untracked()
                     || register_modal_open.get_untracked()
                     || conversation_modal_open.get_untracked()
                 {
@@ -986,6 +897,13 @@ pub fn RealmPage() -> impl IntoView {
                     return;
                 }
 
+                // Handle 't' to toggle avatar store (template avatars)
+                if key == "t" || key == "T" {
+                    set_avatar_store_open.update(|v| *v = !*v);
+                    ev.prevent_default();
+                    return;
+                }
+
                 // Handle 'l' to toggle message log
                 if key == "l" || key == "L" {
                     set_log_open.update(|v| *v = !*v);
@@ -1060,8 +978,35 @@ pub fn RealmPage() -> impl IntoView {
                 );
             }
 
-            // Forget the keyup closure (it lives for the duration of the page)
-            keyup_closure.forget();
+            // Store the keyup closure for cleanup
+            *keyup_closure_holder_clone.borrow_mut() = Some(keyup_closure);
+
+            // Extract and store js_sys::Function references for cleanup
+            // (must be done inside Effect since Rc<RefCell<>> isn't Send+Sync for on_cleanup)
+            if let Some(ref closure) = *closure_holder_clone.borrow() {
+                let func: &js_sys::Function = closure.as_ref().unchecked_ref();
+                keydown_fn.set_value(Some(func.clone()));
+            }
+            if let Some(ref closure) = *keyup_closure_holder_clone.borrow() {
+                let func: &js_sys::Function = closure.as_ref().unchecked_ref();
+                keyup_fn.set_value(Some(func.clone()));
+            }
+        });
+
+        // Cleanup event listeners when component unmounts
+        on_cleanup(move || {
+            if let Some(window) = web_sys::window() {
+                keydown_fn.with_value(|func| {
+                    if let Some(f) = func {
+                        let _ = window.remove_event_listener_with_callback("keydown", f);
+                    }
+                });
+                keyup_fn.with_value(|func| {
+                    if let Some(f) = func {
+                        let _ = window.remove_event_listener_with_callback("keyup", f);
+                    }
+                });
+            }
         });
 
         // Save position on page unload (beforeunload event)
@@ -1098,15 +1043,23 @@ pub fn RealmPage() -> impl IntoView {
         set_chat_focused.set(focused);
     });
 
-    // Create logout callback (WebSocket disconnects automatically)
+    // Create logout callback - explicitly close WebSocket before calling logout API
+    // Create logout callback - close WebSocket and call logout API
     let on_logout = Callback::new(move |_: ()| {
         #[cfg(feature = "hydrate")]
         {
             use gloo_net::http::Request;
             let navigate = navigate.clone();
 
+            // Close WebSocket explicitly with LOGOUT code (non-blocking, browser handles close handshake)
+            ws_close.with_value(|closer| {
+                if let Some(close_fn) = closer {
+                    close_fn(close_codes::LOGOUT, "logout".to_string());
+                }
+            });
+
+            // Call logout API immediately - session invalidation doesn't depend on WS close completing
             spawn_local(async move {
-                // WebSocket close handles channel leave automatically
                 let _: Result<gloo_net::http::Response, gloo_net::Error> =
                     Request::post("/api/auth/logout").send().await;
                 navigate("/", Default::default());
@@ -1268,7 +1221,6 @@ pub fn RealmPage() -> impl IntoView {
                                                                                 })
                                                                                 fading_members=Signal::derive(move || fading_members.get())
                                                                                 current_user_id=Signal::derive(move || current_user_id.get())
-                                                                                current_guest_session_id=Signal::derive(move || current_guest_session_id.get())
                                                                                 is_guest=Signal::derive(move || is_guest.get())
                                                                                 on_whisper_request=on_whisper_request_cb
                                                                             />
@@ -1395,6 +1347,37 @@ pub fn RealmPage() -> impl IntoView {
                                             }
                                         }
 
+                                        // Avatar store popup
+                                        <AvatarStorePopup
+                                            open=Signal::derive(move || avatar_store_open.get())
+                                            on_close=Callback::new(move |_: ()| set_avatar_store_open.set(false))
+                                            realm_slug=Signal::derive(move || slug.get())
+                                            is_guest=Signal::derive(move || is_guest.get())
+                                            on_avatar_selected=Callback::new(move |_: ()| {
+                                                // Refresh avatar data after selection
+                                                #[cfg(feature = "hydrate")]
+                                                {
+                                                    use gloo_net::http::Request;
+                                                    let current_slug = slug.get();
+                                                    leptos::task::spawn_local(async move {
+                                                        let response = Request::get(&format!("/api/realms/{}/avatar", current_slug))
+                                                            .send()
+                                                            .await;
+                                                        if let Ok(resp) = response {
+                                                            if resp.ok() {
+                                                                if let Ok(avatar) = resp.json::<AvatarWithPaths>().await {
+                                                                    let avail = avatar.compute_emotion_availability();
+                                                                    set_emotion_availability.set(Some(avail));
+                                                                    set_skin_preview_path.set(avatar.skin_layer[4].clone());
+                                                                    set_full_avatar.set(Some(avatar));
+                                                                }
+                                                            }
+                                                        }
+                                                    });
+                                                }
+                                            })
+                                        />
+
                                         // Registration modal for guest-to-user conversion
                                         {
                                             #[cfg(feature = "hydrate")]

crates/chattyness-user-ui/src/pages/signup.rs

@@ -129,6 +129,9 @@ pub fn SignupPage() -> impl IntoView {
                     password: pwd,
                     confirm_password: confirm_pwd,
                     realm_slug: slug.unwrap(),
+                    birthday: None,
+                    gender_preference: None,
+                    age_category: None,
                 };
 
                 let response = Request::post("/api/auth/signup")

db/reinitialize_all_users.sql

@@ -1,25 +0,0 @@
--- Reinitialize all users with current server props
--- Use: psql -d chattyness -f reinitialize_all_users.sql
-
-DO $$
-DECLARE
-    v_user RECORD;
-    v_count INT := 0;
-BEGIN
-    FOR v_user IN SELECT id, username FROM auth.users
-    LOOP
-        -- Clear existing data
-        DELETE FROM auth.active_avatars WHERE user_id = v_user.id;
-        DELETE FROM auth.avatars WHERE user_id = v_user.id;
-        DELETE FROM auth.inventory WHERE user_id = v_user.id;
-
-        -- Reinitialize with current server props
-        PERFORM auth.initialize_new_user(v_user.id);
-
-        v_count := v_count + 1;
-        RAISE NOTICE 'Reinitialized user: % (%)', v_user.username, v_user.id;
-    END LOOP;
-
-    RAISE NOTICE 'Total users reinitialized: %', v_count;
-END;
-$$;

db/reinitialize_user.md

@@ -1,59 +0,0 @@
-# Reinitialize User with Default Props
-
-When stock props or avatars are updated in the database, existing users may need to be reinitialized to receive the new defaults.
-
-## Steps
-
-1. Find the user's ID:
-
-```sql
-SELECT id, username FROM auth.users WHERE username = 'TARGET_USERNAME';
-```
-
-2. Clear existing data and reinitialize:
-
-```sql
-BEGIN;
-
--- Clear existing props and avatars for the user
-DELETE FROM auth.active_avatars WHERE user_id = 'USER_UUID';
-DELETE FROM auth.avatars WHERE user_id = 'USER_UUID';
-DELETE FROM auth.inventory WHERE user_id = 'USER_UUID';
-
--- Reinitialize with current server props
-SELECT auth.initialize_new_user('USER_UUID');
-
-COMMIT;
-```
-
-3. Verify the results:
-
-```sql
-SELECT COUNT(*) as inventory_count FROM auth.inventory WHERE user_id = 'USER_UUID';
-SELECT id, name, slot_number FROM auth.avatars WHERE user_id = 'USER_UUID';
-```
-
-## Example: Reinitialize ranosh
-
-```bash
-psql -d chattyness <<'EOF'
-BEGIN;
-
-DELETE FROM auth.active_avatars WHERE user_id = '57a12201-ea0f-4545-9ccc-c4e67ea7e2c4';
-DELETE FROM auth.avatars WHERE user_id = '57a12201-ea0f-4545-9ccc-c4e67ea7e2c4';
-DELETE FROM auth.inventory WHERE user_id = '57a12201-ea0f-4545-9ccc-c4e67ea7e2c4';
-
-SELECT auth.initialize_new_user('57a12201-ea0f-4545-9ccc-c4e67ea7e2c4');
-
-COMMIT;
-EOF
-```
-
-## What `initialize_new_user` Does
-
-The `auth.initialize_new_user()` function:
-
-1. Inserts all face-tagged server props into the user's inventory
-2. Creates a default avatar (slot 0) with:
-   - Face prop in the skin layer (position 4, center)
-   - All emotion props mapped to their respective emotion slots

db/schema/functions/001_helpers.sql

@@ -68,24 +68,6 @@ EXCEPTION
 END;
 $$ LANGUAGE plpgsql STABLE;
 
--- Set current guest session ID for RLS
-CREATE OR REPLACE FUNCTION public.set_current_guest_session_id(guest_session_id UUID)
-RETURNS VOID AS $$
-BEGIN
-    PERFORM set_config('app.current_guest_session_id', guest_session_id::TEXT, false);
-END;
-$$ LANGUAGE plpgsql;
-
--- Get current guest session ID for RLS
-CREATE OR REPLACE FUNCTION public.current_guest_session_id()
-RETURNS UUID AS $$
-BEGIN
-    RETURN NULLIF(current_setting('app.current_guest_session_id', true), '')::UUID;
-EXCEPTION
-    WHEN OTHERS THEN RETURN NULL;
-END;
-$$ LANGUAGE plpgsql STABLE;
-
 -- Check if current user is a server admin
 CREATE OR REPLACE FUNCTION public.is_server_admin()
 RETURNS BOOLEAN AS $$
@@ -318,4 +300,34 @@ COMMENT ON FUNCTION scene.clear_stale_instance_members(DOUBLE PRECISION) IS
 GRANT EXECUTE ON FUNCTION scene.clear_all_instance_members() TO chattyness_app;
 GRANT EXECUTE ON FUNCTION scene.clear_stale_instance_members(DOUBLE PRECISION) TO chattyness_app;
 
+-- =============================================================================
+-- Guest Cleanup Functions
+-- =============================================================================
+
+-- Clean up stale guest accounts that haven't been active in 7 days
+-- Guests are users with the 'guest' tag in auth.users
+-- Uses SECURITY DEFINER to bypass RLS
+CREATE OR REPLACE FUNCTION auth.cleanup_stale_guests()
+RETURNS INTEGER AS $$
+DECLARE
+    deleted_count INTEGER;
+BEGIN
+    WITH deleted AS (
+        DELETE FROM auth.users
+        WHERE 'guest' = ANY(tags)
+          AND last_seen_at < now() - interval '7 days'
+        RETURNING id
+    )
+    SELECT count(*) INTO deleted_count FROM deleted;
+
+    RETURN deleted_count;
+END;
+$$ LANGUAGE plpgsql SECURITY DEFINER;
+
+COMMENT ON FUNCTION auth.cleanup_stale_guests() IS
+    'Removes guest accounts (users with guest tag) inactive for 7+ days. Run via cron.';
+
+-- Grant execute to chattyness_app
+GRANT EXECUTE ON FUNCTION auth.cleanup_stale_guests() TO chattyness_app;
+
 COMMIT;

db/schema/functions/002_user_init.sql

@@ -1,170 +0,0 @@
--- Chattyness User Initialization Functions
--- PostgreSQL 18
---
--- Functions to initialize new users with default props and avatars.
--- Load via: psql -f schema/functions/002_user_init.sql
-
-\set ON_ERROR_STOP on
-
-BEGIN;
-
--- =============================================================================
--- Initialize New User with Default Props and Avatar
--- =============================================================================
--- Called when a new user is created to give them:
---   1. All face-tagged server props in their inventory
---   2. A default avatar (slot 0) with the Face prop and all emotions configured
---
--- Note: active_avatars entry is NOT created here - it's created when the user
--- joins a realm for the first time (per-realm avatar state).
--- =============================================================================
-
-CREATE OR REPLACE FUNCTION auth.initialize_new_user(p_user_id UUID)
-RETURNS VOID AS $$
-DECLARE
-    v_avatar_id UUID;
-    v_face_inventory_id UUID;
-    v_neutral_inventory_id UUID;
-    v_happy_inventory_id UUID;
-    v_sad_inventory_id UUID;
-    v_angry_inventory_id UUID;
-    v_surprised_inventory_id UUID;
-    v_thinking_inventory_id UUID;
-    v_laughing_inventory_id UUID;
-    v_crying_inventory_id UUID;
-    v_love_inventory_id UUID;
-    v_confused_inventory_id UUID;
-    v_sleeping_inventory_id UUID;
-    v_wink_inventory_id UUID;
-    v_prop RECORD;
-BEGIN
-    -- Insert all face-tagged server props into user's inventory
-    -- Note: inventory layer/position are only for content layer props (skin/clothes/accessories).
-    -- Emotion props have default_emotion instead of default_layer, so they get NULL layer/position.
-    FOR v_prop IN
-        SELECT id, name, asset_path, default_layer, default_emotion, default_position, slug,
-               is_transferable, is_portable, is_droppable
-        FROM server.props
-        WHERE tags @> ARRAY['face']
-        AND is_active = true
-    LOOP
-        -- Use a local variable for the inserted inventory ID
-        DECLARE
-            v_new_inventory_id UUID;
-        BEGIN
-            INSERT INTO auth.inventory (
-                user_id,
-                server_prop_id,
-                prop_name,
-                prop_asset_path,
-                layer,
-                position,
-                origin,
-                is_transferable,
-                is_portable,
-                is_droppable
-            )
-            VALUES (
-                p_user_id,
-                v_prop.id,
-                v_prop.name,
-                v_prop.asset_path,
-                v_prop.default_layer,  -- NULL for emotion props
-                CASE WHEN v_prop.default_layer IS NOT NULL THEN v_prop.default_position ELSE NULL END,
-                'server_library',
-                v_prop.is_transferable,
-                v_prop.is_portable,
-                v_prop.is_droppable
-            )
-            RETURNING id INTO v_new_inventory_id;
-
-            -- Track inventory IDs for avatar assignment based on slug
-            CASE v_prop.slug
-                WHEN 'face' THEN v_face_inventory_id := v_new_inventory_id;
-                WHEN 'neutral' THEN v_neutral_inventory_id := v_new_inventory_id;
-                WHEN 'smile' THEN v_happy_inventory_id := v_new_inventory_id;
-                WHEN 'sad' THEN v_sad_inventory_id := v_new_inventory_id;
-                WHEN 'angry' THEN v_angry_inventory_id := v_new_inventory_id;
-                WHEN 'surprised' THEN v_surprised_inventory_id := v_new_inventory_id;
-                WHEN 'thinking' THEN v_thinking_inventory_id := v_new_inventory_id;
-                WHEN 'laughing' THEN v_laughing_inventory_id := v_new_inventory_id;
-                WHEN 'crying' THEN v_crying_inventory_id := v_new_inventory_id;
-                WHEN 'love' THEN v_love_inventory_id := v_new_inventory_id;
-                WHEN 'confused' THEN v_confused_inventory_id := v_new_inventory_id;
-                WHEN 'sleeping' THEN v_sleeping_inventory_id := v_new_inventory_id;
-                WHEN 'wink' THEN v_wink_inventory_id := v_new_inventory_id;
-                ELSE NULL;
-            END CASE;
-        END;
-    END LOOP;
-
-    -- Create default avatar (slot 0) with the Face prop in skin layer
-    -- and all emotion props in their respective emotion slots at position 4 (center)
-    INSERT INTO auth.avatars (
-        user_id,
-        name,
-        slot_number,
-        last_emotion,
-        -- Content layer: Face goes in skin layer, center position
-        l_skin_4,
-        -- Emotion layers: Each emotion prop goes to its matching emotion at center position
-        e_neutral_4,
-        e_happy_4,
-        e_sad_4,
-        e_angry_4,
-        e_surprised_4,
-        e_thinking_4,
-        e_laughing_4,
-        e_crying_4,
-        e_love_4,
-        e_confused_4,
-        e_sleeping_4,
-        e_wink_4
-    )
-    VALUES (
-        p_user_id,
-        'Default',
-        0,
-        0, -- Start with neutral emotion
-        v_face_inventory_id,
-        v_neutral_inventory_id,
-        v_happy_inventory_id,
-        v_sad_inventory_id,
-        v_angry_inventory_id,
-        v_surprised_inventory_id,
-        v_thinking_inventory_id,
-        v_laughing_inventory_id,
-        v_crying_inventory_id,
-        v_love_inventory_id,
-        v_confused_inventory_id,
-        v_sleeping_inventory_id,
-        v_wink_inventory_id
-    )
-    RETURNING id INTO v_avatar_id;
-
-    -- Note: We don't create an active_avatars entry here because that's per-realm.
-    -- The active_avatars entry will be created when the user first joins a realm.
-END;
-$$ LANGUAGE plpgsql SECURITY DEFINER;
-
-COMMENT ON FUNCTION auth.initialize_new_user(UUID) IS
-    'Initialize a new user with default props in inventory and a default avatar configuration';
-
--- =============================================================================
--- Trigger Function for User Registration
--- =============================================================================
--- Wrapper trigger function that calls initialize_new_user.
--- =============================================================================
-
-CREATE OR REPLACE FUNCTION auth.initialize_new_user_trigger()
-RETURNS TRIGGER AS $$
-BEGIN
-    PERFORM auth.initialize_new_user(NEW.id);
-    RETURN NEW;
-END;
-$$ LANGUAGE plpgsql SECURITY DEFINER;
-
-COMMENT ON FUNCTION auth.initialize_new_user_trigger() IS
-    'Trigger function to initialize new users on registration';
-
-COMMIT;

db/schema/load.sql

@@ -45,7 +45,9 @@
 \echo 'Phase 3: Creating tables...'
 \ir tables/010_server.sql
 \ir tables/020_auth.sql
+\ir tables/025_server_avatars.sql
 \ir tables/030_realm.sql
+\ir tables/035_realm_avatars.sql
 \ir tables/045_scene.sql
 \ir tables/050_chat.sql
 \ir tables/080_audit.sql
@@ -56,7 +58,6 @@
 -- =============================================================================
 \echo 'Phase 4: Creating functions...'
 \ir functions/001_helpers.sql
-\ir functions/002_user_init.sql
 \echo ''
 
 -- =============================================================================
@@ -64,7 +65,6 @@
 -- =============================================================================
 \echo 'Phase 5: Creating triggers...'
 \ir triggers/001_updated_at.sql
-\ir triggers/002_user_init.sql
 \echo ''
 
 -- =============================================================================

db/schema/policies/001_rls.sql

@@ -79,6 +79,29 @@ CREATE POLICY server_props_delete ON server.props
 GRANT SELECT ON server.props TO chattyness_app;
 GRANT INSERT, UPDATE, DELETE ON server.props TO chattyness_app;
 
+-- server.avatars
+ALTER TABLE server.avatars ENABLE ROW LEVEL SECURITY;
+
+CREATE POLICY server_avatars_select ON server.avatars
+    FOR SELECT TO chattyness_app
+    USING (true);
+
+CREATE POLICY server_avatars_insert ON server.avatars
+    FOR INSERT TO chattyness_app
+    WITH CHECK (public.is_server_admin());
+
+CREATE POLICY server_avatars_update ON server.avatars
+    FOR UPDATE TO chattyness_app
+    USING (public.is_server_admin())
+    WITH CHECK (public.is_server_admin());
+
+CREATE POLICY server_avatars_delete ON server.avatars
+    FOR DELETE TO chattyness_app
+    USING (public.is_server_admin());
+
+GRANT SELECT ON server.avatars TO chattyness_app;
+GRANT INSERT, UPDATE, DELETE ON server.avatars TO chattyness_app;
+
 -- server.audio
 ALTER TABLE server.audio ENABLE ROW LEVEL SECURITY;
 
@@ -236,16 +259,6 @@ CREATE POLICY auth_sessions_admin ON auth.sessions
 
 GRANT SELECT, INSERT, UPDATE, DELETE ON auth.sessions TO chattyness_app;
 
--- auth.guest_sessions
-ALTER TABLE auth.guest_sessions ENABLE ROW LEVEL SECURITY;
-
-CREATE POLICY auth_guest_sessions_all ON auth.guest_sessions
-    FOR ALL TO chattyness_app
-    USING (true)
-    WITH CHECK (true);
-
-GRANT SELECT, INSERT, UPDATE, DELETE ON auth.guest_sessions TO chattyness_app;
-
 -- auth.tower_sessions
 ALTER TABLE auth.tower_sessions ENABLE ROW LEVEL SECURITY;
 
@@ -350,6 +363,12 @@ CREATE POLICY auth_active_avatars_view ON auth.active_avatars
     FOR SELECT TO chattyness_app
     USING (true);
 
+-- Allow realm moderators to update forced avatar columns on any user in their realm
+CREATE POLICY auth_active_avatars_mod ON auth.active_avatars
+    FOR UPDATE TO chattyness_app
+    USING (public.is_realm_moderator(realm_id))
+    WITH CHECK (public.is_realm_moderator(realm_id));
+
 GRANT SELECT, INSERT, UPDATE, DELETE ON auth.active_avatars TO chattyness_app;
 
 -- =============================================================================
@@ -507,6 +526,30 @@ CREATE POLICY realm_props_modify ON realm.props
 
 GRANT SELECT, INSERT, UPDATE, DELETE ON realm.props TO chattyness_app;
 
+-- realm.avatars
+ALTER TABLE realm.avatars ENABLE ROW LEVEL SECURITY;
+
+CREATE POLICY realm_avatars_select ON realm.avatars
+    FOR SELECT TO chattyness_app
+    USING (
+        public.has_realm_membership(realm_id)
+        OR public.is_server_admin()
+    );
+
+CREATE POLICY realm_avatars_modify ON realm.avatars
+    FOR ALL TO chattyness_app
+    USING (
+        EXISTS (
+            SELECT 1 FROM realm.memberships m
+            WHERE m.realm_id = realm.avatars.realm_id
+            AND m.user_id = public.current_user_id()
+            AND m.role IN ('owner', 'builder')
+        )
+        OR public.is_server_admin()
+    );
+
+GRANT SELECT, INSERT, UPDATE, DELETE ON realm.avatars TO chattyness_app;
+
 -- realm.reports
 ALTER TABLE realm.reports ENABLE ROW LEVEL SECURITY;
 
@@ -674,14 +717,8 @@ CREATE POLICY scene_instance_members_select ON scene.instance_members
 
 CREATE POLICY scene_instance_members_own ON scene.instance_members
     FOR ALL TO chattyness_app
-    USING (
-        user_id = public.current_user_id()
-        OR guest_session_id = public.current_guest_session_id()
-    )
-    WITH CHECK (
-        user_id = public.current_user_id()
-        OR guest_session_id = public.current_guest_session_id()
-    );
+    USING (user_id = public.current_user_id())
+    WITH CHECK (user_id = public.current_user_id());
 
 GRANT SELECT, INSERT, UPDATE, DELETE ON scene.instance_members TO chattyness_app;
 
@@ -876,16 +913,12 @@ CREATE POLICY chat_messages_select ON chat.messages
 
 CREATE POLICY chat_messages_insert ON chat.messages
     FOR INSERT TO chattyness_app
-    WITH CHECK (
-        user_id = public.current_user_id()
-        OR guest_session_id = public.current_guest_session_id()
-    );
+    WITH CHECK (user_id = public.current_user_id());
 
 CREATE POLICY chat_messages_update ON chat.messages
     FOR UPDATE TO chattyness_app
     USING (
         user_id = public.current_user_id()
-        OR guest_session_id = public.current_guest_session_id()
         OR public.is_server_moderator()
     );
 

db/schema/tables/020_auth.sql

@@ -24,6 +24,11 @@ CREATE TABLE auth.users (
     bio TEXT,
     avatar_url public.url,
 
+    -- User preferences for default avatar selection
+    birthday DATE,
+    gender_preference auth.gender_preference NOT NULL DEFAULT 'gender_neutral',
+    age_category auth.age_category NOT NULL DEFAULT 'adult',
+
     reputation_tier server.reputation_tier NOT NULL DEFAULT 'member',
     reputation_promoted_at TIMESTAMPTZ,
 
@@ -634,9 +639,13 @@ CREATE INDEX idx_auth_avatars_default ON auth.avatars (user_id, is_default) WHER
 CREATE TABLE auth.active_avatars (
     user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
     realm_id UUID NOT NULL,  -- FK added in 030_realm.sql after realm.realms exists
-    avatar_id UUID NOT NULL REFERENCES auth.avatars(id) ON DELETE CASCADE,
+    avatar_id UUID REFERENCES auth.avatars(id) ON DELETE SET NULL,
 
-    current_emotion SMALLINT NOT NULL DEFAULT 0 CHECK (current_emotion >= 0 AND current_emotion <= 11),
+    -- User-selected avatars from avatar stores (lower priority than custom avatar)
+    selected_server_avatar_id UUID,  -- FK added in 025_server_avatars.sql
+    selected_realm_avatar_id UUID,   -- FK added in 035_realm_avatars.sql
+
+    current_emotion server.emotion_state NOT NULL DEFAULT 'happy',
 
     updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 
@@ -644,6 +653,12 @@ CREATE TABLE auth.active_avatars (
 );
 
 COMMENT ON TABLE auth.active_avatars IS 'Current avatar per user per realm';
+COMMENT ON COLUMN auth.active_avatars.avatar_id IS
+    'User custom avatar (highest priority, nullable for users without custom avatars)';
+COMMENT ON COLUMN auth.active_avatars.selected_server_avatar_id IS
+    'User-selected server avatar (from avatar store), lower priority than custom avatar';
+COMMENT ON COLUMN auth.active_avatars.selected_realm_avatar_id IS
+    'User-selected realm avatar (from avatar store), higher priority than server selection';
 
 -- =============================================================================
 -- Server-Level Moderation: IP Bans

db/schema/tables/025_server_avatars.sql

@@ -0,0 +1,222 @@
+-- =============================================================================
+-- Server Avatars
+-- =============================================================================
+-- Pre-configured avatar configurations available globally across all realms.
+-- These reference server.props directly (not inventory items).
+--
+-- Loaded after 020_auth.sql (server.props must exist)
+-- =============================================================================
+
+CREATE TABLE server.avatars (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+
+    slug public.slug NOT NULL,
+    name public.nonempty_text NOT NULL,
+    description TEXT,
+
+    is_public BOOLEAN NOT NULL DEFAULT false,
+    is_active BOOLEAN NOT NULL DEFAULT true,
+    thumbnail_path public.asset_path,
+
+    -- Content layers: 3 layers x 9 positions = 27 slots
+    -- All reference server.props(id) directly
+    l_skin_0 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_skin_1 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_skin_2 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_skin_3 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_skin_4 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_skin_5 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_skin_6 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_skin_7 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_skin_8 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+
+    l_clothes_0 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_clothes_1 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_clothes_2 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_clothes_3 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_clothes_4 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_clothes_5 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_clothes_6 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_clothes_7 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_clothes_8 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+
+    l_accessories_0 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_accessories_1 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_accessories_2 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_accessories_3 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_accessories_4 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_accessories_5 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_accessories_6 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_accessories_7 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    l_accessories_8 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+
+    -- Emotion layers: 12 emotions x 9 positions = 108 slots
+    e_neutral_0 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_neutral_1 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_neutral_2 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_neutral_3 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_neutral_4 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_neutral_5 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_neutral_6 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_neutral_7 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_neutral_8 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+
+    e_happy_0 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_happy_1 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_happy_2 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_happy_3 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_happy_4 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_happy_5 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_happy_6 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_happy_7 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_happy_8 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+
+    e_sad_0 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sad_1 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sad_2 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sad_3 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sad_4 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sad_5 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sad_6 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sad_7 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sad_8 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+
+    e_angry_0 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_angry_1 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_angry_2 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_angry_3 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_angry_4 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_angry_5 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_angry_6 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_angry_7 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_angry_8 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+
+    e_surprised_0 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_surprised_1 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_surprised_2 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_surprised_3 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_surprised_4 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_surprised_5 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_surprised_6 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_surprised_7 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_surprised_8 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+
+    e_thinking_0 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_thinking_1 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_thinking_2 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_thinking_3 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_thinking_4 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_thinking_5 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_thinking_6 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_thinking_7 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_thinking_8 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+
+    e_laughing_0 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_laughing_1 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_laughing_2 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_laughing_3 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_laughing_4 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_laughing_5 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_laughing_6 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_laughing_7 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_laughing_8 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+
+    e_crying_0 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_crying_1 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_crying_2 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_crying_3 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_crying_4 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_crying_5 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_crying_6 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_crying_7 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_crying_8 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+
+    e_love_0 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_love_1 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_love_2 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_love_3 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_love_4 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_love_5 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_love_6 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_love_7 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_love_8 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+
+    e_confused_0 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_confused_1 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_confused_2 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_confused_3 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_confused_4 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_confused_5 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_confused_6 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_confused_7 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_confused_8 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+
+    e_sleeping_0 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sleeping_1 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sleeping_2 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sleeping_3 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sleeping_4 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sleeping_5 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sleeping_6 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sleeping_7 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_sleeping_8 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+
+    e_wink_0 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_wink_1 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_wink_2 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_wink_3 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_wink_4 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_wink_5 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_wink_6 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_wink_7 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+    e_wink_8 UUID REFERENCES server.props(id) ON DELETE SET NULL,
+
+    created_by UUID REFERENCES auth.users(id) ON DELETE SET NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+
+    CONSTRAINT uq_server_avatars_slug UNIQUE (slug)
+);
+
+COMMENT ON TABLE server.avatars IS 'Pre-configured avatar configurations available globally (references server.props)';
+
+CREATE INDEX idx_server_avatars_active ON server.avatars (is_active) WHERE is_active = true;
+CREATE INDEX idx_server_avatars_public ON server.avatars (is_public) WHERE is_public = true;
+
+COMMENT ON COLUMN server.avatars.is_public IS
+    'When true, avatar appears in the public avatar selection. Uses filtered index.';
+
+-- =============================================================================
+-- Add Default Avatar Columns to server.config
+-- =============================================================================
+-- These columns reference server.avatars for gender/age-based default avatars.
+-- =============================================================================
+
+ALTER TABLE server.config
+    ADD COLUMN default_avatar_neutral_child UUID REFERENCES server.avatars(id) ON DELETE SET NULL,
+    ADD COLUMN default_avatar_neutral_adult UUID REFERENCES server.avatars(id) ON DELETE SET NULL,
+    ADD COLUMN default_avatar_male_child UUID REFERENCES server.avatars(id) ON DELETE SET NULL,
+    ADD COLUMN default_avatar_male_adult UUID REFERENCES server.avatars(id) ON DELETE SET NULL,
+    ADD COLUMN default_avatar_female_child UUID REFERENCES server.avatars(id) ON DELETE SET NULL,
+    ADD COLUMN default_avatar_female_adult UUID REFERENCES server.avatars(id) ON DELETE SET NULL;
+
+COMMENT ON COLUMN server.config.default_avatar_neutral_child IS
+    'Default server avatar for gender-neutral child users';
+COMMENT ON COLUMN server.config.default_avatar_neutral_adult IS
+    'Default server avatar for gender-neutral adult users';
+COMMENT ON COLUMN server.config.default_avatar_male_child IS
+    'Default server avatar for male child users';
+COMMENT ON COLUMN server.config.default_avatar_male_adult IS
+    'Default server avatar for male adult users';
+COMMENT ON COLUMN server.config.default_avatar_female_child IS
+    'Default server avatar for female child users';
+COMMENT ON COLUMN server.config.default_avatar_female_adult IS
+    'Default server avatar for female adult users';
+
+-- =============================================================================
+-- Add FK for auth.active_avatars.selected_server_avatar_id
+-- =============================================================================
+
+ALTER TABLE auth.active_avatars
+    ADD CONSTRAINT fk_auth_active_avatars_selected_server_avatar
+    FOREIGN KEY (selected_server_avatar_id) REFERENCES server.avatars(id) ON DELETE SET NULL;

db/schema/tables/030_realm.sql

@@ -35,6 +35,15 @@ CREATE TABLE realm.realms (
 
     default_scene_id UUID,
 
+    -- Default avatars for this realm (optional, override server defaults)
+    -- FK constraints added in 035_realm_avatars.sql after realm.avatars exists
+    default_avatar_neutral_child UUID,
+    default_avatar_neutral_adult UUID,
+    default_avatar_male_child UUID,
+    default_avatar_male_adult UUID,
+    default_avatar_female_child UUID,
+    default_avatar_female_adult UUID,
+
     member_count INTEGER NOT NULL DEFAULT 0 CHECK (member_count >= 0),
     current_user_count INTEGER NOT NULL DEFAULT 0 CHECK (current_user_count >= 0),
 
@@ -93,35 +102,6 @@ ALTER TABLE realm.realms
     ADD CONSTRAINT fk_realm_realms_default_scene
     FOREIGN KEY (default_scene_id) REFERENCES realm.scenes(id) ON DELETE SET NULL;
 
--- =============================================================================
--- Guest Sessions (created here since it references realm tables)
--- =============================================================================
--- Note: current_instance_id FK is added in 045_scene.sql after scene.instances exists
-
-CREATE TABLE auth.guest_sessions (
-    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-
-    guest_name public.display_name NOT NULL,
-    token_hash TEXT NOT NULL,
-
-    user_agent TEXT,
-    ip_address INET,
-
-    current_realm_id UUID REFERENCES realm.realms(id) ON DELETE SET NULL,
-    current_instance_id UUID,  -- FK added in 045_scene.sql
-
-    expires_at TIMESTAMPTZ NOT NULL,
-    last_activity_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-
-    CONSTRAINT uq_auth_guest_sessions_token UNIQUE (token_hash)
-);
-
-COMMENT ON TABLE auth.guest_sessions IS 'Anonymous guest sessions';
-
-CREATE INDEX idx_auth_guest_sessions_expires ON auth.guest_sessions (expires_at);
-CREATE INDEX idx_auth_guest_sessions_ip ON auth.guest_sessions (ip_address);
-
 -- =============================================================================
 -- Realm Memberships
 -- =============================================================================

db/schema/tables/035_realm_avatars.sql

@@ -0,0 +1,288 @@
+-- =============================================================================
+-- Realm Avatars and Forced Avatar Support
+-- =============================================================================
+-- Pre-configured avatar configurations specific to a realm.
+-- These reference realm.props directly (not inventory items).
+--
+-- Also adds forced avatar support to auth.active_avatars and realm.scenes.
+--
+-- Loaded after 030_realm.sql (realm.props must exist)
+-- =============================================================================
+
+-- =============================================================================
+-- Realm Avatars Table
+-- =============================================================================
+
+CREATE TABLE realm.avatars (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+
+    realm_id UUID NOT NULL REFERENCES realm.realms(id) ON DELETE CASCADE,
+
+    slug public.slug NOT NULL,
+    name public.nonempty_text NOT NULL,
+    description TEXT,
+
+    is_public BOOLEAN NOT NULL DEFAULT false,
+    is_active BOOLEAN NOT NULL DEFAULT true,
+    thumbnail_path public.asset_path,
+
+    -- Content layers: 3 layers x 9 positions = 27 slots
+    -- All reference realm.props(id) directly (realm props only, no server props)
+    l_skin_0 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_skin_1 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_skin_2 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_skin_3 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_skin_4 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_skin_5 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_skin_6 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_skin_7 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_skin_8 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+
+    l_clothes_0 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_clothes_1 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_clothes_2 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_clothes_3 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_clothes_4 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_clothes_5 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_clothes_6 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_clothes_7 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_clothes_8 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+
+    l_accessories_0 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_accessories_1 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_accessories_2 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_accessories_3 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_accessories_4 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_accessories_5 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_accessories_6 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_accessories_7 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    l_accessories_8 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+
+    -- Emotion layers: 12 emotions x 9 positions = 108 slots
+    e_neutral_0 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_neutral_1 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_neutral_2 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_neutral_3 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_neutral_4 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_neutral_5 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_neutral_6 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_neutral_7 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_neutral_8 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+
+    e_happy_0 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_happy_1 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_happy_2 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_happy_3 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_happy_4 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_happy_5 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_happy_6 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_happy_7 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_happy_8 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+
+    e_sad_0 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sad_1 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sad_2 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sad_3 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sad_4 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sad_5 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sad_6 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sad_7 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sad_8 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+
+    e_angry_0 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_angry_1 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_angry_2 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_angry_3 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_angry_4 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_angry_5 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_angry_6 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_angry_7 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_angry_8 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+
+    e_surprised_0 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_surprised_1 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_surprised_2 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_surprised_3 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_surprised_4 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_surprised_5 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_surprised_6 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_surprised_7 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_surprised_8 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+
+    e_thinking_0 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_thinking_1 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_thinking_2 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_thinking_3 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_thinking_4 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_thinking_5 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_thinking_6 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_thinking_7 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_thinking_8 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+
+    e_laughing_0 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_laughing_1 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_laughing_2 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_laughing_3 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_laughing_4 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_laughing_5 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_laughing_6 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_laughing_7 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_laughing_8 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+
+    e_crying_0 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_crying_1 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_crying_2 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_crying_3 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_crying_4 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_crying_5 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_crying_6 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_crying_7 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_crying_8 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+
+    e_love_0 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_love_1 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_love_2 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_love_3 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_love_4 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_love_5 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_love_6 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_love_7 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_love_8 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+
+    e_confused_0 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_confused_1 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_confused_2 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_confused_3 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_confused_4 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_confused_5 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_confused_6 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_confused_7 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_confused_8 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+
+    e_sleeping_0 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sleeping_1 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sleeping_2 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sleeping_3 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sleeping_4 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sleeping_5 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sleeping_6 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sleeping_7 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_sleeping_8 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+
+    e_wink_0 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_wink_1 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_wink_2 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_wink_3 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_wink_4 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_wink_5 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_wink_6 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_wink_7 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+    e_wink_8 UUID REFERENCES realm.props(id) ON DELETE SET NULL,
+
+    created_by UUID REFERENCES auth.users(id) ON DELETE SET NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+
+    CONSTRAINT uq_realm_avatars_slug UNIQUE (realm_id, slug)
+);
+
+COMMENT ON TABLE realm.avatars IS 'Pre-configured avatar configurations specific to a realm (references realm.props only)';
+
+CREATE INDEX idx_realm_avatars_realm ON realm.avatars (realm_id);
+CREATE INDEX idx_realm_avatars_active ON realm.avatars (realm_id, is_active) WHERE is_active = true;
+CREATE INDEX idx_realm_avatars_public ON realm.avatars (realm_id, is_public) WHERE is_public = true;
+
+COMMENT ON COLUMN realm.avatars.is_public IS
+    'When true, avatar appears in the public avatar selection for this realm. Uses filtered index.';
+
+-- =============================================================================
+-- Add Default Avatar FK Constraints to realm.realms
+-- =============================================================================
+-- Now that realm.avatars exists, add the FK constraints for default avatars.
+-- =============================================================================
+
+ALTER TABLE realm.realms
+    ADD CONSTRAINT fk_realm_default_avatar_neutral_child
+    FOREIGN KEY (default_avatar_neutral_child) REFERENCES realm.avatars(id) ON DELETE SET NULL,
+    ADD CONSTRAINT fk_realm_default_avatar_neutral_adult
+    FOREIGN KEY (default_avatar_neutral_adult) REFERENCES realm.avatars(id) ON DELETE SET NULL,
+    ADD CONSTRAINT fk_realm_default_avatar_male_child
+    FOREIGN KEY (default_avatar_male_child) REFERENCES realm.avatars(id) ON DELETE SET NULL,
+    ADD CONSTRAINT fk_realm_default_avatar_male_adult
+    FOREIGN KEY (default_avatar_male_adult) REFERENCES realm.avatars(id) ON DELETE SET NULL,
+    ADD CONSTRAINT fk_realm_default_avatar_female_child
+    FOREIGN KEY (default_avatar_female_child) REFERENCES realm.avatars(id) ON DELETE SET NULL,
+    ADD CONSTRAINT fk_realm_default_avatar_female_adult
+    FOREIGN KEY (default_avatar_female_adult) REFERENCES realm.avatars(id) ON DELETE SET NULL;
+
+COMMENT ON COLUMN realm.realms.default_avatar_neutral_child IS
+    'Default realm avatar for gender-neutral child users (overrides server default)';
+COMMENT ON COLUMN realm.realms.default_avatar_neutral_adult IS
+    'Default realm avatar for gender-neutral adult users (overrides server default)';
+COMMENT ON COLUMN realm.realms.default_avatar_male_child IS
+    'Default realm avatar for male child users (overrides server default)';
+COMMENT ON COLUMN realm.realms.default_avatar_male_adult IS
+    'Default realm avatar for male adult users (overrides server default)';
+COMMENT ON COLUMN realm.realms.default_avatar_female_child IS
+    'Default realm avatar for female child users (overrides server default)';
+COMMENT ON COLUMN realm.realms.default_avatar_female_adult IS
+    'Default realm avatar for female adult users (overrides server default)';
+
+-- =============================================================================
+-- Add FK for auth.active_avatars.selected_realm_avatar_id
+-- =============================================================================
+
+ALTER TABLE auth.active_avatars
+    ADD CONSTRAINT fk_auth_active_avatars_selected_realm_avatar
+    FOREIGN KEY (selected_realm_avatar_id) REFERENCES realm.avatars(id) ON DELETE SET NULL;
+
+-- =============================================================================
+-- Add Forced Avatar Columns to auth.active_avatars
+-- =============================================================================
+-- Tracks when a user has a forced avatar (from mod command or scene entry)
+
+ALTER TABLE auth.active_avatars
+    ADD COLUMN forced_avatar_id UUID,
+    ADD COLUMN forced_avatar_source TEXT
+        CHECK (forced_avatar_source IS NULL OR forced_avatar_source IN ('server', 'realm', 'scene')),
+    ADD COLUMN forced_by UUID REFERENCES auth.users(id) ON DELETE SET NULL,
+    ADD COLUMN forced_until TIMESTAMPTZ;
+
+COMMENT ON COLUMN auth.active_avatars.forced_avatar_id IS
+    'UUID of the forced avatar (from server.avatars or realm.avatars depending on source)';
+COMMENT ON COLUMN auth.active_avatars.forced_avatar_source IS
+    'Source of forced avatar: server (server.avatars), realm (realm.avatars), or scene (from scene setting)';
+COMMENT ON COLUMN auth.active_avatars.forced_by IS
+    'User who forced this avatar (moderator), NULL for scene-forced';
+COMMENT ON COLUMN auth.active_avatars.forced_until IS
+    'When the forced avatar expires, NULL for permanent/until manually cleared';
+
+-- Index for finding expired forced avatars
+CREATE INDEX idx_auth_active_avatars_forced_expires
+    ON auth.active_avatars (forced_until)
+    WHERE forced_until IS NOT NULL;
+
+-- =============================================================================
+-- Add Forced Avatar Columns to realm.scenes
+-- =============================================================================
+-- Allows scenes to force all users to wear a specific avatar
+
+ALTER TABLE realm.scenes
+    ADD COLUMN forced_avatar_id UUID,
+    ADD COLUMN forced_avatar_source TEXT
+        CHECK (forced_avatar_source IS NULL OR forced_avatar_source IN ('server', 'realm'));
+
+COMMENT ON COLUMN realm.scenes.forced_avatar_id IS
+    'UUID of avatar all users must wear in this scene (from server.avatars or realm.avatars)';
+COMMENT ON COLUMN realm.scenes.forced_avatar_source IS
+    'Source of forced avatar: server (server.avatars) or realm (realm.avatars)';
+
+-- =============================================================================
+-- Add New Moderation Action Types
+-- =============================================================================
+
+ALTER TYPE server.action_type ADD VALUE 'dress_user';
+ALTER TYPE server.action_type ADD VALUE 'undress_user';
+ALTER TYPE server.action_type ADD VALUE 'teleport';
+
+COMMENT ON TYPE server.action_type IS 'Type of moderation action taken (includes dress_user, undress_user, teleport)';

db/schema/tables/045_scene.sql

@@ -40,30 +40,19 @@ CREATE INDEX idx_scene_instances_scene ON scene.instances (scene_id);
 CREATE INDEX idx_scene_instances_type ON scene.instances (scene_id, instance_type);
 CREATE INDEX idx_scene_instances_expires ON scene.instances (expires_at) WHERE expires_at IS NOT NULL;
 
--- =============================================================================
--- Add FK from auth.guest_sessions to scene.instances
--- =============================================================================
--- guest_sessions.current_instance_id was added without FK in 030_realm.sql
--- Now we can add the constraint since scene.instances exists
--- =============================================================================
-
-ALTER TABLE auth.guest_sessions
-    ADD CONSTRAINT fk_auth_guest_sessions_instance
-    FOREIGN KEY (current_instance_id) REFERENCES scene.instances(id) ON DELETE SET NULL;
-
 -- =============================================================================
 -- Instance Members (renamed from realm.channel_members)
 -- =============================================================================
 -- Users currently present in an instance with their positions.
 -- Note: instance_id is actually scene_id in this system (scenes are used directly as instances).
+-- Guests are regular users with the 'guest' tag in auth.users.
 -- =============================================================================
 
 CREATE TABLE scene.instance_members (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 
     instance_id UUID NOT NULL REFERENCES realm.scenes(id) ON DELETE CASCADE,
-    user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE,
-    guest_session_id UUID REFERENCES auth.guest_sessions(id) ON DELETE CASCADE,
+    user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
 
     position public.virtual_point NOT NULL DEFAULT ST_SetSRID(ST_MakePoint(400, 300), 0),
 
@@ -74,19 +63,13 @@ CREATE TABLE scene.instance_members (
     joined_at TIMESTAMPTZ NOT NULL DEFAULT now(),
     last_moved_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 
-    CONSTRAINT chk_scene_instance_members_user_or_guest CHECK (
-        (user_id IS NOT NULL AND guest_session_id IS NULL) OR
-        (user_id IS NULL AND guest_session_id IS NOT NULL)
-    ),
-    CONSTRAINT uq_scene_instance_members_user UNIQUE (instance_id, user_id),
-    CONSTRAINT uq_scene_instance_members_guest UNIQUE (instance_id, guest_session_id)
+    CONSTRAINT uq_scene_instance_members_user UNIQUE (instance_id, user_id)
 );
 
-COMMENT ON TABLE scene.instance_members IS 'Users in an instance with positions';
+COMMENT ON TABLE scene.instance_members IS 'Users in an instance with positions (guests are users with guest tag)';
 
 CREATE INDEX idx_scene_instance_members_instance ON scene.instance_members (instance_id);
-CREATE INDEX idx_scene_instance_members_user ON scene.instance_members (user_id) WHERE user_id IS NOT NULL;
-CREATE INDEX idx_scene_instance_members_guest ON scene.instance_members (guest_session_id) WHERE guest_session_id IS NOT NULL;
+CREATE INDEX idx_scene_instance_members_user ON scene.instance_members (user_id);
 CREATE INDEX idx_scene_instance_members_position ON scene.instance_members USING GIST (position);
 
 -- =============================================================================

db/schema/tables/050_chat.sql

@@ -28,9 +28,8 @@ CREATE TABLE chat.messages (
 
     instance_id UUID NOT NULL REFERENCES scene.instances(id) ON DELETE CASCADE,
 
-    -- Sender (either user or guest)
-    user_id UUID REFERENCES auth.users(id) ON DELETE SET NULL,
-    guest_session_id UUID REFERENCES auth.guest_sessions(id) ON DELETE SET NULL,
+    -- Sender (all users including guests - guests have 'guest' tag in auth.users)
+    user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE SET NULL,
 
     -- Cached sender info (in case account deleted)
     sender_name public.display_name NOT NULL,
@@ -51,13 +50,7 @@ CREATE TABLE chat.messages (
     deleted_at TIMESTAMPTZ,
 
     -- Timestamps
-    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-
-    -- Either user_id or guest_session_id must be set
-    CONSTRAINT chk_chat_messages_sender CHECK (
-        (user_id IS NOT NULL AND guest_session_id IS NULL) OR
-        (user_id IS NULL AND guest_session_id IS NOT NULL)
-    )
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 
 COMMENT ON TABLE chat.messages IS 'Instance messages (design supports future time-based partitioning)';

db/schema/triggers/002_user_init.sql

@@ -1,26 +0,0 @@
--- Chattyness User Initialization Trigger
--- PostgreSQL 18
---
--- Trigger to initialize new users with default props and avatar.
--- Load via: psql -f schema/triggers/002_user_init.sql
-
-\set ON_ERROR_STOP on
-
-BEGIN;
-
--- =============================================================================
--- User Registration Trigger
--- =============================================================================
--- Automatically initializes new users with default props and avatar
--- when they are inserted into auth.users.
--- =============================================================================
-
-CREATE TRIGGER trg_auth_users_initialize
-    AFTER INSERT ON auth.users
-    FOR EACH ROW
-    EXECUTE FUNCTION auth.initialize_new_user_trigger();
-
-COMMENT ON TRIGGER trg_auth_users_initialize ON auth.users IS
-    'Initialize new users with default props and avatar on registration';
-
-COMMIT;

db/schema/types/001_enums.sql

@@ -135,6 +135,21 @@ COMMENT ON TYPE server.filter_action IS 'Action to take when content filter matc
 -- Authentication Enums
 -- =============================================================================
 
+-- Gender preference for default avatar selection
+CREATE TYPE auth.gender_preference AS ENUM (
+    'gender_neutral',
+    'gender_male',
+    'gender_female'
+);
+COMMENT ON TYPE auth.gender_preference IS 'User gender preference for selecting default avatars';
+
+-- Age category for default avatar selection
+CREATE TYPE auth.age_category AS ENUM (
+    'child',
+    'adult'
+);
+COMMENT ON TYPE auth.age_category IS 'User age category for selecting default avatars';
+
 -- User account tags for feature gating and access control
 CREATE TYPE auth.user_tag AS ENUM (
     'guest',

e2e/test-results/.last-run.json

@@ -1,4 +0,0 @@
-{
-  "status": "passed",
-  "failedTests": []
-}

stock/load.sh

@@ -6,6 +6,9 @@
 # Options:
 #   --force, -f   Update existing assets instead of failing with 409 Conflict
 
+# Get script directory
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
 # Parse arguments
 FORCE_FLAG=""
 for arg in "$@"; do
@@ -16,5 +19,8 @@ for arg in "$@"; do
     esac
 done
 
-(cd avatar && ./upload-stockavatars.sh $FORCE_FLAG)
-(cd props && ./upload-stockprops.sh $FORCE_FLAG)
+(cd "$SCRIPT_DIR/avatar" && ./upload-stockavatars.sh $FORCE_FLAG)
+(cd "$SCRIPT_DIR/props" && ./upload-stockprops.sh $FORCE_FLAG)
+
+# Create stock avatar from uploaded props and set as default
+(cd "$SCRIPT_DIR/avatar" && ./create-stock-avatar.sh $FORCE_FLAG)