@mideind/netskrafl-react 1.6.1 → 1.7.1

package/dist/esm/index.js

@@ -1,8 +1,65 @@
 import { jsx } from 'react/jsx-runtime';
 import React, { useEffect } from 'react';
 
+const DEFAULT_STATE = {
+    projectId: "netskrafl",
+    firebaseApiKey: "",
+    databaseUrl: "",
+    firebaseSenderId: "",
+    firebaseAppId: "",
+    measurementId: "",
+    account: "",
+    userEmail: "",
+    userId: "",
+    userNick: "",
+    userFullname: "",
+    locale: "is_IS",
+    isExplo: false,
+    serverUrl: "",
+    movesUrl: "",
+    movesAccessKey: "",
+    token: "",
+    loginMethod: "",
+    subscriptionUrl: "",
+    newUser: false,
+    beginner: true,
+    fairPlay: false,
+    plan: "", // Not a friend
+    hasPaid: false,
+    audio: false,
+    fanfare: false,
+    ready: true,
+    readyTimed: true,
+    uiFullscreen: true,
+    uiLandscape: false,
+    runningLocal: false,
+};
+
 // Key for storing auth settings in sessionStorage
 const AUTH_SETTINGS_KEY = "netskrafl_auth_settings";
+const makeServerUrls = (backendUrl, movesUrl) => {
+    // If the last character of the url is a slash, cut it off,
+    // since path URLs always start with a slash
+    const cleanupUrl = (url) => {
+        if (url.length > 0 && url[url.length - 1] === "/") {
+            url = url.slice(0, -1);
+        }
+        return url;
+    };
+    return {
+        serverUrl: cleanupUrl(backendUrl),
+        movesUrl: cleanupUrl(movesUrl),
+    };
+};
+const makeGlobalState = (overrides) => {
+    const state = {
+        ...DEFAULT_STATE,
+        ...overrides,
+    };
+    const stateWithUrls = { ...state, ...makeServerUrls(state.serverUrl, state.movesUrl) };
+    // Apply any persisted authentication settings from sessionStorage
+    return applyPersistedSettings(stateWithUrls);
+};
 // Save authentication settings to sessionStorage
 const saveAuthSettings = (settings) => {
     if (!settings) {
@@ -31,6 +88,10 @@ const saveAuthSettings = (settings) => {
             filteredSettings.ready = settings.ready;
         if (settings.readyTimed !== undefined)
             filteredSettings.readyTimed = settings.readyTimed;
+        if (settings.audio !== undefined)
+            filteredSettings.audio = settings.audio;
+        if (settings.fanfare !== undefined)
+            filteredSettings.fanfare = settings.fanfare;
         // Only save if we have actual settings to persist
         if (Object.keys(filteredSettings).length > 1) {
             sessionStorage.setItem(AUTH_SETTINGS_KEY, JSON.stringify(filteredSettings));
@@ -69,7 +130,7 @@ const clearAuthSettings = () => {
 };
 // Apply persisted settings to a GlobalState object
 const applyPersistedSettings = (state) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f;
     const persisted = loadAuthSettings();
     if (!persisted) {
         return state;
@@ -95,64 +156,11 @@ const applyPersistedSettings = (state) => {
         fairPlay: (_b = persisted.fairPlay) !== null && _b !== void 0 ? _b : state.fairPlay,
         ready: (_c = persisted.ready) !== null && _c !== void 0 ? _c : state.ready,
         readyTimed: (_d = persisted.readyTimed) !== null && _d !== void 0 ? _d : state.readyTimed,
+        audio: (_e = persisted.audio) !== null && _e !== void 0 ? _e : state.audio,
+        fanfare: (_f = persisted.fanfare) !== null && _f !== void 0 ? _f : state.fanfare,
     };
 };
 
-const DEFAULT_STATE = {
-    projectId: "netskrafl",
-    firebaseApiKey: "",
-    databaseUrl: "",
-    firebaseSenderId: "",
-    firebaseAppId: "",
-    measurementId: "",
-    account: "",
-    userEmail: "",
-    userId: "",
-    userNick: "",
-    userFullname: "",
-    locale: "is_IS",
-    isExplo: false,
-    serverUrl: "",
-    movesUrl: "",
-    movesAccessKey: "",
-    token: "",
-    loginMethod: "",
-    subscriptionUrl: "",
-    newUser: false,
-    beginner: true,
-    fairPlay: false,
-    plan: "", // Not a friend
-    hasPaid: false,
-    ready: true,
-    readyTimed: true,
-    uiFullscreen: true,
-    uiLandscape: false,
-    runningLocal: false,
-};
-const makeServerUrls = (backendUrl, movesUrl) => {
-    // If the last character of the url is a slash, cut it off,
-    // since path URLs always start with a slash
-    const cleanupUrl = (url) => {
-        if (url.length > 0 && url[url.length - 1] === "/") {
-            url = url.slice(0, -1);
-        }
-        return url;
-    };
-    return {
-        serverUrl: cleanupUrl(backendUrl),
-        movesUrl: cleanupUrl(movesUrl),
-    };
-};
-const makeGlobalState = (overrides) => {
-    const state = {
-        ...DEFAULT_STATE,
-        ...overrides,
-    };
-    const stateWithUrls = { ...state, ...makeServerUrls(state.serverUrl, state.movesUrl) };
-    // Apply any persisted authentication settings from sessionStorage
-    return applyPersistedSettings(stateWithUrls);
-};
-
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -2533,6 +2541,133 @@ const ERROR_MESSAGES = {
     "server": "Netþjónn gat ekki tekið við leiknum - reyndu aftur"
 };
 
+/*
+
+  Audio.ts
+
+  Audio management service for Netskrafl/Explo
+
+  Copyright (C) 2025 Miðeind ehf.
+  Author: Vilhjálmur Þorsteinsson
+
+  The Creative Commons Attribution-NonCommercial 4.0
+  International Public License (CC-BY-NC 4.0) applies to this software.
+  For further information, see https://github.com/mideind/Netskrafl
+
+*/
+/**
+ * AudioManager handles preloading and playback of sound effects.
+ * It creates HTMLAudioElement instances for each sound and manages their lifecycle.
+ */
+class AudioManager {
+    constructor(state, soundUrls) {
+        this.sounds = new Map();
+        this.initialized = false;
+        // By default, sound URLs are based on /static on the backend server
+        const DEFAULT_SOUND_BASE = serverUrl(state, "/static");
+        const DEFAULT_SOUND_URLS = {
+            "your-turn": `${DEFAULT_SOUND_BASE}/your-turn.mp3`,
+            "you-win": `${DEFAULT_SOUND_BASE}/you-win.mp3`,
+            "new-msg": `${DEFAULT_SOUND_BASE}/new-msg.mp3`,
+        };
+        // Merge provided URLs with defaults
+        this.soundUrls = {
+            ...DEFAULT_SOUND_URLS,
+            ...(soundUrls || {}),
+        };
+    }
+    /**
+     * Initialize the audio manager by creating and preloading audio elements.
+     * This should be called once when the application starts.
+     */
+    initialize() {
+        if (this.initialized) {
+            return;
+        }
+        // Create audio elements for each sound
+        Object.entries(this.soundUrls).forEach(([soundId, url]) => {
+            const audio = new Audio(url);
+            audio.preload = "auto";
+            // Handle load errors gracefully - don't let them crash the app
+            audio.addEventListener("error", () => {
+                console.warn(`Failed to load audio: ${soundId} from ${url}`);
+            });
+            this.sounds.set(soundId, audio);
+        });
+        this.initialized = true;
+    }
+    /**
+     * Play a sound by its ID.
+     * If the sound is not loaded or fails to play, the error is logged but doesn't throw.
+     *
+     * @param soundId The identifier of the sound to play
+     */
+    play(soundId) {
+        if (!this.initialized) {
+            this.initialize();
+        }
+        const audio = this.sounds.get(soundId);
+        if (!audio) {
+            console.warn(`Audio not found: ${soundId}`);
+            return;
+        }
+        // Reset to start in case it's already playing
+        audio.currentTime = 0;
+        // Play the audio - catch any errors (e.g., user hasn't interacted with page yet)
+        audio.play().catch((err) => {
+            // This is expected in some cases (e.g., autoplay restrictions)
+            // so we just log it at debug level
+            if (err.name !== "NotAllowedError") {
+                console.warn(`Failed to play audio ${soundId}:`, err);
+            }
+        });
+    }
+    /**
+     * Update the URL for a specific sound.
+     * This will recreate the audio element with the new URL.
+     *
+     * @param soundId The identifier of the sound to update
+     * @param url The new URL for the sound
+     */
+    updateSoundUrl(soundId, url) {
+        this.soundUrls[soundId] = url;
+        // If already initialized, recreate this audio element
+        if (this.initialized) {
+            const audio = new Audio(url);
+            audio.preload = "auto";
+            audio.addEventListener("error", () => {
+                console.warn(`Failed to load audio: ${soundId} from ${url}`);
+            });
+            this.sounds.set(soundId, audio);
+        }
+    }
+    /**
+     * Dispose of all audio elements and clean up resources.
+     */
+    dispose() {
+        this.sounds.forEach((audio) => {
+            audio.pause();
+            audio.src = "";
+        });
+        this.sounds.clear();
+        this.initialized = false;
+    }
+}
+// Global singleton instance
+let audioManager = null;
+/**
+ * Get or create the global AudioManager instance.
+ *
+ * @param soundUrls Optional custom sound URLs (only used on first call)
+ * @returns The global AudioManager instance
+ */
+function getAudioManager(state, soundUrls) {
+    if (!audioManager) {
+        audioManager = new AudioManager(state, soundUrls);
+    }
+    return audioManager;
+}
+
 /*
 
   Util.ts
@@ -2689,11 +2824,10 @@ function setInput(id, val) {
     const elem = document.getElementById(id);
     elem.value = val;
 }
-function playAudio(elemId) {
-    // Play an audio file
-    const sound = document.getElementById(elemId);
-    if (sound)
-        sound.play();
+function playAudio(state, soundId) {
+    // Play an audio file using the AudioManager
+    const audioManager = getAudioManager(state);
+    audioManager.play(soundId);
 }
 function arrayEqual(a, b) {
     // Return true if arrays a and b are equal
@@ -27230,6 +27364,19 @@ let app;
 let auth;
 let database;
 let analytics;
+// Queue of callbacks to execute when database is ready
+let databaseReadyQueue = [];
+/**
+ * Execute all queued callbacks now that database is ready
+ */
+function flushDatabaseReadyQueue(state) {
+    var _a;
+    const queue = [...databaseReadyQueue];
+    databaseReadyQueue = []; // Clear queue before executing to avoid re-queuing
+    queue.forEach(callback => callback());
+    // Also notify the global callback if set
+    (_a = state.onFirebaseReady) === null || _a === void 0 ? void 0 : _a.call(state);
+}
 function initFirebase(state) {
     try {
         const { projectId, firebaseApiKey, databaseUrl, firebaseSenderId, firebaseAppId, measurementId } = state;
@@ -27264,9 +27411,30 @@ function isFirebaseAuthenticated(state) {
         if (app)
             auth = getAuth(app);
     }
-    if (!auth)
+    if (!auth || auth.currentUser === null) {
         return false;
-    return auth.currentUser !== null;
+    }
+    // If auth is valid but database not initialized, initialize it
+    // This handles the case where the user has cached auth but returns
+    // directly to a route that needs Firebase Database (e.g., Gáta Dagsins)
+    if (!database && app) {
+        database = getDatabase(app);
+        if (!database) {
+            console.error("Failed to initialize Firebase Database");
+            return false;
+        }
+        // Database initialized successfully - flush queued callbacks
+        flushDatabaseReadyQueue(state);
+        // Also initialize analytics if not already done
+        if (!analytics) {
+            analytics = getAnalytics(app);
+            if (!analytics) {
+                console.error("Failed to initialize Firebase Analytics");
+                // We don't return false here since analytics is not critical
+            }
+        }
+    }
+    return true;
 }
 async function loginFirebase(state, firebaseToken, onLoginFunc) {
     if (!app && !initFirebase(state))
@@ -27304,6 +27472,10 @@ async function loginFirebase(state, firebaseToken, onLoginFunc) {
     if (!database) {
         console.error("Failed to initialize Firebase Database");
     }
+    else {
+        // Database initialized successfully - flush queued callbacks
+        flushDatabaseReadyQueue(state);
+    }
     analytics = getAnalytics(app);
     if (!analytics) {
         console.error("Failed to initialize Firebase Analytics");
@@ -27335,8 +27507,12 @@ function initPresence(projectId, userId, locale) {
 }
 function attachFirebaseListener(path, func) {
     // Attach a message listener to a Firebase path
-    if (!database)
+    // console.log(`attachFirebaseListener(${path})`);
+    if (!database) {
+        // Database not ready yet - queue this attachment for later
+        databaseReadyQueue.push(() => attachFirebaseListener(path, func));
         return;
+    }
     let cnt = 0;
     const pathRef = ref(database, path);
     onValue(pathRef, function (snapshot) {
@@ -27353,8 +27529,10 @@ function attachFirebaseListener(path, func) {
 }
 function detachFirebaseListener(path) {
     // Detach a message listener from a Firebase path
-    if (!database)
+    // console.log(`detachFirebaseListener(${path})`);
+    if (!database) {
         return;
+    }
     const pathRef = ref(database, path);
     off(pathRef);
 }
@@ -27373,63 +27551,178 @@ async function getFirebaseData(path) {
     return snapshot.val();
 }
 
-// Global state for authentication
+// ============================================================================
+// Configuration constants for login protection
+// ============================================================================
+// Maximum number of login attempts before giving up
+const MAX_LOGIN_RETRIES = 3;
+// Minimum time between login attempts (milliseconds) - prevents rapid-fire retries
+const MIN_LOGIN_INTERVAL_MS = 500;
+// Initial backoff delay for retries (milliseconds) - doubles each retry
+const INITIAL_BACKOFF_MS = 500;
+// Maximum backoff delay (milliseconds) - caps exponential growth
+const MAX_BACKOFF_MS = 5000;
+// Circuit breaker timeout (milliseconds) - how long to wait after max retries
+const CIRCUIT_BREAKER_TIMEOUT_MS = 2 * 60 * 1000; // 2 minutes
+// ============================================================================
+// Global state for authentication and retry protection
+// ============================================================================
+// Active login promise - prevents concurrent login attempts
 let authPromise = null;
-// Custom error class for authentication failures
+// Retry tracking
+let loginAttemptCount = 0;
+let lastLoginAttemptTime = 0;
+// Circuit breaker state
+let circuitBreakerOpen = false;
+let circuitBreakerResetTime = 0;
+// ============================================================================
+// Custom error classes
+// ============================================================================
 class AuthenticationError extends Error {
     constructor() {
         super("Authentication required");
         this.name = "AuthenticationError";
     }
 }
-// Internal function to ensure authentication
+class LoginThrottledError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "LoginThrottledError";
+    }
+}
+// ============================================================================
+// Helper functions
+// ============================================================================
+/**
+ * Delays execution for the specified number of milliseconds
+ */
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/**
+ * Calculates exponential backoff delay based on attempt number
+ */
+const calculateBackoff = (attemptNumber) => {
+    const backoff = INITIAL_BACKOFF_MS * Math.pow(2, attemptNumber - 1);
+    return Math.min(backoff, MAX_BACKOFF_MS);
+};
+/**
+ * Resets all retry and circuit breaker state to initial values
+ */
+const resetLoginState = () => {
+    loginAttemptCount = 0;
+    circuitBreakerOpen = false;
+    circuitBreakerResetTime = 0;
+};
+/**
+ * Opens the circuit breaker to prevent further login attempts
+ */
+const openCircuitBreaker = () => {
+    circuitBreakerOpen = true;
+    circuitBreakerResetTime = Date.now() + CIRCUIT_BREAKER_TIMEOUT_MS;
+    loginAttemptCount = 0;
+    console.error(`Circuit breaker opened. Login attempts blocked until ${new Date(circuitBreakerResetTime).toLocaleTimeString()}`);
+};
+/**
+ * Checks if circuit breaker should be reset based on timeout
+ */
+const checkCircuitBreakerReset = () => {
+    if (circuitBreakerOpen && Date.now() >= circuitBreakerResetTime) {
+        resetLoginState();
+    }
+};
+// ============================================================================
+// Authentication flow
+// ============================================================================
+/**
+ * Internal function to ensure authentication with comprehensive retry protection
+ *
+ * Protection mechanisms:
+ * - Circuit breaker: Stops all attempts after max retries for a cooldown period
+ * - Retry limits: Maximum number of consecutive failed attempts
+ * - Exponential backoff: Increasing delays between retries
+ * - Rate limiting: Minimum time between attempts
+ * - Request deduplication: Only one login attempt at a time
+ */
 const ensureAuthenticated = async (state) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+    // Check and potentially reset circuit breaker
+    checkCircuitBreakerReset();
+    // Circuit breaker check - fail fast if too many recent failures
+    if (circuitBreakerOpen) {
+        const waitMinutes = Math.ceil((circuitBreakerResetTime - Date.now()) / 60000);
+        throw new LoginThrottledError(`Too many failed login attempts. Please wait ${waitMinutes} minute(s) before trying again.`);
+    }
     // If login is already in progress, wait for it to complete
     if (authPromise) {
         await authPromise;
         return;
     }
+    // Rate limiting - prevent rapid-fire retries
+    const timeSinceLastAttempt = Date.now() - lastLoginAttemptTime;
+    if (timeSinceLastAttempt < MIN_LOGIN_INTERVAL_MS && loginAttemptCount > 0) {
+        console.warn(`Login attempt too soon (${timeSinceLastAttempt}ms since last attempt)`);
+        throw new LoginThrottledError("Please wait a moment before trying again.");
+    }
+    // Retry loop with exponential backoff
     let continueTrying = true;
-    while (continueTrying) {
+    while (continueTrying && loginAttemptCount < MAX_LOGIN_RETRIES) {
         continueTrying = false;
-        // Start new login attempt (either forced by 401 or needed for Firebase)
+        loginAttemptCount++;
+        lastLoginAttemptTime = Date.now();
+        // Apply exponential backoff for retries (skip delay on first attempt)
+        if (loginAttemptCount >= 2) {
+            const backoffMs = calculateBackoff(loginAttemptCount - 1);
+            console.warn(`Login retry ${loginAttemptCount}/${MAX_LOGIN_RETRIES}, waiting ${backoffMs}ms...`);
+            await delay(backoffMs);
+        }
+        // Start new login attempt
         authPromise = loginUserByEmail(state);
         try {
             const result = await authPromise;
+            // Handle expired token
             if (result.status === "expired") {
-                // Token has expired, notify the React component if callback is set
                 if (state.tokenExpired) {
-                    // We have a callback to renew the token: do it and try again
-                    state.tokenExpired();
-                    continueTrying = true; // Try logging in again
-                    clearAuthSettings();
-                    continue;
+                    // Token refresh callback is available
+                    try {
+                        // Call the token refresh callback
+                        state.tokenExpired();
+                        continueTrying = true;
+                        clearAuthSettings();
+                        continue;
+                    }
+                    catch (error) {
+                        console.error("Token refresh failed:", error);
+                        clearAuthSettings();
+                        throw new Error(`Failed to refresh authentication token: ${error instanceof Error ? error.message : String(error)}`);
+                    }
                 }
-                // Clear any persisted settings since they're no longer valid
+                // No refresh callback available
                 clearAuthSettings();
-                throw new Error("Authentication token has expired");
+                throw new Error("Authentication token has expired. Please log in again.");
             }
-            else if (result.status !== "success") {
-                // Clear any persisted settings on auth failure
+            // Handle other non-success statuses
+            if (result.status !== "success") {
                 clearAuthSettings();
                 throw new Error(`Authentication failed: ${result.message || result.status}`);
             }
+            // ========================================================================
+            // Success! Update global state and persist authentication
+            // ========================================================================
             // Update the user's ID to the internal one used by the backend and Firebase
             state.userId = result.user_id || state.userId;
             state.account = result.account || state.userId;
-            // Update the user's nickname
             state.userNick = result.nickname || state.userNick;
-            // Use the server's Firebase API key, if provided
             state.firebaseApiKey = result.firebase_api_key || state.firebaseApiKey;
             // Load state flags and preferences
             state.beginner = (_b = (_a = result.prefs) === null || _a === void 0 ? void 0 : _a.beginner) !== null && _b !== void 0 ? _b : true;
             state.fairPlay = (_d = (_c = result.prefs) === null || _c === void 0 ? void 0 : _c.fairplay) !== null && _d !== void 0 ? _d : false;
             state.ready = (_f = (_e = result.prefs) === null || _e === void 0 ? void 0 : _e.ready) !== null && _f !== void 0 ? _f : true;
             state.readyTimed = (_h = (_g = result.prefs) === null || _g === void 0 ? void 0 : _g.ready_timed) !== null && _h !== void 0 ? _h : true;
-            // Save the authentication settings to sessionStorage for persistence
+            state.audio = (_k = (_j = result.prefs) === null || _j === void 0 ? void 0 : _j.audio) !== null && _k !== void 0 ? _k : false;
+            state.fanfare = (_m = (_l = result.prefs) === null || _l === void 0 ? void 0 : _l.fanfare) !== null && _m !== void 0 ? _m : false;
+            state.hasPaid = (_p = (_o = result.prefs) === null || _o === void 0 ? void 0 : _o.haspaid) !== null && _p !== void 0 ? _p : false;
+            // Save authentication settings to sessionStorage
             saveAuthSettings({
-                userEmail: state.userEmail, // CRITICAL: Include email to validate ownership
+                userEmail: state.userEmail,
                 userId: state.userId,
                 userNick: state.userNick,
                 firebaseApiKey: state.firebaseApiKey,
@@ -27437,18 +27730,39 @@ const ensureAuthenticated = async (state) => {
                 fairPlay: state.fairPlay,
                 ready: state.ready,
                 readyTimed: state.readyTimed,
+                audio: state.audio,
+                fanfare: state.fanfare,
             });
-            // Be sure to redraw Mithril components after authentication;
-            // user info may have changed
+            // Redraw UI to reflect authentication changes
             m.redraw();
-            // Success: Log in to Firebase with the token passed from the server
+            // Log in to Firebase with the token from server
             await loginFirebase(state, result.firebase_token);
+            // Success - reset all retry state
+            resetLoginState();
+        }
+        catch (error) {
+            // On last retry, open circuit breaker
+            if (loginAttemptCount >= MAX_LOGIN_RETRIES) {
+                openCircuitBreaker();
+                throw new Error(`Login failed after ${MAX_LOGIN_RETRIES} attempts. ` +
+                    `Please wait ${Math.ceil(CIRCUIT_BREAKER_TIMEOUT_MS / 60000)} minutes before trying again.`);
+            }
+            // Re-throw error if we're not retrying
+            if (!continueTrying) {
+                throw error;
+            }
+            // Continue to next retry iteration
         }
         finally {
-            // Reset the promise so future 401s can trigger a new login
+            // Reset the promise so future attempts can proceed
             authPromise = null;
         }
     }
+    // Should not reach here, but handle max retries edge case
+    if (loginAttemptCount >= MAX_LOGIN_RETRIES) {
+        openCircuitBreaker();
+        throw new Error("Maximum login attempts exceeded. Please try again later.");
+    }
 };
 // Internal authenticated request function
 const authenticatedRequest = async (state, options, retries = 0) => {
@@ -27696,43 +28010,49 @@ const UserInfoButton = {
         }, isRobot ? "" : m("span.usr-info"));
     }
 };
-const OnlinePresence = (initialVnode) => {
+const OnlinePresence = {
     // Shows an icon in grey or green depending on whether a given user
     // is online or not. If attrs.online is given (i.e. not undefined),
     // that value is used and displayed; otherwise the server is asked.
-    const attrs = initialVnode.attrs;
-    let online = attrs.online ? true : false;
-    const askServer = attrs.online === undefined;
-    const id = attrs.id;
-    const userId = attrs.userId;
-    const state = attrs.state;
-    let loading = false;
-    async function _update() {
-        if (askServer && !loading) {
-            loading = true;
-            const json = await request(state, {
-                method: "POST",
-                url: "/onlinecheck",
-                body: { user: userId }
-            });
-            online = json && json.online;
-            loading = false;
+    oninit: (vnode) => {
+        const { state } = vnode;
+        state.online = false;
+    },
+    oncreate: (vnode) => {
+        // Note: we must use a two-step initialization here,
+        // calling oninit() first and then oncreate(), since calls to
+        // m.redraw() - explicit or implicit via m.request() - from within
+        // oninit() will cause a recursive call to oninit(), resulting in
+        // a double API call to the backend.
+        const { attrs, state } = vnode;
+        state.online = !!attrs.online;
+        if (attrs.online === undefined) {
+            // We need to ask the server for the online status
+            const askServer = async () => {
+                try {
+                    const json = await request(attrs.state, {
+                        method: "POST",
+                        url: "/onlinecheck",
+                        body: { user: attrs.userId }
+                    });
+                    state.online = json && json.online;
+                }
+                catch (e) {
+                    state.online = false;
+                }
+            };
+            askServer(); // Fire-and-forget
         }
+    },
+    view: (vnode) => {
+        const { attrs, state } = vnode;
+        const online = state.online || (!!attrs.online);
+        return m("span", {
+            id: attrs.id,
+            title: online ? ts("Er álínis") : ts("Álínis?"),
+            class: online ? "online" : ""
+        });
     }
-    return {
-        oninit: _update,
-        view: (vnode) => {
-            var _a, _b;
-            if (!askServer)
-                // Display the state of the online attribute as-is
-                online = (_b = (_a = vnode.attrs) === null || _a === void 0 ? void 0 : _a.online) !== null && _b !== void 0 ? _b : false;
-            return m("span", {
-                id: id,
-                title: online ? ts("Er álínis") : ts("Álínis?"),
-                class: online ? "online" : ""
-            });
-        }
-    };
 };
 const UserId = {
     // User identifier at top right, opens user preferences
@@ -27905,11 +28225,12 @@ const TogglerReadyTimed = (initialVnode) => {
         }
     };
 };
-const TogglerAudio = () => {
+const TogglerAudio = (initialVnode) => {
     // Toggle for audio on/off
+    const { model } = initialVnode.attrs.view;
     function toggleFunc(state) {
-        if (state)
-            playAudio("your-turn");
+        if (state && model.state !== null)
+            playAudio(model.state, "your-turn");
     }
     return {
         view: ({ attrs: { state, tabindex } }) => m(Toggler, {
@@ -27924,11 +28245,12 @@ const TogglerAudio = () => {
         })
     };
 };
-const TogglerFanfare = () => {
+const TogglerFanfare = (initialVnode) => {
     // Toggle for fanfare on/off
+    const { model } = initialVnode.attrs.view;
     function toggleFunc(state) {
-        if (state)
-            playAudio("you-win");
+        if (state && model.state !== null)
+            playAudio(model.state, "you-win");
     }
     return {
         view: ({ attrs: { state, tabindex } }) => m(Toggler, {
@@ -27985,146 +28307,148 @@ const TogglerFairplay = () => {
   For further information, see https://github.com/mideind/Netskrafl
 
 */
-const WaitDialog = (initialVnode) => {
+const WaitDialog = {
     // A dialog that is shown while the user waits for the opponent,
     // who issued a timed game challenge, to be ready
-    var _a, _b;
-    const attrs = initialVnode.attrs;
-    const view = attrs.view;
-    const model = view.model;
-    const state = model.state;
-    const duration = attrs.duration;
-    const oppId = attrs.oppId;
-    const key = attrs.challengeKey;
-    let oppNick = attrs.oppNick;
-    let oppName = attrs.oppName;
-    let oppOnline = false;
-    const userId = (_b = (_a = model.state) === null || _a === void 0 ? void 0 : _a.userId) !== null && _b !== void 0 ? _b : "";
-    // Firebase path
-    const path = 'user/' + userId + "/wait/" + oppId;
-    // Flag set when the new game has been initiated
-    let pointOfNoReturn = false;
-    let initialized = false;
-    async function updateOnline() {
-        // Initiate an online check on the opponent
-        try {
-            if (!oppId || !key || !state)
-                return;
-            const json = await request(state, {
-                method: "POST",
-                url: "/initwait",
-                body: { opp: oppId, key }
-            });
-            // If json.waiting is false, the initiation failed
-            // and there is really no point in continuing to wait
-            if (json && json.online && json.waiting)
-                // The user is online
-                oppOnline = true;
-        }
-        catch (e) {
-        }
-    }
-    async function cancelWait() {
-        // Cancel a pending wait for a timed game
-        if (!state)
-            return;
-        try {
-            await request(state, {
-                method: "POST",
-                url: "/cancelwait",
-                body: {
-                    user: userId,
-                    opp: oppId,
-                    key
-                }
-            });
-        }
-        catch (e) {
-        }
-    }
-    const oncreate = async () => {
-        if (!userId || !oppId || initialized)
+    oninit: (vnode) => {
+        const { state } = vnode;
+        state.oppOnline = false;
+        state.pointOfNoReturn = false;
+        state.firebasePath = "";
+    },
+    oncreate: (vnode) => {
+        var _a, _b;
+        // Note: we must use a two-step initialization here,
+        // calling oninit() first and then oncreate(), since calls to
+        // m.redraw() - explicit or implicit via m.request() - from within
+        // oninit() will cause a recursive call to oninit(), resulting in
+        // a double API call to the backend.
+        const { attrs, state } = vnode;
+        const { view, oppId, challengeKey: key } = attrs;
+        const { model } = view;
+        const globalState = model.state;
+        const userId = (_b = (_a = model.state) === null || _a === void 0 ? void 0 : _a.userId) !== null && _b !== void 0 ? _b : "";
+        if (!userId || !oppId)
             return; // Should not happen
-        initialized = true;
-        updateOnline();
+        state.firebasePath = `user/${userId}/wait/${oppId}`;
+        // Initiate an online check on the opponent (fire-and-forget)
+        const updateOnline = async () => {
+            try {
+                if (key && globalState) {
+                    const json = await request(globalState, {
+                        method: "POST",
+                        url: "/initwait",
+                        body: { opp: oppId, key }
+                    });
+                    // If json.waiting is false, the initiation failed
+                    // and there is really no point in continuing to wait
+                    if (json && json.online && json.waiting) {
+                        // The user is online
+                        state.oppOnline = true;
+                    }
+                }
+            }
+            catch (e) {
+            }
+        };
+        updateOnline(); // Fire-and-forget, don't await
         // Attach a Firebase listener to the wait path
-        attachFirebaseListener(path, (json) => {
+        attachFirebaseListener(state.firebasePath, (json) => {
             if (json !== true && json.game) {
                 // A new game has been created and initiated by the server
-                pointOfNoReturn = true;
-                detachFirebaseListener(path);
+                state.pointOfNoReturn = true;
+                detachFirebaseListener(state.firebasePath);
                 // We don't need to pop the dialog; that is done automatically
                 // by the route resolver upon m.route.set()
                 // Navigate to the newly initiated game
                 m.route.set("/game/" + json.game);
             }
         });
-    };
-    return {
-        oncreate,
-        view: () => {
-            if (!state)
-                return null;
-            return m(".modal-dialog", { id: "wait-dialog", style: { visibility: "visible" } }, m(".ui-widget.ui-widget-content.ui-corner-all", { "id": "wait-form" }, [
-                m(".chall-hdr", m("table", m("tbody", m("tr", [
-                    m("td", m("h1.chall-icon", glyph("time"))),
-                    m("td.l-border", [
-                        m(OnlinePresence, { id: "chall-online", userId: oppId, online: oppOnline, state }),
-                        m("h1", oppNick),
-                        m("h2", oppName)
-                    ])
-                ])))),
-                m(".wait-explain", [
-                    mt("p", [
-                        "Þú ert reiðubúin(n) að taka áskorun um viðureign með klukku, ",
-                        m("strong", ["2 x ", duration.toString(), ts(" mínútur.")])
-                    ]),
-                    mt("p", [
-                        "Beðið er eftir að áskorandinn ", m("strong", oppNick),
-                        " sé ", oppOnline ? "" : mt("span#chall-is-online", "álínis og "), "til í tuskið."
-                    ]),
-                    mt("p", "Leikur hefst um leið og áskorandinn bregst við. Handahóf ræður hvor byrjar."),
-                    mt("p", "Ef þér leiðist biðin geturðu hætt við og reynt aftur síðar.")
+    },
+    view: (vnode) => {
+        var _a, _b;
+        const { attrs, state } = vnode;
+        const { view, oppId, duration, challengeKey: key, oppNick, oppName } = attrs;
+        const { model } = view;
+        const globalState = model.state;
+        const userId = (_b = (_a = model.state) === null || _a === void 0 ? void 0 : _a.userId) !== null && _b !== void 0 ? _b : "";
+        if (!globalState)
+            return null;
+        const cancelWait = async () => {
+            // Cancel a pending wait for a timed game
+            if (!globalState)
+                return;
+            try {
+                request(globalState, {
+                    method: "POST",
+                    url: "/cancelwait",
+                    body: {
+                        user: userId,
+                        opp: oppId,
+                        key
+                    }
+                });
+            }
+            catch (e) {
+            }
+        };
+        return m(".modal-dialog", { id: "wait-dialog", style: { visibility: "visible" } }, m(".ui-widget.ui-widget-content.ui-corner-all", { "id": "wait-form" }, [
+            m(".chall-hdr", m("table", m("tbody", m("tr", [
+                m("td", m("h1.chall-icon", glyph("time"))),
+                m("td.l-border", [
+                    m(OnlinePresence, { id: "chall-online", userId: oppId, online: state.oppOnline, state: globalState }),
+                    m("h1", oppNick),
+                    m("h2", oppName),
+                ])
+            ])))),
+            m(".wait-explain", [
+                mt("p", [
+                    "Þú ert reiðubúin(n) að taka áskorun um viðureign með klukku,",
                 ]),
-                m(DialogButton, {
-                    id: "wait-cancel",
-                    title: ts("Hætta við"),
-                    onclick: (ev) => {
-                        // Cancel the wait status and navigate back to the main page
-                        if (pointOfNoReturn) {
-                            // Actually, it's too late to cancel
-                            ev.preventDefault();
-                            return;
-                        }
-                        detachFirebaseListener(path);
-                        cancelWait();
-                        view.popDialog();
+                m("p", [
+                    m("strong", ["2 x ", duration.toString(), ts(" mínútur.")])
+                ]),
+                mt("p", [
+                    "Beðið er eftir að áskorandinn ", m("strong", oppNick),
+                    " sé ", state.oppOnline ? "" : mt("span#chall-is-online", "álínis og "), "til í tuskið."
+                ]),
+                mt("p", "Leikur hefst um leið og áskorandinn bregst við. Handahóf ræður hvor byrjar."),
+                mt("p", "Ef þér leiðist biðin geturðu hætt við og reynt aftur síðar.")
+            ]),
+            m(DialogButton, {
+                id: "wait-cancel",
+                title: ts("Hætta við"),
+                onclick: (ev) => {
+                    // Cancel the wait status and navigate back to the main page
+                    if (state.pointOfNoReturn) {
+                        // Actually, it's too late to cancel
                         ev.preventDefault();
+                        return;
                     }
-                }, glyph("remove"))
-            ]));
-        }
-    };
+                    if (state.firebasePath)
+                        detachFirebaseListener(state.firebasePath);
+                    cancelWait();
+                    view.popDialog();
+                    ev.preventDefault();
+                }
+            }, glyph("remove"))
+        ]));
+    }
 };
-const AcceptDialog = (initialVnode) => {
+const AcceptDialog = {
     // A dialog that is shown (usually briefly) while
     // the user who originated a timed game challenge
     // is linked up with her opponent and a new game is started
-    const attrs = initialVnode.attrs;
-    const view = attrs.view;
-    const state = view.model.state;
-    const oppId = attrs.oppId;
-    const key = attrs.challengeKey;
-    let oppNick = attrs.oppNick;
-    let oppReady = true;
-    let loading = false;
-    async function waitCheck() {
+    oninit: async (vnode) => {
+        const { attrs, state } = vnode;
+        const { view, oppId, challengeKey: key } = attrs;
+        const globalState = view.model.state;
+        if (!globalState)
+            return; // Should not happen
+        state.oppReady = true;
         // Initiate a wait status check on the opponent
-        if (loading || !state)
-            return; // Already checking
-        loading = true;
         try {
-            const json = await request(state, {
+            const json = await request(globalState, {
                 method: "POST",
                 url: "/waitcheck",
                 body: { user: oppId, key }
@@ -28135,42 +28459,40 @@ const AcceptDialog = (initialVnode) => {
                 // and all open dialogs are thereby closed automatically.
                 view.actions.startNewGame(oppId, true);
             }
-            else
+            else {
                 // Something didn't check out: keep the dialog open
                 // until the user manually closes it
-                oppReady = false;
+                state.oppReady = false;
+            }
         }
         catch (e) {
+            state.oppReady = false;
         }
-        finally {
-            loading = false;
-        }
+    },
+    view: (vnode) => {
+        const { attrs, state } = vnode;
+        const { view, oppNick } = attrs;
+        return m(".modal-dialog", { id: "accept-dialog", style: { visibility: "visible" } }, m(".ui-widget.ui-widget-content.ui-corner-all", { id: "accept-form" }, [
+            m(".chall-hdr", m("table", m("tbody", m("tr", [
+                m("td", m("h1.chall-icon", glyph("time"))),
+                m("td.l-border", m("h1", oppNick))
+            ])))),
+            m("div", { "style": { "text-align": "center", "padding-top": "32px" } }, [
+                m("p", mt("strong", "Viðureign með klukku")),
+                mt("p", state.oppReady ? "Athuga hvort andstæðingur er reiðubúinn..."
+                    : ["Andstæðingurinn ", m("strong", oppNick), " er ekki reiðubúinn"])
+            ]),
+            m(DialogButton, {
+                id: 'accept-cancel',
+                title: ts('Reyna síðar'),
+                onclick: (ev) => {
+                    // Abort mission
+                    view.popDialog();
+                    ev.preventDefault();
+                }
+            }, glyph("remove"))
+        ]));
     }
-    return {
-        oninit: waitCheck,
-        view: () => {
-            return m(".modal-dialog", { id: "accept-dialog", style: { visibility: "visible" } }, m(".ui-widget.ui-widget-content.ui-corner-all", { id: "accept-form" }, [
-                m(".chall-hdr", m("table", m("tbody", m("tr", [
-                    m("td", m("h1.chall-icon", glyph("time"))),
-                    m("td.l-border", m("h1", oppNick))
-                ])))),
-                m("div", { "style": { "text-align": "center", "padding-top": "32px" } }, [
-                    m("p", mt("strong", "Viðureign með klukku")),
-                    mt("p", oppReady ? "Athuga hvort andstæðingur er reiðubúinn..."
-                        : ["Andstæðingurinn ", m("strong", oppNick), " er ekki reiðubúinn"])
-                ]),
-                m(DialogButton, {
-                    id: 'accept-cancel',
-                    title: ts('Reyna síðar'),
-                    onclick: (ev) => {
-                        // Abort mission
-                        view.popDialog();
-                        ev.preventDefault();
-                    }
-                }, glyph("remove"))
-            ]));
-        }
-    };
 };
 
 /*
@@ -29075,8 +29397,7 @@ class Game extends BaseGame {
             // Ongoing timed game: start the clock
             this.startClock();
         // Kick off loading of chat messages, if this is not a robot game
-        const isHumanGame = !this.autoplayer[0] && !this.autoplayer[1];
-        if (isHumanGame)
+        if (!this.isRobotGame())
             this.loadMessages();
     }
     init(srvGame) {
@@ -29234,6 +29555,8 @@ class Game extends BaseGame {
         // Update the srvGame state with data from the server,
         // either after submitting a move to the server or
         // after receiving a move notification via the Firebase listener
+        // Remember if the game was already won before this update
+        const wasWon = this.congratulate;
         // Stop highlighting the previous opponent move, if any
         for (let sq in this.tiles)
             if (this.tiles.hasOwnProperty(sq))
@@ -29254,6 +29577,10 @@ class Game extends BaseGame {
             // The call to resetClock() clears any outstanding interval timers
             // if the srvGame is now over
             this.resetClock();
+        // Notify the move listener if the game just transitioned to won
+        if (!wasWon && this.congratulate && this.moveListener) {
+            this.moveListener.notifyGameWon();
+        }
     }
     ;
     async refresh() {
@@ -29458,6 +29785,10 @@ class Game extends BaseGame {
         // actual game score minus accrued time penalty, if any, in a timed game
         return Math.max(this.scores[player] + (player === 0 ? this.penalty0 : this.penalty1), 0);
     }
+    isRobotGame() {
+        // Return true if any player in the game is a robot
+        return this.autoplayer[0] || this.autoplayer[1];
+    }
     async loadMessages() {
         // Load chat messages for this game
         if (this.chatLoading)
@@ -30942,60 +31273,48 @@ class Model {
         }
         return false;
     }
-    handleUserMessage(json, firstAttach) {
-        // Handle an incoming Firebase user message, i.e. a message
-        // on the /user/[userid] path
+    handleUserChallengeMessage(json, firstAttach) {
+        // Handle an incoming Firebase user challenge message,
+        // i.e. a message on the /user/[userid]/challenge path
         if (firstAttach || !this.state || !json)
             return;
-        let redraw = false;
-        if (typeof json.plan === "string") {
-            // Potential change of user subscription plan
-            if (this.state.plan !== json.plan) {
-                this.state.plan = json.plan;
-                redraw = true;
-            }
-        }
-        if (json.hasPaid !== undefined) {
-            // Potential change of payment status
-            const newHasPaid = (this.state.plan !== "" && json.hasPaid) ? true : false;
-            if (this.state.hasPaid !== newHasPaid) {
-                this.state.hasPaid = newHasPaid;
-                redraw = true;
-            }
-        }
-        let invalidateGameList = false;
-        // The following code is a bit iffy since both json.challenge and json.move
-        // are included in the same message on the /user/[userid] path.
-        // !!! FIXME: Split this into two separate listeners,
-        // !!! one for challenges and one for moves
-        if (json.challenge) {
-            // Reload challenge list
-            this.loadChallengeList();
-            if (this.userListCriteria)
-                // We are showing a user list: reload it
-                this.loadUserList(this.userListCriteria);
-            // Reload game list
-            // !!! FIXME: It is strictly speaking not necessary to reload
-            // !!! the game list unless this is an acceptance of a challenge
-            // !!! (issuance or rejection don't cause the game list to change)
-            invalidateGameList = true;
-        }
-        else if (json.move) {
-            // A move has been made in one of this user's games:
-            // invalidate the game list (will be loaded upon next display)
-            invalidateGameList = true;
-        }
-        if (invalidateGameList && !this.loadingGameList) {
+        // Reload challenge list
+        this.loadChallengeList();
+        if (this.userListCriteria)
+            // We are showing a user list: reload it
+            this.loadUserList(this.userListCriteria);
+        // Reload game list
+        // !!! FIXME: It is strictly speaking not necessary to reload
+        // !!! the game list unless this is an acceptance of a challenge
+        // !!! (issuance or rejection don't cause the game list to change)
+        if (!this.loadingGameList) {
             this.gameList = null;
-            redraw = true;
         }
-        if (redraw)
+        m.redraw();
+    }
+    handleUserMoveMessage(json, firstAttach) {
+        // Handle an incoming Firebase user move message,
+        // i.e. a message on the /user/[userid]/move path
+        if (firstAttach || !this.state || !json)
+            return;
+        // A move has been made in one of this user's games:
+        // invalidate the game list (will be loaded upon next display)
+        if (!this.loadingGameList) {
+            this.gameList = null;
             m.redraw();
+        }
     }
     handleMoveMessage(json, firstAttach) {
         // Handle an incoming Firebase move message
         if (!firstAttach && this.game) {
             this.game.update(json);
+            // Play "your turn" audio notification if:
+            // - User has audio enabled
+            // - User is a participant in the game
+            // - This is not a robot game (robots reply instantly anyway)
+            if (this.state.audio && this.game.player !== null && !this.game.isRobotGame()) {
+                playAudio(this.state, "your-turn");
+            }
             m.redraw();
         }
     }
@@ -31006,6 +31325,14 @@ class Model {
             this.gameList = null;
         }
     }
+    notifyGameWon() {
+        var _a;
+        // The user just won a game:
+        // play the "you-win" audio if fanfare is enabled
+        if ((_a = this.user) === null || _a === void 0 ? void 0 : _a.fanfare) {
+            playAudio(this.state, "you-win");
+        }
+    }
     moreGamesAllowed() {
         // Return true if the user is allowed to have more games ongoing
         if (!this.state)
@@ -32428,117 +32755,128 @@ const Main = () => {
   For further information, see https://github.com/mideind/Netskrafl
 
 */
-const UserInfoDialog = (initialVnode) => {
+const _updateStats = (attrs, state) => {
+    // Fetch the statistics of the given user
+    if (state.loadingStats)
+        return;
+    state.loadingStats = true;
+    const { model } = attrs.view;
+    model.loadUserStats(attrs.userid, (json) => {
+        if (json && json.result === 0)
+            state.stats = json;
+        else
+            state.stats = {};
+        state.loadingStats = false;
+        // m.redraw();
+    });
+};
+const _updateRecentList = (attrs, state) => {
+    var _a, _b;
+    // Fetch the recent game list of the given user
+    if (state.loadingRecentList)
+        return;
+    state.loadingRecentList = true;
+    const { model } = attrs.view;
+    model.loadUserRecentList(attrs.userid, state.versusAll ? null : (_b = (_a = model.state) === null || _a === void 0 ? void 0 : _a.userId) !== null && _b !== void 0 ? _b : "", (json) => {
+        if (json && json.result === 0)
+            state.recentList = json.recentlist;
+        else
+            state.recentList = [];
+        state.loadingRecentList = false;
+        // m.redraw();
+    });
+};
+const _setVersus = (attrs, state, vsState) => {
+    if (state.versusAll != vsState) {
+        state.versusAll = vsState;
+        state.loadingRecentList = false;
+        _updateRecentList(attrs, state);
+    }
+};
+const UserInfoDialog = {
     // A dialog showing the track record of a given user, including
     // recent games and total statistics
+    /*
     const view = initialVnode.attrs.view;
     const model = view.model;
-    let stats = {};
-    let recentList = [];
+    let stats: UserStats = {};
+    let recentList: RecentListItem[] = [];
     let versusAll = true; // Show games against all opponents or just the current user?
     let loadingStats = false;
     let loadingRecentList = false;
-    function _updateStats(vnode) {
-        // Fetch the statistics of the given user
-        if (loadingStats)
-            return;
-        loadingStats = true;
-        model.loadUserStats(vnode.attrs.userid, (json) => {
-            if (json && json.result === 0)
-                stats = json;
-            else
-                stats = {};
-            loadingStats = false;
-            // m.redraw();
-        });
-    }
-    function _updateRecentList(vnode) {
-        var _a, _b;
-        // Fetch the recent game list of the given user
-        if (loadingRecentList)
-            return;
-        loadingRecentList = true;
-        model.loadUserRecentList(vnode.attrs.userid, versusAll ? null : (_b = (_a = model.state) === null || _a === void 0 ? void 0 : _a.userId) !== null && _b !== void 0 ? _b : "", (json) => {
-            if (json && json.result === 0)
-                recentList = json.recentlist;
-            else
-                recentList = [];
-            loadingRecentList = false;
-            // m.redraw();
-        });
-    }
-    function _setVersus(vnode, vsState) {
-        if (versusAll != vsState) {
-            versusAll = vsState;
-            loadingRecentList = false;
-            _updateRecentList(vnode);
-        }
-    }
-    return {
-        oninit: (vnode) => {
-            _updateRecentList(vnode);
-            _updateStats(vnode);
-        },
-        view: (vnode) => {
-            return m(".modal-dialog", { id: 'usr-info-dialog', style: { visibility: "visible" } }, m(".ui-widget.ui-widget-content.ui-corner-all", { id: 'usr-info-form' }, [
-                m(".usr-info-hdr", [
-                    m("h1.usr-info-icon", [
-                        stats.friend ?
-                            glyph("coffee-cup", { title: ts('Áskrifandi') }) :
-                            glyph("user"), nbsp()
-                    ]),
-                    m("h1[id='usr-info-nick']", vnode.attrs.nick),
-                    m("span.vbar", "|"),
-                    m("h2[id='usr-info-fullname']", vnode.attrs.fullname),
-                    m(".usr-info-fav", {
-                        title: ts('Uppáhald'),
-                        onclick: (ev) => {
-                            var _a;
-                            // Toggle the favorite setting
-                            ev.preventDefault();
-                            view.actions.toggleFavorite(vnode.attrs.userid, (_a = stats.favorite) !== null && _a !== void 0 ? _a : false);
-                            stats.favorite = !stats.favorite;
-                        }
-                    }, stats.favorite ? glyph("star") : glyph("star-empty"))
-                ]),
-                m("p", [
-                    m("strong", t("Nýjustu viðureignir")),
-                    nbsp(),
-                    m("span.versus-cat", [
-                        m("span", {
-                            class: versusAll ? "shown" : "",
-                            onclick: () => { _setVersus(vnode, true); } // Set this.versusAll to true
-                        }, t(" gegn öllum ")),
-                        m("span", {
-                            class: versusAll ? "" : "shown",
-                            onclick: () => { _setVersus(vnode, false); } // Set this.versusAll to false
-                        }, t(" gegn þér "))
-                    ])
+    */
+    oninit: (vnode) => {
+        const { attrs, state } = vnode;
+        state.stats = {};
+        state.recentList = [];
+        state.versusAll = true;
+        state.loadingRecentList = false;
+        state.loadingStats = false;
+        _updateRecentList(attrs, state);
+        _updateStats(attrs, state);
+    },
+    view: (vnode) => {
+        const { attrs, state } = vnode;
+        const { view } = attrs;
+        const { stats, recentList, versusAll } = state;
+        return m(".modal-dialog", { id: 'usr-info-dialog', style: { visibility: "visible" } }, m(".ui-widget.ui-widget-content.ui-corner-all", { id: 'usr-info-form' }, [
+            m(".usr-info-hdr", [
+                m("h1.usr-info-icon", [
+                    vnode.state.stats.friend ?
+                        glyph("coffee-cup", { title: ts('Áskrifandi') }) :
+                        glyph("user"), nbsp()
                 ]),
-                m(".listitem.listheader", [
-                    m("span.list-win", glyphGrayed("bookmark", { title: ts('Sigur') })),
-                    mt("span.list-ts-short", "Viðureign lauk"),
-                    mt("span.list-nick", "Andstæðingur"),
-                    mt("span.list-scorehdr", "Úrslit"),
-                    m("span.list-elo-hdr", [
-                        m("span.glyphicon.glyphicon-user.elo-hdr-left", { title: ts('Mennskir andstæðingar') }),
-                        "Elo",
-                        m("span.glyphicon.glyphicon-cog.elo-hdr-right", { title: ts('Allir andstæðingar') })
-                    ]),
-                    mt("span.list-duration", "Lengd"),
-                    m("span.list-manual", glyphGrayed("lightbulb", { title: ts('Keppnishamur') }))
+                m("h1[id='usr-info-nick']", vnode.attrs.nick),
+                m("span.vbar", "|"),
+                m("h2[id='usr-info-fullname']", vnode.attrs.fullname),
+                m(".usr-info-fav", {
+                    title: ts('Uppáhald'),
+                    onclick: (ev) => {
+                        var _a;
+                        // Toggle the favorite setting
+                        ev.preventDefault();
+                        view.actions.toggleFavorite(vnode.attrs.userid, (_a = stats.favorite) !== null && _a !== void 0 ? _a : false);
+                        stats.favorite = !stats.favorite;
+                    }
+                }, stats.favorite ? glyph("star") : glyph("star-empty"))
+            ]),
+            m("p", [
+                m("strong", t("Nýjustu viðureignir")),
+                nbsp(),
+                m("span.versus-cat", [
+                    m("span", {
+                        class: versusAll ? "shown" : "",
+                        onclick: () => { _setVersus(attrs, state, true); } // Set this.versusAll to true
+                    }, t(" gegn öllum ")),
+                    m("span", {
+                        class: versusAll ? "" : "shown",
+                        onclick: () => { _setVersus(attrs, state, false); } // Set this.versusAll to false
+                    }, t(" gegn þér "))
+                ])
+            ]),
+            m(".listitem.listheader", [
+                m("span.list-win", glyphGrayed("bookmark", { title: ts('Sigur') })),
+                mt("span.list-ts-short", "Viðureign lauk"),
+                mt("span.list-nick", "Andstæðingur"),
+                mt("span.list-scorehdr", "Úrslit"),
+                m("span.list-elo-hdr", [
+                    m("span.glyphicon.glyphicon-user.elo-hdr-left", { title: ts('Mennskir andstæðingar') }),
+                    "Elo",
+                    m("span.glyphicon.glyphicon-cog.elo-hdr-right", { title: ts('Allir andstæðingar') })
                 ]),
-                m(RecentList, { view, id: 'usr-recent', recentList }), // Recent game list
-                m(StatsDisplay, { view, id: 'usr-stats', ownStats: stats }),
-                m(BestDisplay, { id: 'usr-best', ownStats: stats, myself: false }), // Highest word and game scores
-                m(DialogButton, {
-                    id: 'usr-info-close',
-                    title: ts('Loka'),
-                    onclick: (ev) => { view.popDialog(); ev.preventDefault(); }
-                }, glyph("ok"))
-            ]));
-        }
-    };
+                mt("span.list-duration", "Lengd"),
+                m("span.list-manual", glyphGrayed("lightbulb", { title: ts('Keppnishamur') }))
+            ]),
+            m(RecentList, { view, id: 'usr-recent', recentList }), // Recent game list
+            m(StatsDisplay, { view, id: 'usr-stats', ownStats: stats }),
+            m(BestDisplay, { id: 'usr-best', ownStats: stats, myself: false }), // Highest word and game scores
+            m(DialogButton, {
+                id: 'usr-info-close',
+                title: ts('Loka'),
+                onclick: (ev) => { view.popDialog(); ev.preventDefault(); }
+            }, glyph("ok"))
+        ]));
+    },
 };
 
 /*
@@ -32717,7 +33055,7 @@ const GamePromptDialogs = (initialVnode) => {
             // they can be invoked while the last_chall dialog is being
             // displayed. We therefore allow them to cover the last_chall
             // dialog. On mobile, both dialogs are displayed simultaneously.
-            if (game.last_chall) {
+            if (game.last_chall && game.localturn) {
                 r.push(m(".chall-info", [
                     glyph("info-sign"), nbsp(),
                     // "Your opponent emptied the rack - you can challenge or pass"
@@ -34334,7 +34672,7 @@ const Tab = {
         const game = view.model.game;
         return m(".right-tab" + (sel === tabid ? ".selected" : ""), {
             id: "tab-" + tabid,
-            className: alert ? "alert" : "",
+            className: alert ? "chat-alert" : "",
             title: title,
             onclick: (ev) => {
                 // Select this tab
@@ -34356,7 +34694,7 @@ const TabGroup = {
         // A group of clickable tabs for the right-side area content
         const { view } = vnode.attrs;
         const { game } = view.model;
-        const showChat = game && !(game.autoplayer[0] || game.autoplayer[1]);
+        const showChat = game && !game.isRobotGame();
         const r = [
             m(Tab, { view, tabid: "board", title: ts("Borðið"), icon: "grid" }),
             m(Tab, { view, tabid: "movelist", title: ts("Leikir"), icon: "show-lines" }),
@@ -34378,7 +34716,7 @@ const TabGroup = {
                 },
                 // Show chat icon in red if any chat messages have not been seen
                 // and the chat tab is not already selected
-                alert: !game.chatSeen && view.selectedTab != "chat"
+                alert: !game.chatSeen && view.selectedTab !== "chat"
             }));
         }
         return m.fragment({}, r);
@@ -35080,6 +35418,18 @@ class View {
         this.actions = actions;
         // Initialize media listeners now that we have the view reference
         this.actions.initMediaListener(this);
+        // Set up callback to attach user listener when Firebase is ready
+        // This handles both fresh login and cached authentication cases
+        const state = this.model.state;
+        if (state) {
+            state.onFirebaseReady = () => {
+                // Firebase Database is now initialized, attach user listener
+                this.actions.attachListenerToUser();
+            };
+        }
+        // Load user preferences early so audio settings are available
+        // Use false to not show spinner on initial load
+        this.model.loadUser(false);
     }
     appView(routeName) {
         // Returns a view based on the current route.
@@ -35412,8 +35762,8 @@ View.dialogViews = {
 class Actions {
     constructor(model) {
         this.model = model;
-        // Media listeners will be initialized when view is available
-        // this.attachListenerToUser();
+        // Media and Firebase listeners will be initialized
+        // when view is available
     }
     onNavigateTo(routeName, params, view) {
         var _a, _b;
@@ -35503,23 +35853,36 @@ class Actions {
     }
     onMoveMessage(json, firstAttach) {
         // Handle a move message from Firebase
-        console.log("Move message received: " + JSON.stringify(json));
+        // console.log("Move message received: " + JSON.stringify(json));
         this.model.handleMoveMessage(json, firstAttach);
     }
-    onUserMessage(json, firstAttach) {
-        // Handle a user message from Firebase
-        console.log("User message received: " + JSON.stringify(json));
-        this.model.handleUserMessage(json, firstAttach);
+    onUserChallengeMessage(json, firstAttach) {
+        // Handle a user challenge message from Firebase
+        // console.log("User challenge message received: " + JSON.stringify(json));
+        this.model.handleUserChallengeMessage(json, firstAttach);
+    }
+    onUserMoveMessage(json, firstAttach) {
+        // Handle a user move message from Firebase
+        // console.log("User move message received: " + JSON.stringify(json));
+        this.model.handleUserMoveMessage(json, firstAttach);
     }
     onChatMessage(json, firstAttach, view) {
+        var _a;
         // Handle an incoming chat message
-        if (firstAttach)
-            console.log("First attach of chat: " + JSON.stringify(json));
+        if (firstAttach) ;
         else {
-            console.log("Chat message received: " + JSON.stringify(json));
+            // console.log("Chat message received: " + JSON.stringify(json));
             if (this.model.addChatMessage(json.game, json.from_userid, json.msg, json.ts)) {
                 // A chat message was successfully added
                 view.notifyChatMessage();
+                // Play audio notification if:
+                // - User has audio enabled
+                // - Message is from opponent (not from current user)
+                const { state } = this.model;
+                const userId = (_a = state.userId) !== null && _a !== void 0 ? _a : "";
+                if (state.audio && json.from_userid !== userId) {
+                    playAudio(state, "new-msg");
+                }
             }
         }
     }
@@ -35620,12 +35983,17 @@ class Actions {
     }
     attachListenerToUser() {
         const state = this.model.state;
-        if (state && state.userId)
-            attachFirebaseListener('user/' + state.userId, (json, firstAttach) => this.onUserMessage(json, firstAttach));
+        // console.log(`attachListenerToUser(): userId=${state?.userId}`);
+        if (!state || !state.userId)
+            return;
+        // Listen to challenge and move notifications separately
+        attachFirebaseListener(`user/${state.userId}/challenge`, (json, firstAttach) => this.onUserChallengeMessage(json, firstAttach));
+        attachFirebaseListener(`user/${state.userId}/move`, (json, firstAttach) => this.onUserMoveMessage(json, firstAttach));
     }
     detachListenerFromUser() {
         // Stop listening to Firebase notifications for the current user
         const state = this.model.state;
+        // console.log(`detachListenerFromUser(): userId=${state?.userId}`);
         if (state && state.userId)
             detachFirebaseListener('user/' + state.userId);
     }
@@ -37217,7 +37585,7 @@ async function main(state, container) {
         const locale = state.locale || "is_IS";
         // Log the date being used (helpful for debugging)
         if (dateParam) {
-            console.log(`Loading Gáta Dagsins for date: ${validDate} (from URL parameter)`);
+            // console.log(`Loading Gáta Dagsins for date: ${validDate} (from URL parameter)`);
         }
         // Mount the Gáta Dagsins UI using an anonymous closure component
         m.mount(container, {