diff --git a/lang/dev/lobby.json b/lang/dev/lobby.json
index 9df141662..dab4fc9f5 100644
--- a/lang/dev/lobby.json
+++ b/lang/dev/lobby.json
@@ -570,6 +570,13 @@
                 "luaOptionsModal": {
                     "resetAllToDefault": "Reest all to dfauelt",
                     "close": "Csole"
+                },
+                "rejoinBattleModal": {
+                    "title": "Reojin Blatte?",
+                    "description1": "The sveerr idecatind that you were in an avctie btalte.",
+                    "description2": "Wulod you like to atemtpt to rejoin the btalte?",
+                    "rejoinButton": "Reojin",
+                    "ignoreButton": "Ingroe"
                 }
             },
             "controls": {
diff --git a/lang/en/lobby.json b/lang/en/lobby.json
index e84408a8c..2b7ffb9d4 100644
--- a/lang/en/lobby.json
+++ b/lang/en/lobby.json
@@ -570,6 +570,13 @@
                 "luaOptionsModal": {
                     "resetAllToDefault": "Reset all to default",
                     "close": "Close"
+                },
+                "rejoinBattleModal": {
+                    "title": "Rejoin Battle?",
+                    "description1": "The server indicated that you were in an active battle.",
+                    "description2": "Would you like to attempt to rejoin the battle?",
+                    "rejoinButton": "Rejoin",
+                    "ignoreButton": "Ignore"
                 }
             },
             "controls": {
diff --git a/package-lock.json b/package-lock.json
index 619c45c41..fddeb2906 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -39,7 +39,7 @@
                 "primeicons": "^6.0.1",
                 "primevue": "3.23.0",
                 "sdfz-demo-parser": "^5.15.0",
-                "tachyon-protocol": "^1.23.0",
+                "tachyon-protocol": "^1.24.0",
                 "vue-i18n": "^11.1.11",
                 "vue-router": "^4.5.1",
                 "ws": "^8.18.3"
@@ -12232,9 +12232,9 @@
             "license": "MIT"
         },
         "node_modules/tachyon-protocol": {
-            "version": "1.23.0",
-            "resolved": "https://registry.npmjs.org/tachyon-protocol/-/tachyon-protocol-1.23.0.tgz",
-            "integrity": "sha512-7Ji9ULgIv03p1NEQaJZvNeWCarTiR99Jt53gow53u+f+G8jXWIn8XzYcckm9m02D0va768J0t9ramChCBEBJ9g==",
+            "version": "1.24.0",
+            "resolved": "https://registry.npmjs.org/tachyon-protocol/-/tachyon-protocol-1.24.0.tgz",
+            "integrity": "sha512-vQFMDEHlkAkZlIolvMzsrKyQy04zml8zuBW25OZAd7M3B7aNr1ZHtkYmhzvO6JEUWlRJ8bctX6uTO+2Z35Ia9w==",
             "license": "ISC",
             "dependencies": {
                 "ajv": "^8.17.1",
diff --git a/package.json b/package.json
index 05d391b3c..c5ed0f2dc 100644
--- a/package.json
+++ b/package.json
@@ -73,7 +73,7 @@
         "primeicons": "^6.0.1",
         "primevue": "3.23.0",
         "sdfz-demo-parser": "^5.15.0",
-        "tachyon-protocol": "^1.23.0",
+        "tachyon-protocol": "^1.24.0",
         "vue-i18n": "^11.1.11",
         "vue-router": "^4.5.1",
         "ws": "^8.18.3"
diff --git a/src/main/main-window.ts b/src/main/main-window.ts
index 7b2529dc4..ab25d4387 100644
--- a/src/main/main-window.ts
+++ b/src/main/main-window.ts
@@ -43,6 +43,7 @@ export function createWindow() {
             preload: path.join(__dirname, "../build/preload.js"),
             zoomFactor: 1,
             spellcheck: false,
+            autoplayPolicy: "no-user-gesture-required",
         },
     });
 
diff --git a/src/main/tachyon/tachyon.handlers.ts b/src/main/tachyon/tachyon.handlers.ts
index 2b531c341..e40a54c2f 100644
--- a/src/main/tachyon/tachyon.handlers.ts
+++ b/src/main/tachyon/tachyon.handlers.ts
@@ -40,7 +40,16 @@ function createBattleHandlers(webContents: BarIpcWebContents) {
             "battle/start",
             createTypedTachyonRequestHandler<"battle/start">()(async (data: BattleStartRequestData) => {
                 // data carries the join password, so it is summarised rather than dumped.
-                log.info(`Received battle start request for ${data.ip}:${data.port}`);
+                // Note, data.ips[string] values are either ipv4 or ipv6, but we only use the first (only) for now.
+                if (data.ips && data.ips.length > 0) log.info(`Received battle start request for ${data.ips[0]}:${data.port}`);
+                else {
+                    // @ts-expect-error ip is not part of BattleStartRequestData but is used for backward server compatibility
+                    if (data.ip) {
+                        // @ts-expect-error ip is not part of BattleStartRequestData but is used for backward server compatibility
+                        data.ips = [data.ip];
+                    }
+                    log.debug(data);
+                }
                 const missing = contentAPI.missing([
                     { type: "game", id: data.game.springName },
                     { type: "map", id: data.map.springName },
@@ -53,9 +62,7 @@ function createBattleHandlers(webContents: BarIpcWebContents) {
                     });
                     return { status: "failed", reason: "internal_error" };
                 } else {
-                    const { ip, port, username, password } = data;
-                    const springString = `spring://${username}:${password}@${ip}:${port}`;
-                    webContents.send("tachyon:battleStart", springString, data);
+                    webContents.send("tachyon:battleStart", data);
                     return {
                         status: "success",
                     };
diff --git a/src/main/typed-ipc.ts b/src/main/typed-ipc.ts
index 9cedef5d5..ac2e96815 100644
--- a/src/main/typed-ipc.ts
+++ b/src/main/typed-ipc.ts
@@ -5,7 +5,7 @@
 import type { AuthState } from "@main/services/auth.service";
 import type { StoredIdentity } from "@main/model/user";
 import type { BattleWithMetadata } from "@main/game/battle/battle-types";
-import type { BattleStartRequestData } from "tachyon-protocol/types";
+import type { BattleStartRequestData, BattleEndedEventData } from "tachyon-protocol/types";
 import type { ContentRef } from "@main/content/content-ref";
 import type { ContentPresence, ContentState } from "@main/content/content-state";
 import type { DownloadInfo } from "@main/content/downloads";
@@ -47,7 +47,8 @@ export type IPCEvents = {
     "replays:replayCachingStarted": (filename: string) => void;
     "replays:replayDeleted": (filename: string) => void;
     "replays:highlightOpened": (fileNames: string[]) => void;
-    "tachyon:battleStart": (springString: string, data: BattleStartRequestData) => void;
+    "tachyon:battleStart": (data: BattleStartRequestData) => void;
+    "tachyon:battleEnded": (data: BattleEndedEventData) => void;
     "tachyon:connected": () => void;
     "tachyon:disconnected": () => void;
     "tachyon:event": (event: TachyonEvent) => void;
diff --git a/src/preload/preload.ts b/src/preload/preload.ts
index 2fa4473c9..dd74211ef 100644
--- a/src/preload/preload.ts
+++ b/src/preload/preload.ts
@@ -16,7 +16,7 @@ import { DownloadInfo } from "@main/content/downloads";
 import { Info } from "@main/services/info.service";
 import { BattleWithMetadata } from "@main/game/battle/battle-types";
 import { GetCommandData, GetCommandIds, GetCommands } from "tachyon-protocol";
-import type { BattleStartRequestData } from "tachyon-protocol/types";
+import type { BattleStartRequestData, BattleEndedEventData } from "tachyon-protocol/types";
 import { MultiplayerLaunchSettings } from "@main/game/game";
 import { logLevels } from "@main/services/log.service";
 import { Config } from "@main/services/config.service";
@@ -248,7 +248,8 @@ const tachyonApi = {
     onConnected: (callback: () => void) => ipcRenderer.on("tachyon:connected", callback),
     onDisconnected: (callback: () => void) => ipcRenderer.on("tachyon:disconnected", callback),
     onEvent,
-    onBattleStart: (callback: (springString: string, data: BattleStartRequestData) => void) => ipcRenderer.on("tachyon:battleStart", (_event, springString, data) => callback(springString, data)),
+    onBattleStart: (callback: (data: BattleStartRequestData) => void) => ipcRenderer.on("tachyon:battleStart", (_event, data) => callback(data)),
+    onBattleEnded: (callback: (data: BattleEndedEventData) => void) => ipcRenderer.on("tachyon:battleEnded", (_event, data) => callback(data)),
 };
 export type TachyonApi = typeof tachyonApi;
 contextBridge.exposeInMainWorld("tachyon", tachyonApi);
diff --git a/src/renderer/App.vue b/src/renderer/App.vue
index 52e916618..37d3c01bd 100644
--- a/src/renderer/App.vue
+++ b/src/renderer/App.vue
@@ -62,6 +62,7 @@ SPDX-License-Identifier: MIT
         <FullscreenGameModeSelector v-if="state === 'default'" :visible="battleStore.isSelectingGameMode" />
         <LogInConfirmationModal v-model="logInConfirmationIsOpen" :intendedRoute="logInConfirmationIntendedRoute" />
         <ReportUserModal />
+        <RejoinBattleModal v-model="tachyonStore.rejoinModalOpen" />
     </div>
     <Error />
 </template>
@@ -89,6 +90,7 @@ import ReconnectingOverlay from "@renderer/components/misc/ReconnectingOverlay.v
 import PromptContainer from "@renderer/components/prompts/PromptContainer.vue";
 import LogInConfirmationModal from "@renderer/components/misc/LogInConfirmationModal.vue";
 import ReportUserModal from "@renderer/components/user/ReportUserModal.vue";
+import RejoinBattleModal from "@renderer/components/battle/RejoinBattleModal.vue";
 
 import { playRandomMusic } from "@renderer/utils/play-random-music";
 import { settingsStore } from "./store/settings.store";
@@ -201,8 +203,9 @@ if (!settingsStore.devMode) {
 
 function unseenPartyMessages() {
     if (!partyStore.activeParty) return false;
-    if (chatStore.partyChat.length <= 0) return false;
-    return !chatStore.partyChat.at(-1)?.seen;
+    const messages = chatStore.partyChats.get(partyStore.activeParty);
+    if (!messages || messages.length <= 0) return false;
+    return !messages.at(-1)?.seen;
 }
 function getPartyIcon() {
     if (unseenPartyMessages()) return bellAlert;
diff --git a/src/renderer/assets/assetFiles.ts b/src/renderer/assets/assetFiles.ts
index 19c0deab0..16db98db0 100644
--- a/src/renderer/assets/assetFiles.ts
+++ b/src/renderer/assets/assetFiles.ts
@@ -12,6 +12,7 @@ export const sfxFiles = import.meta.glob<string>(["./audio/sfx/*", "!**/*.licens
 
 // Videos
 export const introVideos = import.meta.glob<string>(["./videos/intros/*", "!**/*.license"], { eager: true, import: "default", query: "?url" });
+export const miscVideos = import.meta.glob<string>(["./videos/misc/*", "!**/*.license"], { eager: true, import: "default", query: "?url" });
 
 // Images
 export const backgroundImages = import.meta.glob<string>(["./images/backgrounds/*", "!**/*.license"], { eager: true, import: "default", query: "?url" });
diff --git a/src/renderer/assets/languages/cs.json b/src/renderer/assets/languages/cs.json
index 1ee4c453a..dec9d0cef 100644
--- a/src/renderer/assets/languages/cs.json
+++ b/src/renderer/assets/languages/cs.json
@@ -2553,6 +2553,13 @@
                 "luaOptionsModal": {
                     "resetAllToDefault": null,
                     "close": null
+                },
+                "rejoinBattleModal": {
+                    "title": null,
+                    "description1": null,
+                    "description2": null,
+                    "rejoinButton": null,
+                    "ignoreButton": null
                 }
             },
             "controls": {
diff --git a/src/renderer/assets/languages/de.json b/src/renderer/assets/languages/de.json
index e2019f3ae..fb56c39db 100644
--- a/src/renderer/assets/languages/de.json
+++ b/src/renderer/assets/languages/de.json
@@ -2424,6 +2424,13 @@
                 "luaOptionsModal": {
                     "resetAllToDefault": null,
                     "close": null
+                },
+                "rejoinBattleModal": {
+                    "title": null,
+                    "description1": null,
+                    "description2": null,
+                    "rejoinButton": null,
+                    "ignoreButton": null
                 }
             },
             "controls": {
diff --git a/src/renderer/assets/languages/dev.json b/src/renderer/assets/languages/dev.json
index 55ea3a297..8e05cba77 100644
--- a/src/renderer/assets/languages/dev.json
+++ b/src/renderer/assets/languages/dev.json
@@ -570,6 +570,13 @@
                 "luaOptionsModal": {
                     "resetAllToDefault": "Reest all to dfauelt",
                     "close": "Csole"
+                },
+                "rejoinBattleModal": {
+                    "title": "Reojin Blatte?",
+                    "description1": "The sveerr idecatind that you were in an avctie btalte.",
+                    "description2": "Wulod you like to atemtpt to rejoin the btalte?",
+                    "rejoinButton": "Reojin",
+                    "ignoreButton": "Ingroe"
                 }
             },
             "controls": {
diff --git a/src/renderer/assets/languages/en.json b/src/renderer/assets/languages/en.json
index 2d7298e97..e4201df59 100644
--- a/src/renderer/assets/languages/en.json
+++ b/src/renderer/assets/languages/en.json
@@ -2401,6 +2401,13 @@
                 "luaOptionsModal": {
                     "resetAllToDefault": "Reset all to default",
                     "close": "Close"
+                },
+                "rejoinBattleModal": {
+                    "title": "Rejoin Battle?",
+                    "description1": "The server indicated that you were in an active battle.",
+                    "description2": "Would you like to attempt to rejoin the battle?",
+                    "rejoinButton": "Rejoin",
+                    "ignoreButton": "Ignore"
                 }
             },
             "controls": {
diff --git a/src/renderer/assets/languages/fr.json b/src/renderer/assets/languages/fr.json
index f448c0969..633305c71 100644
--- a/src/renderer/assets/languages/fr.json
+++ b/src/renderer/assets/languages/fr.json
@@ -4406,6 +4406,13 @@
                 "luaOptionsModal": {
                     "resetAllToDefault": null,
                     "close": null
+                },
+                "rejoinBattleModal": {
+                    "title": null,
+                    "description1": null,
+                    "description2": null,
+                    "rejoinButton": null,
+                    "ignoreButton": null
                 }
             },
             "controls": {
diff --git a/src/renderer/assets/languages/ru.json b/src/renderer/assets/languages/ru.json
index 50a567c18..d0ea54b26 100644
--- a/src/renderer/assets/languages/ru.json
+++ b/src/renderer/assets/languages/ru.json
@@ -4375,6 +4375,13 @@
                 "luaOptionsModal": {
                     "resetAllToDefault": null,
                     "close": null
+                },
+                "rejoinBattleModal": {
+                    "title": null,
+                    "description1": null,
+                    "description2": null,
+                    "rejoinButton": null,
+                    "ignoreButton": null
                 }
             },
             "controls": {
diff --git a/src/renderer/assets/languages/zh.json b/src/renderer/assets/languages/zh.json
index 1178305bb..717eb0e5c 100644
--- a/src/renderer/assets/languages/zh.json
+++ b/src/renderer/assets/languages/zh.json
@@ -4517,6 +4517,13 @@
                 "luaOptionsModal": {
                     "resetAllToDefault": null,
                     "close": null
+                },
+                "rejoinBattleModal": {
+                    "title": null,
+                    "description1": null,
+                    "description2": null,
+                    "rejoinButton": null,
+                    "ignoreButton": null
                 }
             },
             "controls": {
diff --git a/src/renderer/assets/videos/misc/active_battle.mkv b/src/renderer/assets/videos/misc/active_battle.mkv
new file mode 100644
index 000000000..bc14350aa
Binary files /dev/null and b/src/renderer/assets/videos/misc/active_battle.mkv differ
diff --git a/src/renderer/assets/videos/misc/active_battle.mkv.license b/src/renderer/assets/videos/misc/active_battle.mkv.license
new file mode 100644
index 000000000..472dcb84e
--- /dev/null
+++ b/src/renderer/assets/videos/misc/active_battle.mkv.license
@@ -0,0 +1,3 @@
+SPDX-FileCopyrightText: 2026 The BAR Lobby Authors
+
+SPDX-License-Identifier: CC0-1.0
diff --git a/src/renderer/components/battle/RejoinBattleModal.vue b/src/renderer/components/battle/RejoinBattleModal.vue
new file mode 100644
index 000000000..e73b8748f
--- /dev/null
+++ b/src/renderer/components/battle/RejoinBattleModal.vue
@@ -0,0 +1,57 @@
+<!--
+SPDX-FileCopyrightText: 2026 The BAR Lobby Authors
+
+SPDX-License-Identifier: MIT
+-->
+
+<template>
+    <Modal v-model="isOpen" :title="t('lobby.components.battle.rejoinBattleModal.title')">
+        <div class="container">
+            <p>{{ t("lobby.components.battle.rejoinBattleModal.description1") }}</p>
+            <p>{{ t("lobby.components.battle.rejoinBattleModal.description2") }}</p>
+            <div class="flex-row flex-center padding-top-lg gap-xl">
+                <Button class="green fullwidth" @click="onConfirm">{{
+                    t("lobby.components.battle.rejoinBattleModal.rejoinButton")
+                }}</Button>
+                <Button class="red fullwidth" @click="onCancel">{{ t("lobby.components.battle.rejoinBattleModal.ignoreButton") }}</Button>
+            </div>
+        </div>
+    </Modal>
+</template>
+
+<script lang="ts" setup>
+import { computed } from "vue";
+import Modal from "@renderer/components/common/Modal.vue";
+import Button from "@renderer/components/controls/Button.vue";
+import { tachyon, tachyonStore } from "@renderer/store/tachyon.store";
+import { useTypedI18n } from "@renderer/i18n";
+
+const { t } = useTypedI18n();
+
+const props = withDefaults(
+    defineProps<{
+        modelValue?: boolean;
+    }>(),
+    { modelValue: false }
+);
+
+const emit = defineEmits<{ (e: "update:modelValue", v: boolean): void }>();
+const isOpen = computed({
+    get: () => props.modelValue,
+    set: (v: boolean) => emit("update:modelValue", v),
+});
+
+function onConfirm() {
+    console.log("Rejoining battle...");
+    if (tachyonStore.springConnectionDetails) {
+        tachyon.launchMultiplayerBattle(tachyonStore.springConnectionDetails);
+    }
+    isOpen.value = false;
+}
+function onCancel() {
+    console.log("Ignoring rejoin battle prompt.");
+    isOpen.value = false;
+}
+</script>
+
+<style lang="scss" scoped></style>
diff --git a/src/renderer/components/maps/MapSimplePreview.vue b/src/renderer/components/maps/MapSimplePreview.vue
index e58f4ffd6..19932f90a 100644
--- a/src/renderer/components/maps/MapSimplePreview.vue
+++ b/src/renderer/components/maps/MapSimplePreview.vue
@@ -16,6 +16,7 @@ import { useImageBlobUrlCache } from "@renderer/composables/useImageBlobUrlCache
 import vStartBox from "@renderer/directives/vStartBox";
 import vStartPos from "@renderer/directives/vStartPos";
 import { computed, defineComponent } from "vue";
+import defaultMiniMap from "/src/renderer/assets/images/default-minimap.png?url";
 
 defineComponent({
     directives: {
@@ -25,17 +26,14 @@ defineComponent({
 });
 
 const props = defineProps<{
-    map: MapData;
+    map: MapData | undefined;
 }>();
 
-const { get } = useImageBlobUrlCache();
+const cache = useImageBlobUrlCache();
 
-const mapTextureUrl = computed(() => {
-    if (!props.map?.images) {
-        return;
-    }
-    return get(props.map?.springName, props.map?.imagesBlob?.preview);
-});
+const mapTextureUrl = computed(() =>
+    props.map?.imagesBlob?.preview ? cache.get(props.map?.springName, props.map?.imagesBlob?.preview) : defaultMiniMap
+);
 </script>
 
 <style lang="scss" scoped>
diff --git a/src/renderer/components/misc/ActiveBattleVideo.vue b/src/renderer/components/misc/ActiveBattleVideo.vue
new file mode 100644
index 000000000..822533309
--- /dev/null
+++ b/src/renderer/components/misc/ActiveBattleVideo.vue
@@ -0,0 +1,38 @@
+<!--
+SPDX-FileCopyrightText: 2026 The BAR Lobby Authors
+
+SPDX-License-Identifier: MIT
+-->
+
+<template>
+    <div>
+        <span class="rejoin-label">{{ "Rejoin" }}</span>
+        <video :src="video" autoplay muted loop></video>
+    </div>
+</template>
+
+<script lang="ts" setup>
+import { miscVideos } from "@renderer/assets/assetFiles";
+
+const video = miscVideos["./videos/misc/active_battle.mkv"];
+</script>
+
+<style lang="scss" scoped>
+:deep(> div) {
+    width: 100%;
+}
+
+video {
+    display: block;
+    width: 100%;
+    height: auto;
+}
+
+.rejoin-label {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    text-align: center;
+}
+</style>
diff --git a/src/renderer/components/navbar/NavBar.vue b/src/renderer/components/navbar/NavBar.vue
index 20a1cdfb3..d33d46c67 100644
--- a/src/renderer/components/navbar/NavBar.vue
+++ b/src/renderer/components/navbar/NavBar.vue
@@ -7,8 +7,11 @@ SPDX-License-Identifier: MIT
 <template>
     <div class="nav" :class="{ hidden }">
         <div class="logo">
-            <Button to="/play/menu?">
-                <img src="/src/renderer/assets/images/logo.svg" />
+            <Button @click="onLogoClick">
+                <div class="logo-container">
+                    <img src="/src/renderer/assets/images/logo.svg" :class="{ dim: tachyonStore.springConnectionDetails }" />
+                    <ActiveBattleVideo class="battle-video" v-if="tachyonStore.springConnectionDetails" />
+                </div>
             </Button>
         </div>
         <div class="flex-col flex-grow">
@@ -126,6 +129,8 @@ import { me } from "@renderer/store/me.store";
 import ServerStatus from "@renderer/components/navbar/ServerStatus.vue";
 import { useLogInConfirmation } from "@renderer/composables/useLogInConfirmation";
 import { chatStore } from "@renderer/store/chat.store";
+import { tachyonStore } from "@renderer/store/tachyon.store";
+import ActiveBattleVideo from "@renderer/components/misc/ActiveBattleVideo.vue";
 
 defineProps<{
     hidden?: boolean;
@@ -173,6 +178,14 @@ function minimizeWindow() {
 function toggleFullscreen() {
     settingsStore.fullscreen = !settingsStore.fullscreen;
 }
+
+function onLogoClick() {
+    if (tachyonStore.springConnectionDetails) {
+        tachyonStore.rejoinModalOpen = true;
+    } else {
+        router.push("/play");
+    }
+}
 </script>
 
 <style lang="scss" scoped>
@@ -361,4 +374,24 @@ function toggleFullscreen() {
     flex-grow: 1;
     -webkit-app-region: drag !important;
 }
+.logo-container {
+    position: relative;
+    display: inline-block;
+}
+.logo-container img {
+    display: block;
+    // max-width: 100%;
+    // height: auto;
+}
+.battle-video {
+    position: absolute;
+    top: 50%;
+    left: 0;
+    width: 100%;
+    transform: translateY(-50%);
+    z-index: 2;
+}
+.dim {
+    filter: brightness(0.12);
+}
 </style>
diff --git a/src/renderer/components/party/PartyChat.vue b/src/renderer/components/party/PartyChat.vue
index ec998f0f9..be22aee8b 100644
--- a/src/renderer/components/party/PartyChat.vue
+++ b/src/renderer/components/party/PartyChat.vue
@@ -10,7 +10,7 @@ SPDX-License-Identifier: MIT
             <div class="messages">
                 <div class="flex-col gap-sm">
                     <div
-                        v-for="(message, i) in chatStore.partyChat"
+                        v-for="(message, i) in partyMessages"
                         :key="i"
                         v-in-view.once="() => (message.seen = true)"
                         :class="['message', { fromMe: message.source.userId === me.userId }]"
@@ -36,8 +36,9 @@ SPDX-License-Identifier: MIT
 </template>
 
 <script lang="ts" setup>
-import { ref } from "vue";
+import { computed, ref } from "vue";
 import { chatStore, chat } from "@renderer/store/chat.store";
+import { partyStore } from "@renderer/store/party.store";
 import { tachyonStore } from "@renderer/store/tachyon.store";
 import { useDexieLiveQueryWithDeps } from "@renderer/composables/useDexieLiveQuery";
 import { UserId } from "tachyon-protocol/types";
@@ -55,7 +56,9 @@ function focusTextbox(el: HTMLElement) {
         el.firstElementChild.focus();
     }
 }
-const displayNames = useDexieLiveQueryWithDeps(chatStore.partyChat, async () => {
+const partyMessages = computed(() => (partyStore.activeParty ? (chatStore.partyChats.get(partyStore.activeParty) ?? []) : []));
+
+const displayNames = useDexieLiveQueryWithDeps(partyMessages, async () => {
     const map = new Map<UserId, string>();
     await db.users.each(function (user) {
         map.set(user.userId, user.username);
diff --git a/src/renderer/store/chat.store.ts b/src/renderer/store/chat.store.ts
index 8eb10fbc3..363149260 100644
--- a/src/renderer/store/chat.store.ts
+++ b/src/renderer/store/chat.store.ts
@@ -4,11 +4,15 @@
 
 import { reactive } from "vue";
 import { subsManager } from "@renderer/store/users.store";
-import { HistoryMarker, MessagingReceivedEventData, MessagingSendRequestData, MessagingSubscribeReceivedRequestData, UserId } from "tachyon-protocol/types";
+import { HistoryMarker, MessagingReceivedEventData, MessagingSendRequestData, MessagingSubscribeReceivedRequestData, UserId, PartyId, LobbyId } from "tachyon-protocol/types";
 import { notificationsApi } from "@renderer/api/notifications";
+import { tachyonRequest } from "@renderer/api/tachyon";
 import { Message } from "@renderer/model/message";
 import { me } from "@renderer/store/me.store";
 import { onWentOffline } from "@renderer/utils/offline-signal";
+import { onTachyonConnected } from "@renderer/utils/connection-signal";
+import { lobbyStore } from "@renderer/store/lobby.store";
+import { partyStore } from "@renderer/store/party.store";
 // import { setupI18n } from "@renderer/i18n";
 
 // const i18n = setupI18n();
@@ -24,18 +28,22 @@ let subscribeAttempts = 0;
 export const chatStore: {
     isInitialized: boolean;
     lastMarker: HistoryMarker | null;
-    lobbyChat: Message[];
-    partyChat: Message[];
+    lobbyChats: Map<LobbyId, Message[]>;
+    partyChats: Map<PartyId, Message[]>;
     userChats: Map<UserId, Message[]>;
 } = reactive({
     isInitialized: false,
     lastMarker: null,
-    lobbyChat: [],
-    partyChat: [],
-    userChats: new Map<UserId, Message[]>(), // Messages.vue will turn each of these Map elements into a TabPanel for the chat history with that user
+    lobbyChats: new Map<LobbyId, Message[]>(),
+    partyChats: new Map<PartyId, Message[]>(),
+    userChats: new Map<UserId, Message[]>(),
 });
 
 export async function initChatStore() {
+    if (chatStore.isInitialized) {
+        console.warn("Chat store is already initialized. Skipping initialization.");
+        return;
+    }
     onWentOffline.add(clearOnlineState);
     // Losing the session is the one signal every way of leaving an account reaches:
     // the exit menu, a server switch, and a refresh token the server rejects.
@@ -43,12 +51,14 @@ export async function initChatStore() {
         if (!authenticated) clearAccountState();
     });
     window.tachyon.onEvent("messaging/received", onMessagingReceivedEvent);
+    // Subscribe to messages (all sources) once connected.
+    onTachyonConnected.add(() => requestSubscribeReceived());
     chatStore.isInitialized = true;
 }
 
 const chatDestinations = {
-    lobby: chatStore.lobbyChat,
-    party: chatStore.partyChat,
+    lobby: chatStore.lobbyChats,
+    party: chatStore.partyChats,
     player: chatStore.userChats,
 };
 
@@ -58,7 +68,7 @@ const chatDestinations = {
  */
 async function requestSend(data: MessagingSendRequestData) {
     try {
-        const response = await window.tachyon.request("messaging/send", data);
+        const response = await tachyonRequest("messaging/send", data);
         console.log("Tachyon messaging/send:", response);
         if (data.target.type === "player") {
             if (data.target.userId !== me.userId) {
@@ -90,7 +100,7 @@ function resumePoint(): MessagingSubscribeReceivedRequestData["since"] {
 }
 
 function hasStoredMessages(): boolean {
-    return chatStore.lobbyChat.length > 0 || chatStore.partyChat.length > 0 || [...chatStore.userChats.values()].some((chat) => chat.length > 0);
+    return chatStore.lobbyChats.size > 0 || chatStore.partyChats.size > 0 || [...chatStore.userChats.values()].some((chat) => chat.length > 0);
 }
 
 /**
@@ -110,7 +120,7 @@ async function subscribeReceived(data?: MessagingSubscribeReceivedRequestData) {
     const request = data ?? { since: resumePoint() };
 
     try {
-        const response = await window.tachyon.request("messaging/subscribeReceived", request);
+        const response = await tachyonRequest("messaging/subscribeReceived", request);
         console.log("Tachyon messaging/subscribeReceived:", response);
         subscribeAttempts = 0;
 
@@ -164,22 +174,21 @@ function onMessagingReceivedEvent(data: MessagingReceivedEventData) {
  * @param requestData Payload of data already sent to the Tachyon server for this client's message request
  */
 function insertSelfMessage(requestData: MessagingSendRequestData) {
-    insertMessage(
-        // data:
-        {
-            message: requestData.message,
-            source: {
-                type: requestData.target.type,
-                userId: me.userId,
-                lobbyId: "", // We are not preserving lobby/party chat based on an ID, so these are irrelevant and can be empty strings
-                partyId: "",
-            },
-            timestamp: Date.now() * 1000,
-            marker: "",
-        },
-        // destination:
-        requestData.target
-    );
+    if (requestData.target.type === "player") {
+        insertMessage({ ...requestData, source: { type: "player", userId: me.userId }, timestamp: Date.now() * 1000, marker: "" }, requestData.target);
+    }
+    if (requestData.target.type === "lobby") {
+        insertMessage(
+            { ...requestData, source: { type: "lobby", lobbyId: lobbyStore.activeLobby?.id ?? "", userId: me.userId }, timestamp: Date.now() * 1000, marker: "" },
+            { type: "lobby", lobbyId: lobbyStore.activeLobby?.id ?? "", userId: me.userId }
+        );
+    }
+    if (requestData.target.type === "party") {
+        insertMessage(
+            { ...requestData, source: { type: "party", partyId: partyStore.activeParty ?? "", userId: me.userId }, timestamp: Date.now() * 1000, marker: "" },
+            { type: "party", partyId: partyStore.activeParty ?? "", userId: me.userId }
+        );
+    }
 }
 
 /**
@@ -187,32 +196,54 @@ function insertSelfMessage(requestData: MessagingSendRequestData) {
  * @param data Payload of message data
  * @param destination The targets chat that will store the message event
  */
-function insertMessage(data: MessagingReceivedEventData, destination: MessagingSendRequestData["target"]) {
+function insertMessage(data: MessagingReceivedEventData, destination: MessagingReceivedEventData["source"]) {
     const msg = { ...data, seen: false };
-    if (destination.type === "player") {
-        const userChat = chatDestinations["player"].get(destination.userId);
-        if (!userChat) {
-            chatDestinations["player"].set(destination.userId, [msg]);
-        } else {
-            userChat.push(msg);
-        }
+    const destId = destination.type === "lobby" ? destination.lobbyId : destination.type === "party" ? destination.partyId : destination.userId;
+    // if (destination.type === "player") {
+    const chat = chatDestinations[destination.type].get(destId);
+    if (!chat) {
+        chatDestinations[destination.type].set(destId, [msg]);
     } else {
-        chatDestinations[destination.type].push(msg);
+        chat.push(msg);
     }
+    // }
+    // if (destination.type === "lobby") {
+    //     const lobbyChat = chatDestinations[destination.type].get(dId);
+    //     if (!lobbyChat) {
+    //         chatDestinations[destination.type].set(dId, [msg]);
+    //     } else {
+    //         lobbyChat.push(msg);
+    //     }
+    // }
+    // if (destination.type === "party") {
+    //     const partyChat = chatDestinations[destination.type].get(dId);
+    //     if (!partyChat) {
+    //         chatDestinations[destination.type].set(dId, [msg]);
+    //     } else {
+    //         partyChat.push(msg);
+    //     }
+    // }
 }
 
 /**
- * Deletes all stored history in chatStore.lobbyChat
+ * Deletes all stored history in chatStore.lobbyChats
  */
 function clearLobbyChat() {
-    chatStore.lobbyChat.length = 0;
+    chatStore.lobbyChats.clear();
 }
 
 /**
- * Deletes all stored history in chatStore.partyChat
+ * Deletes all stored history in chatStore.partyChats
  */
 function clearPartyChat() {
-    chatStore.partyChat.length = 0;
+    chatStore.partyChats.clear();
+}
+
+/**
+ * Deletes all stored history in chatStore.userChats
+ */
+function clearAllUserChats() {
+    chatStore.userChats.clear();
 }
 
 /**
@@ -251,7 +282,7 @@ function clearOnlineState() {
 // may be left for whoever signs in next.
 function clearAccountState() {
     subsManager.clearAllFromList(chatSymbol);
-    chatStore.userChats.clear();
+    clearAllUserChats();
     clearLobbyChat();
     clearPartyChat();
 }
@@ -262,6 +293,7 @@ export const chat = {
     clearLobbyChat,
     clearPartyChat,
     clearUserChat,
+    clearAllUserChats,
     addNewUserChat,
     clearOnlineState,
     clearAccountState,
diff --git a/src/renderer/store/downloads.store.ts b/src/renderer/store/downloads.store.ts
index 3796e9e9d..73d4b470c 100644
--- a/src/renderer/store/downloads.store.ts
+++ b/src/renderer/store/downloads.store.ts
@@ -15,6 +15,10 @@ export const downloadsStore: {
 });
 
 export function initDownloadsStore() {
+    if (downloadsStore.isInitialized) {
+        console.warn("Downloads store is already initialized. Skipping initialization.");
+        return;
+    }
     window.autoUpdater.onDownloadUpdateProgress((downloadInfo) => {
         downloadsStore.updateDownloads = downloadInfo ? [downloadInfo] : [];
     });
diff --git a/src/renderer/store/engine.store.ts b/src/renderer/store/engine.store.ts
index 372704838..05501ba10 100644
--- a/src/renderer/store/engine.store.ts
+++ b/src/renderer/store/engine.store.ts
@@ -56,6 +56,10 @@ export async function downloadEngine(engineString: string) {
 }
 
 export async function initEnginesStore() {
+    if (enginesStore.isInitialized) {
+        console.warn("Engines store is already initialized. Skipping initialization.");
+        return;
+    }
     onContentSettled(async (refs) => {
         if (refs.some((ref) => ref.type === "engine")) {
             await refreshEnginesStore();
diff --git a/src/renderer/store/game.store.ts b/src/renderer/store/game.store.ts
index ea92bd721..d32ea23ed 100644
--- a/src/renderer/store/game.store.ts
+++ b/src/renderer/store/game.store.ts
@@ -96,7 +96,10 @@ export async function watchReplay(replay: Replay) {
 }
 
 export async function initGameStore() {
-    if (gameStore.isInitialized) return;
+    if (gameStore.isInitialized) {
+        console.warn("Game store is already initialized. Skipping initialization.");
+        return;
+    }
     await refreshStore();
     onContentSettled(async (refs) => {
         if (refs.some((ref) => ref.type === "game")) {
diff --git a/src/renderer/store/infos.store.ts b/src/renderer/store/infos.store.ts
index fdc0ab1ea..34f7f4016 100644
--- a/src/renderer/store/infos.store.ts
+++ b/src/renderer/store/infos.store.ts
@@ -12,6 +12,10 @@ export const infosStore = reactive({
 } & Info);
 
 export async function initInfosStore() {
+    if (infosStore.isInitialized) {
+        console.warn("Infos store is already initialized. Skipping initialization.");
+        return;
+    }
     const currentInfos = await window.info.getInfo();
     Object.assign(infosStore, currentInfos);
     infosStore.isInitialized = true;
diff --git a/src/renderer/store/lobby.store.ts b/src/renderer/store/lobby.store.ts
index 952b1e357..fd7c0b80d 100644
--- a/src/renderer/store/lobby.store.ts
+++ b/src/renderer/store/lobby.store.ts
@@ -22,18 +22,20 @@ import {
     LobbyVoteSubmitRequestData,
     LobbyUpdateClientStatusRequestData,
     UserId,
+    PrivateUser,
 } from "tachyon-protocol/types";
 import { reactive } from "vue";
 import { apply as applyPatch } from "json8-merge-patch";
 import { notificationsApi } from "@renderer/api/notifications";
+import { tachyonRequest, isTachyonErrorForCommand } from "@renderer/api/tachyon";
 import { Lobby } from "@renderer/model/lobby";
 import { setupI18n } from "@renderer/i18n";
 import { subsManager } from "@renderer/store/users.store";
-import { chat } from "@renderer/store/chat.store";
 import { db } from "@renderer/store/db";
 import { battleStore, battleActions } from "@renderer/store/battle.store";
 import { router } from "@renderer/router";
 import { onWentOffline } from "@renderer/utils/offline-signal";
+import { tachyonStore } from "@renderer/store/tachyon.store";
 
 const i18n = setupI18n();
 
@@ -56,6 +58,10 @@ export const lobbyStore: {
 });
 
 export async function initLobbyStore() {
+    if (lobbyStore.isInitialized) {
+        console.warn("Lobby store is already initialized. Skipping initialization.");
+        return;
+    }
     onWentOffline.add(clearOnlineState);
     window.tachyon.onEvent("lobby/listUpdated", onListUpdatedEvent);
     window.tachyon.onEvent("lobby/listReset", onLobbyListResetEvent);
@@ -69,9 +75,25 @@ export async function initLobbyStore() {
             requestSubscribeList();
         }
     });
+    window.tachyon.onEvent("user/self", (data) => onUserSelfEventLobby(data.user.currentLobby));
+
     lobbyStore.isInitialized = true;
 }
 
+function onUserSelfEventLobby(lobbyId: PrivateUser["currentLobby"]) {
+    if (lobbyId) {
+        // join is idempotent, so we can call it even if we're already in the lobby.
+        requestJoinLobby({ id: lobbyId, pushLobbyView: false });
+    } else {
+        // User is not in a lobby. We navigate out of the lobby view if they are currently there, and clear the activeLobby.
+        if (router.currentRoute.value.path == "/play/lobby") {
+            router.replace("/play/customLobbies");
+        }
+        clearUserSubscriptions();
+        lobbyStore.activeLobby = undefined;
+    }
+}
+
 function onListUpdatedEvent(data: LobbyListUpdatedEventData) {
     console.log("Tachyon event: lobby/listUpdated:", data);
     lobbyStore.lobbies = applyPatch(lobbyStore.lobbies, data.lobbies);
@@ -95,7 +117,7 @@ function onLobbyVoteEndedEvent(data: LobbyVoteEndedEventData) {
 async function requestSubscribeList() {
     lobbyStore.wantsListSubscription = true;
     try {
-        const response = await window.tachyon.request("lobby/subscribeList");
+        const response = await tachyonRequest("lobby/subscribeList");
         //Per Tachyon protocol, this subscribes us, but does not return an updated list, that happens in the ListUpdated or ListReset events.
         console.log("subscribeList:", response.status);
     } catch (error) {
@@ -113,7 +135,7 @@ async function requestSubscribeList() {
 async function requestUnsubscribeList() {
     lobbyStore.wantsListSubscription = false;
     try {
-        await window.tachyon.request("lobby/unsubscribeList");
+        await tachyonRequest("lobby/unsubscribeList");
     } catch (error) {
         console.error("Error with request lobby/unsubscribeList:", error);
         notificationsApi.alert({
@@ -130,7 +152,7 @@ async function requestUnsubscribeList() {
 async function requestCreateLobby(data: LobbyCreateRequestData) {
     try {
         battleActions.resetToDefaultBattle(undefined, undefined, undefined, true);
-        const response = await window.tachyon.request("lobby/create", data);
+        const response = await tachyonRequest("lobby/create", data);
         console.log("Tachyon: lobby/create:", response.status, response.data);
         parseLobbyResponseData(response.data, false);
         router.push("/play/lobby");
@@ -146,14 +168,17 @@ async function requestCreateLobby(data: LobbyCreateRequestData) {
 /**
  * Sends a request to join an existing lobby with the provided ID.
  * @param id The ID of the lobby to join.
+ * @param pushLobbyView Whether to push the route to the lobby view. Optional; defaults to true.
  */
-async function requestJoinLobby(id: string) {
+async function requestJoinLobby({ id, pushLobbyView }: { id: string; pushLobbyView: boolean }) {
     try {
         battleActions.resetToDefaultBattle(undefined, undefined, undefined, true);
-        const response = await window.tachyon.request("lobby/join", { id: id });
+        const response = await tachyonRequest("lobby/join", { id: id });
         console.log("Tachyon: lobby/join:", response.status, response.data);
         parseLobbyResponseData(response.data, false);
-        router.push("/play/lobby");
+        if (pushLobbyView ?? true) {
+            router.push("/play/lobby");
+        }
     } catch (error) {
         console.error("Error with request lobby/join", error);
         notificationsApi.alert({
@@ -169,7 +194,7 @@ async function requestJoinLobby(id: string) {
  */
 async function requestJoinAllyTeam(allyTeam: string) {
     try {
-        const response = await window.tachyon.request("lobby/joinAllyTeam", { allyTeam: allyTeam });
+        const response = await tachyonRequest("lobby/joinAllyTeam", { allyTeam: allyTeam });
         console.log("Tachyon: lobby/joinAllyTeam", response);
     } catch (error) {
         console.error("Tachyon error: lobby/joinAllyTeam:", error);
@@ -185,7 +210,7 @@ async function requestJoinAllyTeam(allyTeam: string) {
  */
 async function requestJoinQueue() {
     try {
-        const response = await window.tachyon.request("lobby/joinQueue");
+        const response = await tachyonRequest("lobby/joinQueue");
         console.log("Tachyon: lobby/joinQueue:", response);
     } catch (error) {
         console.error("Tachyon error: lobby/joinQueue:", error);
@@ -201,7 +226,7 @@ async function requestJoinQueue() {
  */
 async function requestSpectate() {
     try {
-        const response = await window.tachyon.request("lobby/spectate");
+        const response = await tachyonRequest("lobby/spectate");
         console.log("Tachyon: lobby/spectate", response);
     } catch (error) {
         console.error("Tachyon error: lobby/spectate:", error);
@@ -243,15 +268,19 @@ function parseLobbyResponseData(data: LobbyCreateOkResponseData | LobbyJoinOkRes
     } else {
         //Apply the patch for a join/create response
         lobbyStore.activeLobby = applyPatch({}, data);
-        // Leaving clears the transcript, but going offline keeps it and sends no
-        // leave, so entering the next lobby has to clear that one. A reconnect
-        // does not come through here, so a dropped socket cannot wipe it.
-        chat.clearLobbyChat();
     }
     if (!lobbyStore.activeLobby) {
         console.error("Active Lobby is null or undefined after applyPatch. This should never happen!");
         return;
     }
+
+    // Usually `battle/ended` will clear for us, but there's a chance that the client could have the connection details but no longer be a player/spectator and not receive the event.
+    // As a result, we force clear these values if the lobby ends the battle. Since clients cannot be in multiple lobbies/matches, this is safe to do.
+    if (lobbyStore.activeLobby.currentBattle == undefined) {
+        tachyonStore.springConnectionDetails = undefined;
+        tachyonStore.rejoinModalOpen = false;
+    }
+
     //Updates are not guaranteed to change all things, so we check if each property was part of the update before working with it on the stores.
     if (data.engineVersion) {
         battleStore.battleOptions.engineVersion = lobbyStore.activeLobby.engineVersion;
@@ -301,20 +330,34 @@ function parseLobbyResponseData(data: LobbyCreateOkResponseData | LobbyJoinOkRes
  * Sends a request to leave the currently active lobby.
  */
 async function requestLeaveLobby() {
+    let removedFromLobby = false;
     try {
-        const response = await window.tachyon.request("lobby/leave");
+        const response = await tachyonRequest("lobby/leave");
         console.log("Tachyon: lobby/leave:", response.status);
+        removedFromLobby = true;
     } catch (error) {
         console.error("Error with request lobby/leave", error);
-        notificationsApi.alert({
-            text: "Error with request lobby/leave",
-            severity: "error",
-        });
+        if (isTachyonErrorForCommand(error, "lobby/leave")) {
+            if (error.reason === "not_in_lobby") removedFromLobby = true; // treat not_in_lobby as a successful leave.
+        } else {
+            console.error("Error with request lobby/leave", error);
+            notificationsApi.alert({
+                text: "Error with request lobby/leave",
+                severity: "error",
+            });
+        }
+    }
+    if (removedFromLobby) {
+        if (router.currentRoute.value.path == "/play/lobby") {
+            // We use replace instead of push so the user can't use "back".
+            router.replace("/play/customLobbies");
+        }
+        clearUserSubscriptions();
+        lobbyStore.activeLobby = undefined;
+        // Can't rejoin a battle tied to a lobby we're no longer in.
+        tachyonStore.springConnectionDetails = undefined;
+        tachyonStore.rejoinModalOpen = false;
     }
-    // If we ever use a specific view for a lobby instead of BattleDrawer, we need to push a route here
-    clearUserSubscriptions();
-    lobbyStore.activeLobby = undefined;
-    chat.clearLobbyChat();
 }
 
 /**
@@ -324,7 +367,7 @@ async function requestLeaveLobby() {
  */
 async function requestStartBattle() {
     try {
-        const response = await window.tachyon.request("lobby/startBattle");
+        const response = await tachyonRequest("lobby/startBattle");
         console.log("Tachyon: lobby/startBattle:", response.status);
     } catch (error) {
         console.error("Error with request lobby/startBattle", error);
@@ -341,7 +384,7 @@ async function requestStartBattle() {
  */
 async function requestAddBot(data: LobbyAddBotRequestData) {
     try {
-        const response = await window.tachyon.request("lobby/addBot", data);
+        const response = await tachyonRequest("lobby/addBot", data);
         console.log("Tachyon lobby/addBot", response);
     } catch (error) {
         console.error("Error with request lobby/addBot", error);
@@ -358,7 +401,7 @@ async function requestAddBot(data: LobbyAddBotRequestData) {
  */
 async function requestRemoveBot(data: LobbyRemoveBotRequestData) {
     try {
-        const response = await window.tachyon.request("lobby/removeBot", data);
+        const response = await tachyonRequest("lobby/removeBot", data);
         console.log("Tachyon lobby/removeBot:", response);
     } catch (error) {
         console.error("Error with request lobby/removeBot", error);
@@ -375,7 +418,7 @@ async function requestRemoveBot(data: LobbyRemoveBotRequestData) {
  */
 async function requestUpdateBot(data: LobbyUpdateBotRequestData) {
     try {
-        const response = await window.tachyon.request("lobby/updateBot", data);
+        const response = await tachyonRequest("lobby/updateBot", data);
         console.log("Tachyon lobby/updateBot:", response);
     } catch (error) {
         console.error("Error with request lobby/updateBot", error);
@@ -392,7 +435,7 @@ async function requestUpdateBot(data: LobbyUpdateBotRequestData) {
  */
 async function requestLobbyUpdate(data: LobbyUpdateRequestData) {
     try {
-        const response = await window.tachyon.request("lobby/update", data);
+        const response = await tachyonRequest("lobby/update", data);
         console.log("Tachyon lobby/update:", response);
     } catch (error) {
         console.error("Error with request lobby/update", error);
@@ -419,7 +462,9 @@ function onLobbyLeftEvent(data: LobbyLeftEventData) {
     if (!lobbyStore.activeLobby || lobbyStore.activeLobby.id != data.id) return;
     clearUserSubscriptions();
     lobbyStore.activeLobby = undefined;
-    chat.clearLobbyChat();
+    // Can't rejoin a battle tied to a lobby we've been removed from (e.g. kick/ban).
+    tachyonStore.springConnectionDetails = undefined;
+    tachyonStore.rejoinModalOpen = false;
     console.log("Tachyon event: lobby/left:", data);
     if (router.currentRoute.value.path == "/play/lobby") {
         // We use replace instead of push so the user can't use "back".
@@ -459,7 +504,7 @@ async function clearUserSubscriptions() {
  */
 async function requestUpdateClientStatus(data: LobbyUpdateClientStatusRequestData) {
     try {
-        const response = await window.tachyon.request("lobby/updateClientStatus", data);
+        const response = await tachyonRequest("lobby/updateClientStatus", data);
         console.log("Tachyon lobby/updateClientStatus:", response);
     } catch (error) {
         console.error("Error with request lobby/updateClientStatus", error);
@@ -469,10 +514,11 @@ async function requestUpdateClientStatus(data: LobbyUpdateClientStatusRequestDat
 
 /**
  * Request to join an active battle in the lobby as a spectator.
+ * TODO: Implement this on the UI side. It should only be enabled if there is an active battle _and_ the user does not already have the connection details.
  */
 async function requestJoinBattle() {
     try {
-        const response = await window.tachyon.request("lobby/joinBattle");
+        const response = await tachyonRequest("lobby/joinBattle");
         console.log("Tachyon lobby/joinBattle:", response);
     } catch (error) {
         console.error("Error with request lobby/joinBattle", error);
@@ -486,7 +532,7 @@ async function requestJoinBattle() {
  */
 async function requestVoteSubmit(data: LobbyVoteSubmitRequestData) {
     try {
-        const response = await window.tachyon.request("lobby/voteSubmit", data);
+        const response = await tachyonRequest("lobby/voteSubmit", data);
         console.log("Tachyon lobby/voteSubmit:", response);
     } catch (error) {
         console.error("Error with request lobby/voteSubmit", error);
@@ -500,7 +546,7 @@ async function requestVoteSubmit(data: LobbyVoteSubmitRequestData) {
  */
 async function requestAppointBoss(userId: string) {
     try {
-        const response = await window.tachyon.request("lobby/appointBoss", { userId });
+        const response = await tachyonRequest("lobby/appointBoss", { userId });
         console.log("Tachyon lobby/appointBoss:", response);
     } catch (error) {
         console.error("Error with request lobby/appointBoss", error);
@@ -515,7 +561,7 @@ async function requestAppointBoss(userId: string) {
  */
 async function requestKickBan(userId: string, until?: number) {
     try {
-        const response = await window.tachyon.request("lobby/kickban", { userId, banUntil: until });
+        const response = await tachyonRequest("lobby/kickban", { userId, banUntil: until });
         console.log("Tachyon lobby/kickban:", response);
     } catch (error) {
         console.error("Error with request lobby/kickban", error);
@@ -529,7 +575,7 @@ async function requestKickBan(userId: string, until?: number) {
  */
 async function requestUnboss(userId?: UserId) {
     try {
-        const response = await window.tachyon.request("lobby/unboss", { userId });
+        const response = await tachyonRequest("lobby/unboss", { userId });
         console.log("Tachyon lobby/unboss:", response);
     } catch (error) {
         console.error("Error with request lobby/unboss", error);
diff --git a/src/renderer/store/maps.store.ts b/src/renderer/store/maps.store.ts
index d0ccb22f8..7a51ebcac 100644
--- a/src/renderer/store/maps.store.ts
+++ b/src/renderer/store/maps.store.ts
@@ -43,11 +43,14 @@ export async function getRandomMap() {
 }
 
 export async function initMapsStore() {
-    if (mapsStore.isInitialized) return;
     return init();
 }
 
 async function init() {
+    if (mapsStore.isInitialized) {
+        console.warn("Maps store is already initialized. Skipping initialization.");
+        return;
+    }
     window.maps.onMapAdded((springName: string) => {
         console.debug("Received map added event", springName);
         mapsStore.availableMapNames.add(springName);
diff --git a/src/renderer/store/matchmaking.store.ts b/src/renderer/store/matchmaking.store.ts
index 9f1cef490..7f7e6b111 100644
--- a/src/renderer/store/matchmaking.store.ts
+++ b/src/renderer/store/matchmaking.store.ts
@@ -10,11 +10,13 @@ import {
     MatchmakingListOkResponseData,
     MatchmakingQueuesJoinedEventData,
     MatchmakingQueueUpdateEventData,
+    PrivateUser,
 } from "tachyon-protocol/types";
 import { tachyonStore } from "@renderer/store/tachyon.store";
 import { notificationsApi } from "@renderer/api/notifications";
 import { isTachyonErrorForCommand, tachyonRequest } from "@renderer/api/tachyon";
 import { onWentOffline } from "@renderer/utils/offline-signal";
+import { router } from "@renderer/router";
 
 // The server is the authority on the real ready-up deadline and will send its own
 // matchmaking/cancelled event if we miss it; this margin just narrows the window
@@ -88,6 +90,7 @@ function onQueueUpdateEvent(data: MatchmakingQueueUpdateEventData) {
 function onLostEvent() {
     console.log("Tachyon event: matchmaking/lost: no data");
     clearReadyTimers();
+    matchmakingStore.playersReady = 0;
     matchmakingStore.status = MatchmakingStatus.Searching;
 }
 
@@ -99,6 +102,8 @@ function onFoundUpdateEvent(data: MatchmakingFoundUpdateEventData) {
 function onCancelledEvent(data: MatchmakingCancelledEventData) {
     console.log("Tachyon event: matchmaking/cancelled:", data);
     clearReadyTimers();
+    matchmakingStore.playersReady = 0;
+    matchmakingStore.playersQueued = 0;
     matchmakingStore.status = MatchmakingStatus.Idle;
     if (data.reason === "version_changed") {
         sendListRequest();
@@ -121,6 +126,50 @@ function onFoundEvent(data: MatchmakingFoundEventData) {
     }, deadline - Date.now());
 }
 
+function onSelfUpdateFoundSignal(data: Extract<PrivateUser["matchmaking"], { state: "found" }>) {
+    console.log("User/self update: matchmaking/found state:", data);
+    clearReadyTimers();
+    matchmakingStore.selectedQueue = data.queue.id;
+    if (data.queue.hasAlreadyReadied) {
+        matchmakingStore.status = MatchmakingStatus.MatchAccepted;
+    } else {
+        matchmakingStore.status = MatchmakingStatus.MatchFound;
+        const deadline = data.queue.timeoutAt / 1000 - READY_TIMEOUT_SAFETY_MARGIN_MS; // Convert Unix timestamp from microseconds to milliseconds
+        matchmakingStore.readySecondsRemaining = Math.max(0, Math.ceil((deadline - Date.now()) / 1000));
+        matchmakingStore.readyCountdownInterval = window.setInterval(() => {
+            matchmakingStore.readySecondsRemaining = Math.max(0, Math.ceil((deadline - Date.now()) / 1000));
+        }, 1000);
+        matchmakingStore.queueTimeout = window.setTimeout(() => {
+            clearReadyTimers();
+            matchmakingStore.status = MatchmakingStatus.Idle;
+        }, deadline - Date.now());
+    }
+    router.push("/play/matchmaking");
+}
+
+function onUserSelfEventMatchmaking(data: PrivateUser["matchmaking"]) {
+    console.log("User/self update: matchmaking:", data);
+    switch (data.state) {
+        case "no_matchmaking":
+            clearReadyTimers();
+            matchmakingStore.playersReady = 0;
+            matchmakingStore.playersQueued = 0;
+            matchmakingStore.status = MatchmakingStatus.Idle;
+            break;
+        case "queuing":
+            clearReadyTimers();
+            matchmakingStore.status = MatchmakingStatus.Searching;
+            // We try to match to their selected queue, if it's available, or reset it if not.
+            if (!matchmakingStore.selectedQueue || !data.queues.some((q) => q.id === matchmakingStore.selectedQueue)) {
+                matchmakingStore.selectedQueue = data.queues[0]?.id ?? "1v1";
+            }
+            break;
+        case "found":
+            onSelfUpdateFoundSignal(data);
+            break;
+    }
+}
+
 function onQueuesJoinedEvent(data: MatchmakingQueuesJoinedEventData) {
     console.log("Tachyon event: matchmaking/queuesJoined:", data);
     // Current design is a single queue joined at a time. If the user has a *different* queue selected when their party joins, we switch so they match their party's selection.
@@ -136,7 +185,7 @@ async function sendListRequest() {
     matchmakingStore.isLoadingQueues = true;
     matchmakingStore.queueError = undefined;
     try {
-        const response = await window.tachyon.request("matchmaking/list");
+        const response = await tachyonRequest("matchmaking/list");
         console.log("Tachyon: matchmaking/list:", response.data);
         matchmakingStore.playlists = response.data.playlists;
 
@@ -247,7 +296,7 @@ async function sendCancelRequest() {
     clearReadyTimers();
     matchmakingStore.status = MatchmakingStatus.Idle;
     try {
-        const response = await window.tachyon.request("matchmaking/cancel");
+        const response = await tachyonRequest("matchmaking/cancel");
         console.log("Tachyon: matchmaking/cancel:", response.status);
     } catch (error) {
         console.error("Tachyon: matchmaking/cancel:", error);
@@ -263,7 +312,7 @@ async function sendReadyRequest() {
     clearReadyTimers();
     matchmakingStore.status = MatchmakingStatus.MatchAccepted;
     try {
-        const response = await window.tachyon.request("matchmaking/ready");
+        const response = await tachyonRequest("matchmaking/ready");
         console.log("Tachyon: matchmaking/ready:", response.status);
     } catch (error) {
         matchmakingStore.status = MatchmakingStatus.Idle;
@@ -274,7 +323,10 @@ async function sendReadyRequest() {
 }
 
 export async function initializeMatchmakingStore() {
-    if (matchmakingStore.isInitialized) return;
+    if (matchmakingStore.isInitialized) {
+        console.warn("Matchmaking store is already initialized. Skipping initialization.");
+        return;
+    }
 
     onWentOffline.add(clearOnlineState);
     window.tachyon.onEvent("matchmaking/queueUpdate", onQueueUpdateEvent);
@@ -289,6 +341,8 @@ export async function initializeMatchmakingStore() {
 
     window.tachyon.onEvent("matchmaking/queuesJoined", onQueuesJoinedEvent);
 
+    window.tachyon.onEvent("user/self", (data) => onUserSelfEventMatchmaking(data.user.matchmaking));
+
     if (tachyonStore.isConnected) {
         await sendListRequest();
     }
diff --git a/src/renderer/store/me.store.ts b/src/renderer/store/me.store.ts
index ea5c5a128..a6f662775 100644
--- a/src/renderer/store/me.store.ts
+++ b/src/renderer/store/me.store.ts
@@ -6,11 +6,20 @@ import { Me } from "@main/model/user";
 import { db } from "@renderer/store/db";
 import { reactive, toRaw, watch } from "vue";
 import { tachyon } from "@renderer/store/tachyon.store";
-import { PrivateUser } from "tachyon-protocol/types";
+import {
+    PrivateUser,
+    UserSelfEventData,
+    FriendRequestReceivedEventData,
+    FriendRequestAcceptedEventData,
+    FriendRequestRejectedEventData,
+    FriendRequestCancelledEventData,
+    FriendRemovedEventData,
+} from "tachyon-protocol/types";
 import { settingsStore } from "@renderer/store/settings.store";
 import { subsManager } from "@renderer/store/users.store";
 import { onWentOffline } from "@renderer/utils/offline-signal";
 import { notificationsApi } from "@renderer/api/notifications";
+import { tachyonRequest } from "@renderer/api/tachyon";
 
 export const me = reactive<
     Me & {
@@ -94,19 +103,19 @@ async function serverChanged() {
 // the profile view included, so our own record has to be in there too.
 // TODO tidy this up: the row is a snapshot of the whole reactive object, written
 // in two steps that aren't in one transaction, and nothing reads isMe any more.
-window.tachyon.onEvent("user/self", async (event) => {
-    console.debug(`Received user/self event: ${JSON.stringify(event)}`);
-    if (event && event.user) {
+async function onUserSelfEvent(data: UserSelfEventData) {
+    console.debug(`Received user/self event: ${JSON.stringify(data)}`);
+    if (data && data.user) {
         await db.users.where({ isMe: 1 }).modify({ isMe: 0 });
-        Object.assign(me, event.user);
+        Object.assign(me, data.user);
         db.users.put({
             ...toRaw(me),
             isMe: 1,
         });
 
-        await processFriendData(event.user);
+        await processFriendData(data.user);
     }
-});
+}
 
 // Process friend data and manage subscriptions
 async function processFriendData(userData: PrivateUser) {
@@ -127,30 +136,30 @@ async function processFriendData(userData: PrivateUser) {
     }
 }
 
-window.tachyon.onEvent("friend/requestReceived", async (event) => {
-    me.incomingFriendRequestUserIds.add(event.from);
-    await subscribeToUsers([event.from]);
-});
+async function onFriendRequestReceivedEvent(data: FriendRequestReceivedEventData) {
+    me.incomingFriendRequestUserIds.add(data.from);
+    await subscribeToUsers([data.from]);
+}
 
-window.tachyon.onEvent("friend/requestAccepted", async (event) => {
-    me.outgoingFriendRequestUserIds.delete(event.from);
-    me.friendUserIds.add(event.from);
-});
+async function onFriendRequestAcceptedEvent(data: FriendRequestAcceptedEventData) {
+    me.outgoingFriendRequestUserIds.delete(data.from);
+    me.friendUserIds.add(data.from);
+}
 
-window.tachyon.onEvent("friend/requestRejected", async (event) => {
-    me.outgoingFriendRequestUserIds.delete(event.from);
-    await unsubscribeFromUsers([event.from]);
-});
+async function onFriendRequestRejectedEvent(data: FriendRequestRejectedEventData) {
+    me.outgoingFriendRequestUserIds.delete(data.from);
+    await unsubscribeFromUsers([data.from]);
+}
 
-window.tachyon.onEvent("friend/requestCancelled", async (event) => {
-    me.incomingFriendRequestUserIds.delete(event.from);
-    await unsubscribeFromUsers([event.from]);
-});
+async function onFriendRequestCancelledEvent(data: FriendRequestCancelledEventData) {
+    me.incomingFriendRequestUserIds.delete(data.from);
+    await unsubscribeFromUsers([data.from]);
+}
 
-window.tachyon.onEvent("friend/removed", async (event) => {
-    me.friendUserIds.delete(event.from);
-    await unsubscribeFromUsers([event.from]);
-});
+async function onFriendRemovedEvent(data: FriendRemovedEventData) {
+    me.friendUserIds.delete(data.from);
+    await unsubscribeFromUsers([data.from]);
+}
 
 // Identity fields survive; they're persisted in db and used while offline.
 function clearOnlineState() {
@@ -163,7 +172,7 @@ export const auth = { login, goOnline, logout, clearOnlineState };
 // Friend methods
 export const friends = {
     async sendRequest(to: string) {
-        const response = await window.tachyon.request("friend/sendRequest", { to });
+        const response = await tachyonRequest("friend/sendRequest", { to });
         me.outgoingFriendRequestUserIds.add(to);
         await subscribeToUsers([to]);
         return response;
@@ -171,7 +180,7 @@ export const friends = {
 
     async acceptRequest(from: string) {
         try {
-            const response = await window.tachyon.request("friend/acceptRequest", { from });
+            const response = await tachyonRequest("friend/acceptRequest", { from });
             me.incomingFriendRequestUserIds.delete(from);
             me.friendUserIds.add(from);
             return response;
@@ -184,7 +193,7 @@ export const friends = {
 
     async rejectRequest(from: string) {
         try {
-            const response = await window.tachyon.request("friend/rejectRequest", { from });
+            const response = await tachyonRequest("friend/rejectRequest", { from });
             me.incomingFriendRequestUserIds.delete(from);
             await unsubscribeFromUsers([from]);
             return response;
@@ -198,7 +207,7 @@ export const friends = {
 
     async cancelRequest(to: string) {
         try {
-            const response = await window.tachyon.request("friend/cancelRequest", { to });
+            const response = await tachyonRequest("friend/cancelRequest", { to });
             me.outgoingFriendRequestUserIds.delete(to);
             await unsubscribeFromUsers([to]);
             return response;
@@ -212,7 +221,7 @@ export const friends = {
 
     async remove(userId: string) {
         try {
-            const response = await window.tachyon.request("friend/remove", { userId });
+            const response = await tachyonRequest("friend/remove", { userId });
             me.friendUserIds.delete(userId);
             await unsubscribeFromUsers([userId]);
             return response;
@@ -224,7 +233,7 @@ export const friends = {
 
     async fetchFriendList() {
         try {
-            const response = await window.tachyon.request("friend/list");
+            const response = await tachyonRequest("friend/list");
             console.debug(`Received friend/list event: ${JSON.stringify(response)}`);
 
             // Clear existing friend data and populate with new data
@@ -247,6 +256,10 @@ export const friends = {
 };
 
 export async function initMeStore() {
+    if (me.isInitialized) {
+        console.warn("Me store is already initialized. Skipping initialization.");
+        return;
+    }
     // Settings load in parallel with this, and the stored server arriving over
     // the default counts as a change. Reacting to that would sign out everyone
     // who does not use the default server, every launch.
@@ -271,6 +284,13 @@ export async function initMeStore() {
             friends.fetchFriendList();
         }
     });
+    // We need to register these listeners before we try to restore a previous session
+    window.tachyon.onEvent("user/self", onUserSelfEvent);
+    window.tachyon.onEvent("friend/requestReceived", onFriendRequestReceivedEvent);
+    window.tachyon.onEvent("friend/requestAccepted", onFriendRequestAcceptedEvent);
+    window.tachyon.onEvent("friend/requestRejected", onFriendRequestRejectedEvent);
+    window.tachyon.onEvent("friend/requestCancelled", onFriendRequestCancelledEvent);
+    window.tachyon.onEvent("friend/removed", onFriendRemovedEvent);
 
     // Last known, from whenever we were last connected. Absent on a fresh
     // install, in which case the defaults stand in until a socket says otherwise.
diff --git a/src/renderer/store/party.store.ts b/src/renderer/store/party.store.ts
index 68db943e2..d9e822d1f 100644
--- a/src/renderer/store/party.store.ts
+++ b/src/renderer/store/party.store.ts
@@ -14,12 +14,13 @@ import {
     PartyInviteRequestData,
     PartyKickMemberRequestData,
     UserId,
+    PrivateUser,
 } from "tachyon-protocol/types";
 import { reactive } from "vue";
 import { notificationsApi } from "@renderer/api/notifications";
+import { tachyonRequest } from "@renderer/api/tachyon";
 import { Party } from "@renderer/model/party";
 import { subsManager } from "@renderer/store/users.store";
-import { chat } from "@renderer/store/chat.store";
 import { onWentOffline } from "@renderer/utils/offline-signal";
 
 const partySymbol = Symbol("party.store");
@@ -54,7 +55,7 @@ async function requestAcceptInvite(data: PartyAcceptInviteRequestData) {
         currentParty = partyStore.activeParty;
     }
     try {
-        const response = await window.tachyon.request("party/acceptInvite", data);
+        const response = await tachyonRequest("party/acceptInvite", data);
         console.log("Tachyon: party/acceptInvite response:", response);
         // Client should receive a party/updated event upon joining, but if we were in a party before, we have to manually handle the removal of that one.
         // We don't do this before success, because we might not actually leave the other party on the serverside if the join fails!
@@ -75,7 +76,7 @@ async function requestAcceptInvite(data: PartyAcceptInviteRequestData) {
  */
 async function requestCancelInvite(data: PartyCancelInviteRequestData) {
     try {
-        const response = await window.tachyon.request("party/cancelInvite", data);
+        const response = await tachyonRequest("party/cancelInvite", data);
         console.log("Tachyon: party/cancelInvite:", response);
     } catch (error) {
         console.error("Tachyon error: party/cancelInvite:", error);
@@ -88,7 +89,7 @@ async function requestCancelInvite(data: PartyCancelInviteRequestData) {
  */
 async function requestCreate() {
     try {
-        const response = await window.tachyon.request("party/create");
+        const response = await tachyonRequest("party/create");
         console.log("Tachyon: party/create:", response);
         partyStore.parties.set(response.data.party.id, { ...response.data.party, seen: false });
         parseAllPartyData();
@@ -117,7 +118,7 @@ async function requestCreateAndInvite(userId: UserId) {
  */
 async function requestDeclineInvite(data: PartyDeclineInviteRequestData) {
     try {
-        const response = await window.tachyon.request("party/declineInvite", data);
+        const response = await tachyonRequest("party/declineInvite", data);
         console.log("Tachyon: party/declineInvite:", response);
         // Note; we do not get a party/updated event for the declined party, so we have to clear it ourselves.
         partyStore.parties.delete(data.partyId);
@@ -134,7 +135,7 @@ async function requestDeclineInvite(data: PartyDeclineInviteRequestData) {
  */
 async function requestInvite(data: PartyInviteRequestData) {
     try {
-        const response = await window.tachyon.request("party/invite", data);
+        const response = await tachyonRequest("party/invite", data);
         console.log("Tachyon: party/invite:", response);
         // Reminder; success is not "user joined party", but is instead "pending invite created".
     } catch (error) {
@@ -149,7 +150,7 @@ async function requestInvite(data: PartyInviteRequestData) {
  */
 async function requestKickMember(data: PartyKickMemberRequestData) {
     try {
-        const response = await window.tachyon.request("party/kickMember", data);
+        const response = await tachyonRequest("party/kickMember", data);
         console.log("Tachyon: party/kickMember:", response);
     } catch (error) {
         console.error("Tachyon error: party/kickMember:", error);
@@ -162,11 +163,10 @@ async function requestKickMember(data: PartyKickMemberRequestData) {
  */
 async function requestLeave() {
     try {
-        const response = await window.tachyon.request("party/leave");
+        const response = await tachyonRequest("party/leave");
         console.log("Tachyon: party/leave:", response);
         partyStore.parties.delete(partyStore.activeParty ?? "");
         parseAllPartyData();
-        chat.clearPartyChat();
     } catch (error) {
         console.error("Tachyon error: party/leave:", error);
         notificationsApi.alert({ text: "Error with request party/leave", severity: "error" });
@@ -184,7 +184,6 @@ function onRemovedEvent(data: PartyRemovedEventData) {
     // Note that "party/removed" includes cancelled or expired invitations in addition to being kicked/leaving.
     partyStore.parties.delete(data.partyId);
     parseAllPartyData();
-    chat.clearPartyChat();
 }
 
 function onUpdatedEvent(data: PartyUpdatedEventData) {
@@ -193,9 +192,25 @@ function onUpdatedEvent(data: PartyUpdatedEventData) {
     parseAllPartyData();
 }
 
+function onUserSelfEventParty({ party, invites }: { party: PrivateUser["party"]; invites: PrivateUser["invitedToParties"] }) {
+    if (party && party.id === partyStore.activeParty) {
+        // This is the only case where we want to preserve the chat history, so we keep activeParty
+        // The rest will be reset by parseAllPartyData().
+        subsManager.clearAllFromList(partySymbol);
+        partyStore.parties.clear();
+        partyStore.state = PlayersPartyState.None;
+    } else {
+        clearOnlineState();
+    }
+    const allParties = [...(party ? [party] : []), ...(invites || [])];
+    for (const partyState of allParties) {
+        partyStore.parties.set(partyState.id, { ...partyState, seen: false });
+    }
+    parseAllPartyData();
+}
+
 // We might be invited, or member, have to check to know.
 function parseAllPartyData() {
-    const previousParty = partyStore.activeParty;
     // Reset active party in case we are no longer in a party.
     partyStore.activeParty = undefined;
     const bools = {
@@ -218,13 +233,6 @@ function parseAllPartyData() {
     });
     subsManager.setList(users, partySymbol);
 
-    // Leaving clears the transcript, but going offline keeps it and sends no
-    // leave, so entering the next party has to clear that one. Comparing ids keeps
-    // a re-parse of the same party, which happens on every update, from wiping it.
-    if (partyStore.activeParty && partyStore.activeParty !== previousParty) {
-        chat.clearPartyChat();
-    }
-
     if (bools.joined) {
         if (bools.invited) {
             partyStore.state = PlayersPartyState.JoinedAndInvited;
@@ -250,12 +258,16 @@ export function onLogout() {
 }
 
 export async function initPartyStore() {
-    if (partyStore.isInitialized) return;
+    if (partyStore.isInitialized) {
+        console.warn("Party store is already initialized. Skipping initialization.");
+        return;
+    }
 
     onWentOffline.add(clearOnlineState);
     window.tachyon.onEvent("party/invited", onInvitedEvent);
     window.tachyon.onEvent("party/removed", onRemovedEvent);
     window.tachyon.onEvent("party/updated", onUpdatedEvent);
+    window.tachyon.onEvent("user/self", (data) => onUserSelfEventParty({ party: data.user.party, invites: data.user.invitedToParties }));
 
     partyStore.isInitialized = true;
 }
diff --git a/src/renderer/store/replays.store.ts b/src/renderer/store/replays.store.ts
index 85bdfae7d..5615822d3 100644
--- a/src/renderer/store/replays.store.ts
+++ b/src/renderer/store/replays.store.ts
@@ -23,6 +23,10 @@ export function acknowledgeReplay(fileName: string) {
 }
 
 export async function initReplaysStore() {
+    if (state.isInitialized) {
+        console.warn("Replays store is already initialized. Skipping initialization.");
+        return;
+    }
     window.replays.onReplayCached((replay: Replay) => {
         db.replays.put(replay).catch((error) => {
             console.error("Failed to store replay in database:", replay.fileName, error);
diff --git a/src/renderer/store/settings.store.ts b/src/renderer/store/settings.store.ts
index d6f34daaa..6fcfc55f3 100644
--- a/src/renderer/store/settings.store.ts
+++ b/src/renderer/store/settings.store.ts
@@ -18,7 +18,6 @@ export async function initSettingsStore() {
     }
     const currentSettings = await window.settings.getSettings();
     Object.assign(settingsStore, currentSettings);
-    settingsStore.isInitialized = true;
     watch(
         settingsStore,
         () => {
@@ -38,4 +37,5 @@ export async function initSettingsStore() {
             window.mainWindow.setSize(settingsStore.size);
         }
     );
+    settingsStore.isInitialized = true;
 }
diff --git a/src/renderer/store/tachyon.store.ts b/src/renderer/store/tachyon.store.ts
index 07e44ea7b..6ebdf271c 100644
--- a/src/renderer/store/tachyon.store.ts
+++ b/src/renderer/store/tachyon.store.ts
@@ -7,15 +7,24 @@ import { SystemServerStatsOkResponseData } from "tachyon-protocol/types";
 import { reactive } from "vue";
 import { matchmakingStore, matchmaking } from "@renderer/store/matchmaking.store";
 import { subsManager } from "@renderer/store/users.store";
-import { UserId } from "tachyon-protocol/types";
+import { UserId, PrivateUser } from "tachyon-protocol/types";
 import { notificationsApi } from "@renderer/api/notifications";
-import { chat, chatStore } from "@renderer/store/chat.store";
+import { tachyonRequest } from "@renderer/api/tachyon";
 import { onWentOffline } from "@renderer/utils/offline-signal";
+import { onTachyonConnected } from "@renderer/utils/connection-signal";
+import { createSpringString, SpringConnectionDetails } from "@shared/spring-string";
+
+type MultiplayerBattleConnectionDetails = SpringConnectionDetails & {
+    engine: { version: string };
+    game: { springName: string };
+};
 
 export const tachyonStore = reactive({
     isInitialized: false,
     isConnected: false,
     wantsConnection: false,
+    rejoinModalOpen: false,
+    springConnectionDetails: undefined,
     serverStats: undefined,
     error: undefined,
 } as {
@@ -25,6 +34,8 @@ export const tachyonStore = reactive({
     // close while this is false is deliberate, so it isn't worth complaining
     // about and shouldn't be retried.
     wantsConnection: boolean;
+    rejoinModalOpen: boolean;
+    springConnectionDetails?: MultiplayerBattleConnectionDetails;
     serverStats?: SystemServerStatsOkResponseData;
     error?: string;
     fetchServerStatsInterval?: NodeJS.Timeout;
@@ -76,6 +87,8 @@ async function goOffline() {
     tachyonStore.isConnected = false;
     tachyonStore.error = undefined;
     stopFetchingServerStats();
+    tachyonStore.springConnectionDetails = undefined;
+    tachyonStore.rejoinModalOpen = false;
 
     onWentOffline.dispatch();
 }
@@ -105,7 +118,7 @@ function startReconnecting() {
 async function fetchServerStats() {
     try {
         tachyonStore.error = undefined;
-        const response = await window.tachyon.request("system/serverStats");
+        const response = await tachyonRequest("system/serverStats");
         tachyonStore.serverStats = response.data;
     } catch (error) {
         console.error("Error fetching server stats:", error);
@@ -114,7 +127,29 @@ async function fetchServerStats() {
     }
 }
 
+function launchMultiplayerBattle(connectionDetails: MultiplayerBattleConnectionDetails) {
+    window.game.launchMultiplayer({
+        engineVersion: connectionDetails.engine.version,
+        gameVersion: connectionDetails.game.springName,
+        springString: createSpringString(connectionDetails),
+    });
+}
+
+function onUserSelfEventBattle(battle: PrivateUser["currentBattle"]) {
+    if (!battle) {
+        tachyonStore.springConnectionDetails = undefined;
+        tachyonStore.rejoinModalOpen = false;
+        return;
+    }
+    tachyonStore.springConnectionDetails = battle;
+    tachyonStore.rejoinModalOpen = true;
+}
+
 export async function initTachyonStore() {
+    if (tachyonStore.isInitialized) {
+        console.warn("Tachyon store is already initialized. Skipping initialization.");
+        return;
+    }
     tachyonStore.isConnected = await window.tachyon.isConnected();
     if (tachyonStore.isConnected) {
         fetchServerStats();
@@ -140,10 +175,7 @@ export async function initTachyonStore() {
             matchmaking.sendListRequest();
         }
 
-        // Subscribe to messages (all sources) when connected
-        if (chatStore.isInitialized) {
-            chat.requestSubscribeReceived();
-        }
+        onTachyonConnected.dispatch();
     });
 
     window.tachyon.onDisconnected(() => {
@@ -185,21 +217,26 @@ export async function initTachyonStore() {
         stopReconnecting();
     });
 
-    window.tachyon.onBattleStart((springString, data) => {
-        console.debug("Received battle start event", springString);
+    window.tachyon.onBattleStart((data) => {
+        console.debug("Received battle start event", data.ips[0], data.port);
         // tachyon.service.ts checks assets before sending this request here.
-        window.game.launchMultiplayer({
-            engineVersion: data.engine.version,
-            gameVersion: data.game.springName,
-            springString,
-        });
+        tachyonStore.springConnectionDetails = data;
+        launchMultiplayerBattle(data);
     });
 
+    window.tachyon.onBattleEnded((data) => {
+        console.debug("Received battle ended event", data);
+        tachyonStore.springConnectionDetails = undefined;
+        tachyonStore.rejoinModalOpen = false;
+    });
+
+    window.tachyon.onEvent("user/self", (data) => onUserSelfEventBattle(data.user.currentBattle));
+
     subsManager.onNewUsersAttached.add(async (users: UserId[]) => {
         if (!tachyonStore.isConnected) return;
 
         try {
-            const response = await window.tachyon.request("user/subscribeUpdates", { userIds: users });
+            const response = await tachyonRequest("user/subscribeUpdates", { userIds: users });
             console.log("Tachyon: user/subscribeUpdates", response);
         } catch (error) {
             console.error("Tachyon error: 'user/subscribeUpdates'", error);
@@ -212,7 +249,7 @@ export async function initTachyonStore() {
         if (!tachyonStore.isConnected) return;
 
         try {
-            const response = await window.tachyon.request("user/unsubscribeUpdates", { userIds: users });
+            const response = await tachyonRequest("user/unsubscribeUpdates", { userIds: users });
             console.log("Tachyon: user/unsubscribeUpdates", response);
         } catch (error) {
             console.error("Tachyon error: 'user/unsubscribeUpdates'", error);
@@ -225,4 +262,4 @@ export async function initTachyonStore() {
 
 // tachyonStore.reconnectInterval doubles as "are we still retrying", so a caller
 // can show that and call goOffline to give up.
-export const tachyon = { connect, goOffline };
+export const tachyon = { connect, goOffline, launchMultiplayerBattle };
diff --git a/src/renderer/store/users.store.ts b/src/renderer/store/users.store.ts
index e88c35593..2cc30a596 100644
--- a/src/renderer/store/users.store.ts
+++ b/src/renderer/store/users.store.ts
@@ -7,6 +7,7 @@ import { reactive } from "vue";
 import { SubsManager } from "@renderer/utils/subscriptions-manager";
 import { UserReportRequestData } from "tachyon-protocol/types";
 import { notificationsApi } from "@renderer/api/notifications";
+import { tachyonRequest } from "@renderer/api/tachyon";
 
 export const usersStore: {
     isInitialized: boolean;
@@ -17,7 +18,11 @@ export const usersStore: {
 export const subsManager = new SubsManager();
 
 export function initUsersStore() {
-    if (usersStore.isInitialized) return;
+    if (usersStore.isInitialized) {
+        console.warn("Users store is already initialized. Skipping initialization.");
+        return;
+    }
+
     window.tachyon.onEvent("user/updated", (event) => {
         console.debug(`Received user/updated event: ${JSON.stringify(event)}`);
         event.users.forEach(async (user) => {
@@ -53,7 +58,7 @@ export function initUsersStore() {
  */
 async function requestReportUsers(data: UserReportRequestData) {
     try {
-        const response = await window.tachyon.request("user/report", data);
+        const response = await tachyonRequest("user/report", data);
         console.log("Tachyon user/report:", response);
 
         return true;
diff --git a/src/renderer/utils/connection-signal.ts b/src/renderer/utils/connection-signal.ts
new file mode 100644
index 000000000..2899050b6
--- /dev/null
+++ b/src/renderer/utils/connection-signal.ts
@@ -0,0 +1,11 @@
+// SPDX-FileCopyrightText: 2026 The BAR Lobby Authors
+//
+// SPDX-License-Identifier: MIT
+
+import { Signal } from "$/jaz-ts-utils/signal";
+
+// Raised when the Tachyon connection comes up. It lives here rather than on
+// tachyon.store so that each store can react on its own: having tachyon.store
+// call into them instead means importing chat.store, which reaches lobby.store
+// and me.store, both of which import tachyon.store back.
+export const onTachyonConnected = new Signal<void>();
diff --git a/src/renderer/views/play/customLobbies.vue b/src/renderer/views/play/customLobbies.vue
index 0bbd9d3e2..56f5efc05 100644
--- a/src/renderer/views/play/customLobbies.vue
+++ b/src/renderer/views/play/customLobbies.vue
@@ -120,13 +120,14 @@ function sendLobbyJoinRequest(data) {
     //Data here is the entire selectedLobby object (e.g. one of the lobbyList[] items)
     if (lobbyStore.activeLobby == undefined) {
         // No active lobby so we can freely join without worrying about a leave needed first.
-        lobby.requestJoinLobby(data.id);
+        lobby.requestJoinLobby({ id: data.id, pushLobbyView: true });
         return;
-    } else if (lobbyStore.activeLobby.id == data.id) {
+    } else if (lobbyStore.activeLobby.id === data.id) {
         //We are trying to join a lobby we are already in, just open the view, no request needed.
         router.push("/play/lobby");
         return;
     }
+    // TODO: Get user confirmation that they want to leave a current lobby? Or do we just allow them to bounce?
 }
 
 // Because this page is part of <KeepAlive>, we use this instead of onMounted() to trigger anytime the page is loaded.
diff --git a/src/renderer/views/profile/party.vue b/src/renderer/views/profile/party.vue
index 6b1e1c07d..b96c29326 100644
--- a/src/renderer/views/profile/party.vue
+++ b/src/renderer/views/profile/party.vue
@@ -339,7 +339,8 @@ function displayInvites() {
 }
 
 function hasUnseenMessage() {
-    return chatStore.partyChat.at(-1)?.seen === false;
+    if (!partyStore.activeParty) return false;
+    return chatStore.partyChats.get(partyStore.activeParty)?.at(-1)?.seen === false;
 }
 
 function hasUnseenInvites() {
diff --git a/src/shared/spring-string.ts b/src/shared/spring-string.ts
new file mode 100644
index 000000000..59c52d3e2
--- /dev/null
+++ b/src/shared/spring-string.ts
@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: 2026 The BAR Lobby Authors
+//
+// SPDX-License-Identifier: MIT
+
+export interface SpringConnectionDetails {
+    ips: string[];
+    port: number;
+    username: string;
+    password: string;
+    battleId: string;
+}
+
+// TODO: Remove the backward compatibility for the `ip` field once the server is updated to Tachyon 1.24.0
+// @ts-expect-error ip is not part of SpringConnectionDetails but is used for backward server compatibility
+export function createSpringString({ ip, ips, port, username, password }: SpringConnectionDetails): string {
+    let effectiveIp: string = "";
+    if (!ips || ips.length === 0) {
+        if (ip) {
+            effectiveIp = ip;
+        } else throw new Error("No IPs provided for SpringString connection");
+    } else {
+        effectiveIp = ips[0];
+    }
+    // We only use the first provided IP for now, it will typically be the only one provided.
+    return `spring://${username}:${password}@${effectiveIp}:${port}`;
+}
diff --git a/tests/unit/main/tachyon-request-handler.spec.ts b/tests/unit/main/tachyon-request-handler.spec.ts
index 314c46576..758a5c5a7 100644
--- a/tests/unit/main/tachyon-request-handler.spec.ts
+++ b/tests/unit/main/tachyon-request-handler.spec.ts
@@ -4,7 +4,6 @@
 
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import type { TachyonClientRequestHandlers } from "@main/tachyon/tachyon-client";
-import { BattleStartRequestData } from "tachyon-protocol/types";
 
 const { send, missing } = vi.hoisted(() => ({ send: vi.fn(), missing: vi.fn() }));
 
@@ -27,23 +26,6 @@ describe("createTachyonRequestHandlers", () => {
         missing.mockReturnValue([]);
     });
 
-    it("handles battle/start by sending the spring url, data, and returning success", async () => {
-        const handlers = getHandlers();
-        const data: BattleStartRequestData = {
-            ip: "127.0.0.1",
-            port: 8452,
-            username: "tester",
-            password: "secret",
-            engine: { version: "105.1.1" },
-            game: { springName: "byar:test-game" },
-            map: { springName: "map:comet-catcher" },
-        };
-        const response = await handlers["battle/start"](data);
-
-        expect(send).toHaveBeenCalledWith("tachyon:battleStart", "spring://tester:secret@127.0.0.1:8452", data);
-        expect(response).toEqual({ status: "success" });
-    });
-
     it("returns complete when game, maps, and engines are all installed", async () => {
         const handlers = getHandlers();
 
diff --git a/tests/unit/renderer/app-component.spec.ts b/tests/unit/renderer/app-component.spec.ts
index b34b24f4b..43ab44dd0 100644
--- a/tests/unit/renderer/app-component.spec.ts
+++ b/tests/unit/renderer/app-component.spec.ts
@@ -75,6 +75,7 @@ vi.mock("vue-router", () => ({
         afterEach: vi.fn(),
     }),
 }));
+vi.mock("@renderer/router", () => ({ router: { push: vi.fn() } }));
 
 describe("App.vue", () => {
     it("renders the App root and lobby version", () => {
diff --git a/tests/unit/renderer/auth-projection.spec.ts b/tests/unit/renderer/auth-projection.spec.ts
index 93a87c532..bfeea035d 100644
--- a/tests/unit/renderer/auth-projection.spec.ts
+++ b/tests/unit/renderer/auth-projection.spec.ts
@@ -9,6 +9,7 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 const settings = vi.hoisted(() => ({ devMode: true, loginAutomatically: true }));
 
 vi.mock("@renderer/store/settings.store", () => ({ settingsStore: settings }));
+vi.mock("@renderer/router", () => ({ router: { push: vi.fn() } }));
 
 vi.mock("@renderer/store/users.store", () => ({
     subsManager: {
@@ -31,7 +32,7 @@ const authApi = {
     }),
 };
 
-const emptyFriendList = { data: { friends: [], outgoingPendingRequests: [], incomingPendingRequests: [] } };
+const emptyFriendList = { status: "success", data: { friends: [], outgoingPendingRequests: [], incomingPendingRequests: [] } };
 
 beforeEach(() => {
     vi.clearAllMocks();
@@ -48,7 +49,7 @@ beforeEach(() => {
     Object.assign(window.tachyon as any, {
         connect: vi.fn().mockResolvedValue(undefined),
         disconnect: vi.fn().mockResolvedValue(undefined),
-        request: vi.fn().mockResolvedValue(emptyFriendList),
+        requestStructured: vi.fn().mockResolvedValue(emptyFriendList),
         onConnected: vi.fn(),
         onDisconnected: vi.fn(),
     });
diff --git a/tests/unit/renderer/battle-rejoin.spec.ts b/tests/unit/renderer/battle-rejoin.spec.ts
new file mode 100644
index 000000000..c77c2547e
--- /dev/null
+++ b/tests/unit/renderer/battle-rejoin.spec.ts
@@ -0,0 +1,62 @@
+// SPDX-FileCopyrightText: 2026 The BAR Lobby Authors
+//
+// SPDX-License-Identifier: MIT
+
+import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@renderer/router", () => ({ router: { currentRoute: { value: { path: "/" } }, push: vi.fn(), replace: vi.fn() } }));
+vi.mock("@renderer/api/notifications", () => ({ notificationsApi: { alert: vi.fn() } }));
+
+const handlers = new Map<string, (data: unknown) => void>();
+
+Object.assign(window.tachyon, {
+    requestStructured: vi.fn(),
+    onConnected: vi.fn(),
+    onDisconnected: vi.fn(),
+    onEvent: (command: string, callback: (data: unknown) => void) => void handlers.set(command, callback),
+});
+Object.defineProperty(window, "auth", { value: { onChanged: vi.fn() }, writable: true });
+
+const { lobby, lobbyStore, initLobbyStore } = await import("@renderer/store/lobby.store");
+const { me } = await import("@renderer/store/me.store");
+const { tachyonStore } = await import("@renderer/store/tachyon.store");
+
+const emit = (command: string, data: unknown) => handlers.get(command)?.(data);
+
+describe("battle rejoin state", () => {
+    beforeAll(async () => {
+        me.userId = "1";
+        await initLobbyStore();
+    });
+
+    beforeEach(() => {
+        lobbyStore.activeLobby = undefined;
+        tachyonStore.springConnectionDetails = undefined;
+        tachyonStore.rejoinModalOpen = false;
+        vi.mocked(window.tachyon.requestStructured).mockReset();
+    });
+
+    it("clears stale rejoin state when a lobby update removes the battle", async () => {
+        const joinResponse = {
+            status: "success",
+            data: { id: "lobby-1", players: {}, spectators: {}, bots: {}, currentBattle: { id: "battle-1" } },
+        } satisfies Awaited<ReturnType<typeof window.tachyon.requestStructured>>;
+        vi.mocked(window.tachyon.requestStructured).mockResolvedValue(joinResponse);
+        await lobby.requestJoinLobby({ id: "lobby-1", pushLobbyView: true });
+        tachyonStore.springConnectionDetails = {
+            username: "player",
+            password: "secret",
+            ips: ["127.0.0.1"],
+            port: 8452,
+            engine: { version: "engine-version" },
+            game: { springName: "game-version" },
+            battleId: "battle-1",
+        } satisfies NonNullable<typeof tachyonStore.springConnectionDetails>;
+        tachyonStore.rejoinModalOpen = true;
+
+        emit("lobby/updated", { id: "lobby-1", currentBattle: null });
+
+        expect(tachyonStore.springConnectionDetails).toBeUndefined();
+        expect(tachyonStore.rejoinModalOpen).toBe(false);
+    });
+});
diff --git a/tests/unit/renderer/chat-account-change.spec.ts b/tests/unit/renderer/chat-account-change.spec.ts
index db50d9ff6..b27d3695f 100644
--- a/tests/unit/renderer/chat-account-change.spec.ts
+++ b/tests/unit/renderer/chat-account-change.spec.ts
@@ -5,13 +5,14 @@
 import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 
 vi.mock("@renderer/api/notifications", () => ({ notificationsApi: { alert: vi.fn() } }));
+vi.mock("@renderer/router", () => ({ router: { currentRoute: { value: { path: "/" } }, push: vi.fn(), replace: vi.fn() } }));
 
 const authHandlers: Array<(state: { authenticated: boolean }) => void> = [];
 
 const receivedHandlers: Array<(data: unknown) => void> = [];
 
 Object.assign(window.tachyon, {
-    request: vi.fn(),
+    requestStructured: vi.fn(),
     onEvent: (command: string, callback: (data: unknown) => void) => {
         if (command === "messaging/received") receivedHandlers.push(callback);
     },
@@ -38,8 +39,10 @@ describe("chat across an account change", () => {
     beforeEach(() => {
         chatStore.userChats.clear();
         chatStore.userChats.set("42", [{ message: "theirs" } as never]);
-        chatStore.lobbyChat.splice(0, chatStore.lobbyChat.length, { message: "in lobby" } as never);
-        chatStore.partyChat.splice(0, chatStore.partyChat.length, { message: "in party" } as never);
+        chatStore.lobbyChats.clear();
+        chatStore.lobbyChats.set("lobby1", [{ message: "in lobby" } as never]);
+        chatStore.partyChats.clear();
+        chatStore.partyChats.set("party1", [{ message: "in party" } as never]);
     });
 
     it("drops direct message history when the account signs out", () => {
@@ -51,8 +54,8 @@ describe("chat across an account change", () => {
     it("drops the lobby and party transcripts too", () => {
         signOut();
 
-        expect(chatStore.lobbyChat).toEqual([]);
-        expect(chatStore.partyChat).toEqual([]);
+        expect(chatStore.lobbyChats.size).toBe(0);
+        expect(chatStore.partyChats.size).toBe(0);
     });
 
     // Left attached, the next account keeps a subscription to someone it never spoke to.
@@ -78,6 +81,6 @@ describe("chat across an account change", () => {
         authHandlers.forEach((handler) => handler({ authenticated: true }));
 
         expect(chatStore.userChats.size).toBe(1);
-        expect(chatStore.lobbyChat).toHaveLength(1);
+        expect(chatStore.lobbyChats.size).toBe(1);
     });
 });
diff --git a/tests/unit/renderer/chat-history-marker.spec.ts b/tests/unit/renderer/chat-history-marker.spec.ts
index fa5714bdf..169741378 100644
--- a/tests/unit/renderer/chat-history-marker.spec.ts
+++ b/tests/unit/renderer/chat-history-marker.spec.ts
@@ -7,11 +7,12 @@ import { notificationsApi } from "@renderer/api/notifications";
 import { MessagingReceivedEventData, MessagingSubscribeReceivedRequestData } from "tachyon-protocol/types";
 
 vi.mock("@renderer/api/notifications", () => ({ notificationsApi: { alert: vi.fn() } }));
+vi.mock("@renderer/router", () => ({ router: { currentRoute: { value: { path: "/" } }, push: vi.fn(), replace: vi.fn() } }));
 
 const receivedHandlers: Array<(data: MessagingReceivedEventData) => void> = [];
 
 Object.assign(window.tachyon, {
-    request: vi.fn(async () => ({ data: { hasMissedMessages: false } })),
+    requestStructured: vi.fn(async () => ({ status: "success", data: { hasMissedMessages: false } })),
     onEvent: (command: string, callback: (data: MessagingReceivedEventData) => void) => {
         if (command === "messaging/received") receivedHandlers.push(callback);
     },
@@ -33,12 +34,12 @@ const receive = (data: Partial<MessagingReceivedEventData>) =>
     );
 
 const subscribedSince = () => {
-    const [, data] = vi.mocked(window.tachyon.request).mock.calls.at(-1) ?? [];
+    const [, data] = vi.mocked(window.tachyon.requestStructured).mock.calls.at(-1) ?? [];
 
     return (data as MessagingSubscribeReceivedRequestData | undefined)?.since;
 };
 
-const subscribeCount = () => vi.mocked(window.tachyon.request).mock.calls.filter(([command]) => command === "messaging/subscribeReceived").length;
+const subscribeCount = () => vi.mocked(window.tachyon.requestStructured).mock.calls.filter(([command]) => command === "messaging/subscribeReceived").length;
 
 describe("chat history marker", () => {
     beforeAll(async () => {
@@ -47,12 +48,12 @@ describe("chat history marker", () => {
 
     beforeEach(() => {
         chatStore.lastMarker = null;
-        chatStore.lobbyChat.length = 0;
-        chatStore.partyChat.length = 0;
+        chatStore.lobbyChats.clear();
+        chatStore.partyChats.clear();
         chatStore.userChats.clear();
         vi.mocked(notificationsApi.alert).mockClear();
-        vi.mocked(window.tachyon.request).mockReset();
-        vi.mocked(window.tachyon.request).mockResolvedValue({ data: { hasMissedMessages: false } } as never);
+        vi.mocked(window.tachyon.requestStructured).mockReset();
+        vi.mocked(window.tachyon.requestStructured).mockResolvedValue({ status: "success", data: { hasMissedMessages: false } } as never);
     });
 
     it("keeps the marker off the last message received", async () => {
@@ -145,7 +146,7 @@ describe("chat history marker", () => {
             receive({ source: { type: "lobby", lobbyId: "lobby-1", userId: "7" }, message: "missed two", marker: "-576460745790000" });
 
             expect(chatStore.userChats.get("42")?.map((m) => m.message)).toEqual(["hi", "missed one"]);
-            expect(chatStore.lobbyChat.map((m) => m.message)).toEqual(["missed two"]);
+            expect(chatStore.lobbyChats.get("lobby-1")?.map((m) => m.message)).toEqual(["missed two"]);
             expect(chatStore.lastMarker).toBe("-576460745790000");
         });
 
@@ -174,7 +175,7 @@ describe("chat history marker", () => {
         });
 
         it("tries again", async () => {
-            vi.mocked(window.tachyon.request).mockRejectedValueOnce(new Error("nope"));
+            vi.mocked(window.tachyon.requestStructured).mockRejectedValueOnce(new Error("nope"));
 
             await chat.requestSubscribeReceived();
             await vi.advanceTimersByTimeAsync(5000);
@@ -183,7 +184,7 @@ describe("chat history marker", () => {
         });
 
         it("gives up rather than retrying forever", async () => {
-            vi.mocked(window.tachyon.request).mockRejectedValue(new Error("nope"));
+            vi.mocked(window.tachyon.requestStructured).mockRejectedValue(new Error("nope"));
 
             await chat.requestSubscribeReceived();
             await vi.advanceTimersByTimeAsync(60_000);
@@ -193,7 +194,7 @@ describe("chat history marker", () => {
         });
 
         it("stops retrying once the user goes offline", async () => {
-            vi.mocked(window.tachyon.request).mockRejectedValueOnce(new Error("nope"));
+            vi.mocked(window.tachyon.requestStructured).mockRejectedValueOnce(new Error("nope"));
 
             await chat.requestSubscribeReceived();
             chat.clearOnlineState();
@@ -204,10 +205,10 @@ describe("chat history marker", () => {
 
         // Exhausting the retries must not poison the next connection.
         it("starts counting again on the next connect", async () => {
-            vi.mocked(window.tachyon.request).mockRejectedValue(new Error("nope"));
+            vi.mocked(window.tachyon.requestStructured).mockRejectedValue(new Error("nope"));
             await chat.requestSubscribeReceived();
             await vi.advanceTimersByTimeAsync(60_000);
-            vi.mocked(window.tachyon.request).mockClear();
+            vi.mocked(window.tachyon.requestStructured).mockClear();
 
             await chat.requestSubscribeReceived();
             await vi.advanceTimersByTimeAsync(5000);
diff --git a/tests/unit/renderer/chat-offline-input.spec.ts b/tests/unit/renderer/chat-offline-input.spec.ts
index 2c51aa7ac..b3260c53c 100644
--- a/tests/unit/renderer/chat-offline-input.spec.ts
+++ b/tests/unit/renderer/chat-offline-input.spec.ts
@@ -14,6 +14,7 @@ vi.mock("@renderer/store/chat.store", () => ({
 }));
 
 vi.mock("@renderer/store/tachyon.store", () => ({ tachyonStore: { isConnected: false } }));
+vi.mock("@renderer/router", () => ({ router: { currentRoute: { value: { path: "/" } }, push: vi.fn(), replace: vi.fn() } }));
 
 vi.mock("@renderer/composables/useDexieLiveQuery", () => ({
     useDexieLiveQueryWithDeps: () => ({ value: new Map() }),
diff --git a/tests/unit/renderer/chat-transcript-lifecycle.spec.ts b/tests/unit/renderer/chat-transcript-lifecycle.spec.ts
index 142b2dc7d..a69e2bd9d 100644
--- a/tests/unit/renderer/chat-transcript-lifecycle.spec.ts
+++ b/tests/unit/renderer/chat-transcript-lifecycle.spec.ts
@@ -10,7 +10,7 @@ vi.mock("@renderer/api/notifications", () => ({ notificationsApi: { alert: vi.fn
 const handlers = new Map<string, (data: unknown) => void>();
 
 Object.assign(window.tachyon, {
-    request: vi.fn(),
+    requestStructured: vi.fn(),
     onConnected: vi.fn(),
     onDisconnected: vi.fn(),
     onEvent: (command: string, callback: (data: unknown) => void) => void handlers.set(command, callback),
@@ -24,13 +24,13 @@ const { me } = await import("@renderer/store/me.store");
 
 const emit = (command: string, data: unknown) => handlers.get(command)?.(data);
 
-const lobbyPayload = (id: string) => ({ id, players: {}, spectators: {}, bots: {} });
+const lobbyPayload = (id: string) => ({ status: "success" as const, data: { id, players: {}, spectators: {}, bots: {} } });
 
 const partyPayload = (id: string) => ({ id, members: [{ userId: me.userId }], invited: [] });
 
-// Neither transcript is held per lobby or party, so entering the next one is what
-// has to clear it. Going offline no longer does, because the server session
-// holding the only other copy ends with it.
+// Each transcript is keyed by its own lobby/party id, so entering or leaving one
+// no longer has to clear anything: history for an id is simply there again if we
+// come back to it, and untouched while we're elsewhere.
 describe("chat transcript lifecycle", () => {
     beforeAll(async () => {
         me.userId = "1";
@@ -38,70 +38,72 @@ describe("chat transcript lifecycle", () => {
     });
 
     beforeEach(() => {
-        chatStore.lobbyChat.splice(0, chatStore.lobbyChat.length, { message: "said in the last lobby" } as never);
-        chatStore.partyChat.splice(0, chatStore.partyChat.length, { message: "said in the last party" } as never);
+        chatStore.lobbyChats.clear();
+        chatStore.lobbyChats.set("lobby-1", [{ message: "said in the last lobby" } as never]);
+        chatStore.partyChats.clear();
+        chatStore.partyChats.set("party-1", [{ message: "said in the last party" } as never]);
         lobbyStore.activeLobby = undefined;
         partyStore.parties.clear();
         partyStore.activeParty = undefined;
-        vi.mocked(window.tachyon.request).mockReset();
+        vi.mocked(window.tachyon.requestStructured).mockReset();
     });
 
     describe("lobbies", () => {
-        it("clears the previous lobby's chat on joining another", async () => {
-            vi.mocked(window.tachyon.request).mockResolvedValue({ data: lobbyPayload("lobby-2") } as never);
+        it("keeps another lobby's chat when joining a new one", async () => {
+            vi.mocked(window.tachyon.requestStructured).mockResolvedValue(lobbyPayload("lobby-2") as never);
 
-            await lobby.requestJoinLobby("lobby-2");
+            await lobby.requestJoinLobby({ id: "lobby-2", pushLobbyView: true });
 
-            expect(chatStore.lobbyChat).toEqual([]);
+            expect(chatStore.lobbyChats.get("lobby-1")).toEqual([{ message: "said in the last lobby" }]);
         });
 
-        it("clears the chat on leaving", async () => {
-            vi.mocked(window.tachyon.request).mockResolvedValue({ data: lobbyPayload("lobby-2") } as never);
-            await lobby.requestJoinLobby("lobby-2");
-            chatStore.lobbyChat.push({ message: "said in this lobby" } as never);
+        it("keeps the chat on leaving", async () => {
+            vi.mocked(window.tachyon.requestStructured).mockResolvedValue(lobbyPayload("lobby-2") as never);
+            await lobby.requestJoinLobby({ id: "lobby-2", pushLobbyView: true });
+            chatStore.lobbyChats.set("lobby-2", [{ message: "said in this lobby" } as never]);
 
             await lobby.requestLeaveLobby();
 
-            expect(chatStore.lobbyChat).toEqual([]);
+            expect(chatStore.lobbyChats.get("lobby-2")).toEqual([{ message: "said in this lobby" }]);
         });
 
-        it("clears the chat on being dropped from the lobby", async () => {
-            vi.mocked(window.tachyon.request).mockResolvedValue({ data: lobbyPayload("lobby-2") } as never);
-            await lobby.requestJoinLobby("lobby-2");
-            chatStore.lobbyChat.push({ message: "said in this lobby" } as never);
+        it("keeps the chat on being dropped from the lobby", async () => {
+            vi.mocked(window.tachyon.requestStructured).mockResolvedValue(lobbyPayload("lobby-2") as never);
+            await lobby.requestJoinLobby({ id: "lobby-2", pushLobbyView: true });
+            chatStore.lobbyChats.set("lobby-2", [{ message: "said in this lobby" } as never]);
 
             emit("lobby/left", { id: "lobby-2" });
 
-            expect(chatStore.lobbyChat).toEqual([]);
+            expect(chatStore.lobbyChats.get("lobby-2")).toEqual([{ message: "said in this lobby" }]);
         });
 
         // A lobby/updated event arrives on any change to the lobby we are already
         // in, so treating one as an entry would wipe the chat constantly.
         it("leaves the chat alone on an update to the lobby it is already in", async () => {
-            vi.mocked(window.tachyon.request).mockResolvedValue({ data: lobbyPayload("lobby-2") } as never);
-            await lobby.requestJoinLobby("lobby-2");
-            chatStore.lobbyChat.push({ message: "said in this lobby" } as never);
+            vi.mocked(window.tachyon.requestStructured).mockResolvedValue(lobbyPayload("lobby-2") as never);
+            await lobby.requestJoinLobby({ id: "lobby-2", pushLobbyView: true });
+            chatStore.lobbyChats.set("lobby-2", [{ message: "said in this lobby" } as never]);
 
-            emit("lobby/updated", { ...lobbyPayload("lobby-2"), name: "renamed" });
+            emit("lobby/updated", { ...lobbyPayload("lobby-2").data, name: "renamed" });
 
-            expect(chatStore.lobbyChat).toHaveLength(1);
+            expect(chatStore.lobbyChats.get("lobby-2")).toHaveLength(1);
         });
     });
 
     describe("parties", () => {
-        it("clears the previous party's chat on joining another", () => {
+        it("keeps another party's chat when a new one becomes active", () => {
             emit("party/updated", partyPayload("party-2"));
 
-            expect(chatStore.partyChat).toEqual([]);
+            expect(chatStore.partyChats.get("party-1")).toEqual([{ message: "said in the last party" }]);
         });
 
         it("leaves the chat alone on an update to the party it is already in", () => {
             emit("party/updated", partyPayload("party-2"));
-            chatStore.partyChat.push({ message: "said in this party" } as never);
+            chatStore.partyChats.set("party-2", [{ message: "said in this party" } as never]);
 
             emit("party/updated", partyPayload("party-2"));
 
-            expect(chatStore.partyChat).toHaveLength(1);
+            expect(chatStore.partyChats.get("party-2")).toHaveLength(1);
         });
     });
 });
diff --git a/tests/unit/renderer/connection-intent.spec.ts b/tests/unit/renderer/connection-intent.spec.ts
index 08f1489ff..a712ef035 100644
--- a/tests/unit/renderer/connection-intent.spec.ts
+++ b/tests/unit/renderer/connection-intent.spec.ts
@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: MIT
 
 import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import type { BattleEndedEventData, BattleStartRequestData, PrivateBattle, PrivateUser, UserSelfEventData } from "tachyon-protocol/types";
 
 vi.mock("@renderer/router", () => ({ router: { currentRoute: { value: { path: "/" } }, push: vi.fn(), replace: vi.fn() } }));
 
@@ -11,18 +12,24 @@ vi.mock("@renderer/api/notifications", () => ({ notificationsApi: { alert: vi.fn
 const connectHandlers: Array<() => void> = [];
 const disconnectHandlers: Array<() => void> = [];
 const authHandlers: Array<(state: { authenticated: boolean }) => void> = [];
+const battleStartHandlers: Array<(battle: BattleStartRequestData) => void> = [];
+const battleEndedHandlers: Array<(data: BattleEndedEventData) => void> = [];
+const eventHandlers = new Map<string, (data: unknown) => void>();
 
 const connect = vi.fn(async () => {});
 const disconnect = vi.fn(async () => {});
+const launchMultiplayer = vi.fn();
 
 Object.assign(window.tachyon, {
     isConnected: vi.fn(async () => false),
     connect,
     disconnect,
-    request: vi.fn(async () => ({ data: {} })),
+    requestStructured: vi.fn(async () => ({ status: "success", data: {} })),
     onConnected: (callback: () => void) => void connectHandlers.push(callback),
     onDisconnected: (callback: () => void) => void disconnectHandlers.push(callback),
-    onBattleStart: vi.fn(),
+    onBattleStart: (callback: (battle: BattleStartRequestData) => void) => void battleStartHandlers.push(callback),
+    onBattleEnded: (callback: (data: BattleEndedEventData) => void) => void battleEndedHandlers.push(callback),
+    onEvent: (command: string, callback: (data: unknown) => void) => void eventHandlers.set(command, callback),
 });
 
 Object.defineProperty(window, "auth", {
@@ -30,12 +37,15 @@ Object.defineProperty(window, "auth", {
     writable: true,
 });
 
+Object.defineProperty(window, "game", { value: { launchMultiplayer }, writable: true });
+
 const { tachyonStore, tachyon, initTachyonStore } = await import("@renderer/store/tachyon.store");
 const { me } = await import("@renderer/store/me.store");
 
 const simulateConnect = () => connectHandlers.forEach((handler) => handler());
 const simulateClose = () => disconnectHandlers.forEach((handler) => handler());
 const simulateSessionEnd = () => authHandlers.forEach((handler) => handler({ authenticated: false }));
+const simulateBattleEnded = () => battleEndedHandlers.forEach((handler) => handler({ battleId: "battle-1", players: [], spectators: [], winningAllyTeamIds: [] } satisfies BattleEndedEventData));
 
 describe("connection intent", () => {
     beforeAll(async () => {
@@ -48,6 +58,9 @@ describe("connection intent", () => {
         me.isAuthenticated = true;
         tachyonStore.isConnected = false;
         tachyonStore.wantsConnection = false;
+        tachyonStore.rejoinModalOpen = false;
+        tachyonStore.springConnectionDetails = undefined;
+        launchMultiplayer.mockClear();
     });
 
     afterEach(() => {
@@ -103,4 +116,71 @@ describe("connection intent", () => {
         vi.advanceTimersByTime(30000);
         expect(connect).not.toHaveBeenCalled();
     });
+
+    it("stores and immediately launches a server-started battle", () => {
+        const battle = {
+            ips: ["127.0.0.1"],
+            port: 8452,
+            username: "player",
+            password: "secret",
+            engine: { version: "engine-version" },
+            game: { springName: "game-version" },
+            map: { springName: "map-version" },
+            battleId: "battle-1",
+        } satisfies BattleStartRequestData;
+
+        battleStartHandlers.forEach((handler) => handler(battle));
+
+        expect(tachyonStore.springConnectionDetails).toEqual(battle);
+        expect(tachyonStore.rejoinModalOpen).toBe(false);
+        expect(launchMultiplayer).toHaveBeenCalledWith({
+            engineVersion: "engine-version",
+            gameVersion: "game-version",
+            springString: "spring://player:secret@127.0.0.1:8452",
+        });
+    });
+
+    it("stores a user/self currentBattle signal and opens the rejoin prompt without launching", () => {
+        const battle = {
+            ips: ["127.0.0.1"],
+            port: 8452,
+            username: "player",
+            password: "secret",
+            engine: { version: "engine-version" },
+            game: { springName: "game-version" },
+            map: { springName: "map-version" },
+            battleId: "battle-1",
+        } satisfies PrivateBattle;
+
+        const data = { user: { currentBattle: battle } as PrivateUser } satisfies UserSelfEventData;
+        eventHandlers.get("user/self")?.(data);
+
+        expect(tachyonStore.springConnectionDetails).toEqual(battle);
+        expect(tachyonStore.rejoinModalOpen).toBe(true);
+        expect(launchMultiplayer).not.toHaveBeenCalled();
+        // We claim that springConnectionDetails is not undefined because the test above already checked it, or failed.
+        tachyon.launchMultiplayerBattle(tachyonStore.springConnectionDetails!);
+
+        expect(launchMultiplayer).toHaveBeenCalledWith({
+            engineVersion: "engine-version",
+            gameVersion: "game-version",
+            springString: "spring://player:secret@127.0.0.1:8452",
+        });
+    });
+
+    it("clears spring connection details when a battle/ended event is received", () => {
+        tachyonStore.springConnectionDetails = {
+            ips: ["127.0.0.1"],
+            port: 8452,
+            username: "player",
+            password: "secret",
+            engine: { version: "engine-version" },
+            game: { springName: "game-version" },
+            battleId: "battle-1",
+        };
+
+        simulateBattleEnded();
+
+        expect(tachyonStore.springConnectionDetails).toBeUndefined();
+    });
 });
diff --git a/tests/unit/renderer/download-content-button.spec.ts b/tests/unit/renderer/download-content-button.spec.ts
index b362b50d9..caa3a866d 100644
--- a/tests/unit/renderer/download-content-button.spec.ts
+++ b/tests/unit/renderer/download-content-button.spec.ts
@@ -13,10 +13,13 @@ const { missing, ensure } = vi.hoisted(() => ({ missing: vi.fn(), ensure: vi.fn(
 vi.mock("@renderer/i18n", () => ({
     useTypedI18n: () => ({ t: (key: string) => key }),
 }));
+vi.mock("@renderer/router", () => ({ router: { push: vi.fn() } }));
 
 vi.mock("@renderer/api/notifications", () => ({
     notificationsApi: { alert: vi.fn() },
 }));
+// Cuts off the chat -> lobby -> battle store chain pulled in transitively, which this component has nothing to do with.
+vi.mock("@renderer/store/lobby.store", () => ({ lobbyStore: { activeLobby: undefined } }));
 
 vi.stubGlobal("window", Object.assign(window, { content: { missing, ensure } }));
 
diff --git a/tests/unit/renderer/reconnecting-overlay.spec.ts b/tests/unit/renderer/reconnecting-overlay.spec.ts
index f304d0cd0..31987e1f0 100644
--- a/tests/unit/renderer/reconnecting-overlay.spec.ts
+++ b/tests/unit/renderer/reconnecting-overlay.spec.ts
@@ -16,6 +16,7 @@ vi.mock("@renderer/store/tachyon.store", () => ({
     tachyon: { goOffline: stubs.goOffline },
 }));
 vi.mock("@renderer/i18n", () => ({ useTypedI18n: () => ({ t: (key: string) => key }) }));
+vi.mock("@renderer/router", () => ({ router: { push: vi.fn() } }));
 
 function mountWith(reconnectInterval?: NodeJS.Timeout) {
     stubs.store.reconnectInterval = reconnectInterval;
diff --git a/tests/unit/renderer/server-status.spec.ts b/tests/unit/renderer/server-status.spec.ts
index 49fcad1bb..d5afaabf7 100644
--- a/tests/unit/renderer/server-status.spec.ts
+++ b/tests/unit/renderer/server-status.spec.ts
@@ -22,6 +22,7 @@ const stubs = vi.hoisted(() => ({
 
 vi.mock("@renderer/i18n", () => ({ useTypedI18n: () => ({ t: (key: string) => key }) }));
 vi.mock("vue-router", () => ({ useRouter: () => ({ currentRoute: { value: { path: "/play" } } }) }));
+vi.mock("@renderer/router", () => ({ router: { push: vi.fn() } }));
 vi.mock("@renderer/composables/useLogInConfirmation", () => ({
     useLogInConfirmation: () => ({ openLogInConfirmation: stubs.openLogInConfirmation }),
 }));
diff --git a/tests/unit/renderer/server-switch.spec.ts b/tests/unit/renderer/server-switch.spec.ts
index 022cf949a..50d20ce3d 100644
--- a/tests/unit/renderer/server-switch.spec.ts
+++ b/tests/unit/renderer/server-switch.spec.ts
@@ -9,6 +9,7 @@ import { flushPromises } from "@vue/test-utils";
 vi.mock("@renderer/store/db", () => ({
     db: { users: { where: () => ({ first: async () => undefined, modify: async () => undefined }), put: vi.fn() } },
 }));
+vi.mock("@renderer/router", () => ({ router: { push: vi.fn() } }));
 
 const disconnect = vi.fn(async () => {});
 const onConnected = vi.fn(async () => {});
diff --git a/tests/unit/renderer/store-going-offline.spec.ts b/tests/unit/renderer/store-going-offline.spec.ts
index a1982601c..118d32aff 100644
--- a/tests/unit/renderer/store-going-offline.spec.ts
+++ b/tests/unit/renderer/store-going-offline.spec.ts
@@ -15,8 +15,9 @@ Object.assign(window.tachyon, {
     connect: vi.fn(async () => {}),
     disconnect: vi.fn(async () => {}),
     dropConnection: vi.fn(async () => {}),
-    request: vi.fn(async () => ({ data: {} })),
+    requestStructured: vi.fn(async () => ({ status: "success", data: {} })),
     onBattleStart: vi.fn(),
+    onBattleEnded: vi.fn(),
     onDisconnected: (callback: () => void) => void disconnectHandlers.push(callback),
     onConnected: (callback: () => void) => void connectHandlers.push(callback),
 });
@@ -48,8 +49,8 @@ function populateOnlineState() {
     lobbyStore.activeLobby = { id: "lobby-1" } as never;
     lobbyStore.wantsListSubscription = true;
 
-    chatStore.lobbyChat.splice(0, chatStore.lobbyChat.length, { userId: "1", text: "in lobby" } as never);
-    chatStore.partyChat.splice(0, chatStore.partyChat.length, { userId: "1", text: "in party" } as never);
+    chatStore.lobbyChats.set("lobby-1", [{ userId: "1", text: "in lobby" } as never]);
+    chatStore.partyChats.set("party-1", [{ userId: "1", text: "in party" } as never]);
     chatStore.userChats.set("1", [{ userId: "1", text: "dm" } as never]);
 }
 
@@ -114,8 +115,8 @@ describe("going offline", () => {
         it("keeps chat", () => {
             simulateClose();
 
-            expect(chatStore.lobbyChat).toHaveLength(1);
-            expect(chatStore.partyChat).toHaveLength(1);
+            expect(chatStore.lobbyChats.get("lobby-1")).toHaveLength(1);
+            expect(chatStore.partyChats.get("party-1")).toHaveLength(1);
         });
     });
 
@@ -139,8 +140,8 @@ describe("going offline", () => {
         it("keeps the chat transcript the server can no longer send us", async () => {
             await tachyon.goOffline();
 
-            expect(chatStore.lobbyChat).toHaveLength(1);
-            expect(chatStore.partyChat).toHaveLength(1);
+            expect(chatStore.lobbyChats.get("lobby-1")).toHaveLength(1);
+            expect(chatStore.partyChats.get("party-1")).toHaveLength(1);
         });
 
         it("drops the marker, which the ended session leaves pointing at nothing", async () => {
diff --git a/tests/unit/renderer/use-party-size-matchmaking.spec.ts b/tests/unit/renderer/use-party-size-matchmaking.spec.ts
index d5ab44150..0670f3cde 100644
--- a/tests/unit/renderer/use-party-size-matchmaking.spec.ts
+++ b/tests/unit/renderer/use-party-size-matchmaking.spec.ts
@@ -2,12 +2,14 @@
 //
 // SPDX-License-Identifier: MIT
 
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { vi, describe, it, expect, beforeEach, afterEach } from "vitest";
 import { effectScope, nextTick, type EffectScope, type Ref } from "vue";
 import { partyStore } from "@renderer/store/party.store";
 import { matchmakingStore } from "@renderer/store/matchmaking.store";
 import { usePartySizeMatchmaking, getPartySize } from "@renderer/composables/usePartySizeMatchmaking";
 
+vi.mock("@renderer/router", () => ({ router: { push: vi.fn() } }));
+
 function makePlaylist(id: string, teamSize: number) {
     return {
         id,
diff --git a/tests/unit/renderer/user-self-matchmaking.spec.ts b/tests/unit/renderer/user-self-matchmaking.spec.ts
new file mode 100644
index 000000000..15434f17f
--- /dev/null
+++ b/tests/unit/renderer/user-self-matchmaking.spec.ts
@@ -0,0 +1,124 @@
+// SPDX-FileCopyrightText: 2026 The BAR Lobby Authors
+//
+// SPDX-License-Identifier: MIT
+
+import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import type { PrivateUser, UserSelfEventData } from "tachyon-protocol/types";
+
+vi.mock("@renderer/router", () => ({ router: { push: vi.fn() } }));
+vi.mock("@renderer/api/notifications", () => ({ notificationsApi: { alert: vi.fn() } }));
+vi.mock("@renderer/store/db", () => ({
+    db: {
+        users: {
+            where: vi.fn(() => ({ modify: vi.fn(async () => 0) })),
+            put: vi.fn(),
+        },
+    },
+}));
+
+const eventHandlers = new Map<string, (data: unknown) => void>();
+
+Object.assign(window.tachyon, {
+    onEvent: (command: string, callback: (data: unknown) => void) => void eventHandlers.set(command, callback),
+    onConnected: vi.fn(),
+    requestStructured: vi.fn(async () => ({ status: "success", data: {} })),
+});
+
+const { MatchmakingStatus, initializeMatchmakingStore, matchmakingStore } = await import("@renderer/store/matchmaking.store");
+const { router } = await import("@renderer/router");
+
+function emitUserSelf(matchmaking: PrivateUser["matchmaking"]) {
+    const data = { user: { matchmaking } as PrivateUser } satisfies UserSelfEventData;
+    eventHandlers.get("user/self")?.(data);
+}
+
+describe("user/self matchmaking state", () => {
+    beforeAll(async () => {
+        await initializeMatchmakingStore();
+    });
+
+    beforeEach(() => {
+        vi.useFakeTimers();
+        matchmakingStore.status = MatchmakingStatus.Idle;
+        matchmakingStore.selectedQueue = "1v1";
+        matchmakingStore.queueTimeout = undefined;
+        matchmakingStore.readyCountdownInterval = undefined;
+        matchmakingStore.readySecondsRemaining = undefined;
+        vi.mocked(router.push).mockReset();
+    });
+
+    it("updates the selected queue when user/self reports queuing", async () => {
+        await emitUserSelf({ state: "queuing", queues: [{ id: "2v2", version: "1" }] });
+
+        expect(matchmakingStore.status).toBe(MatchmakingStatus.Searching);
+        expect(matchmakingStore.selectedQueue).toBe("2v2");
+    });
+
+    it("syncs the selected queue when user/self reports a found match", async () => {
+        await emitUserSelf({
+            state: "found",
+            queue: { id: "2v2", version: "1", timeoutAt: (Date.now() + 5000) * 1000, hasAlreadyReadied: false },
+            otherQueues: [],
+        });
+
+        expect(matchmakingStore.selectedQueue).toBe("2v2");
+    });
+
+    it("opens the matchmaking view and starts the ready countdown when user/self reports found", async () => {
+        const timeoutAt = (Date.now() + 5000) * 1000;
+
+        await emitUserSelf({
+            state: "found",
+            queue: { id: "1v1", version: "1", timeoutAt, hasAlreadyReadied: false },
+            otherQueues: [],
+        });
+
+        expect(matchmakingStore.status).toBe(MatchmakingStatus.MatchFound);
+        expect(matchmakingStore.readySecondsRemaining).toBeGreaterThan(0);
+        expect(matchmakingStore.readyCountdownInterval).toBeDefined();
+        expect(matchmakingStore.queueTimeout).toBeDefined();
+        expect(router.push).toHaveBeenCalledWith("/play/matchmaking");
+    });
+
+    it("returns to idle and clears the ready countdown when user/self reports no matchmaking", async () => {
+        matchmakingStore.playersQueued = 5;
+        matchmakingStore.playersReady = 3;
+
+        await emitUserSelf({
+            state: "found",
+            queue: { id: "1v1", version: "1", timeoutAt: (Date.now() + 5000) * 1000, hasAlreadyReadied: false },
+            otherQueues: [],
+        });
+
+        await emitUserSelf({ state: "no_matchmaking" });
+
+        expect(matchmakingStore.status).toBe(MatchmakingStatus.Idle);
+        expect(matchmakingStore.readySecondsRemaining).toBeUndefined();
+        expect(matchmakingStore.readyCountdownInterval).toBeUndefined();
+        expect(matchmakingStore.queueTimeout).toBeUndefined();
+        expect(matchmakingStore.playersQueued).toBe(0);
+        expect(matchmakingStore.playersReady).toBe(0);
+    });
+
+    it("clears readiness but keeps the queue count when matchmaking is lost", () => {
+        matchmakingStore.playersQueued = 5;
+        matchmakingStore.playersReady = 3;
+
+        eventHandlers.get("matchmaking/lost")?.(undefined);
+
+        expect(matchmakingStore.status).toBe(MatchmakingStatus.Searching);
+        expect(matchmakingStore.playersQueued).toBe(5);
+        expect(matchmakingStore.playersReady).toBe(0);
+    });
+
+    it("clears matchmaking counters when the match is cancelled", () => {
+        matchmakingStore.playersQueued = 5;
+        matchmakingStore.playersReady = 3;
+
+        eventHandlers.get("matchmaking/cancelled")?.({ reason: "user_cancelled" });
+
+        expect(matchmakingStore.status).toBe(MatchmakingStatus.Idle);
+        expect(matchmakingStore.playersQueued).toBe(0);
+        expect(matchmakingStore.playersReady).toBe(0);
+    });
+});
diff --git a/tests/unit/shared/spring-string.spec.ts b/tests/unit/shared/spring-string.spec.ts
new file mode 100644
index 000000000..1543011db
--- /dev/null
+++ b/tests/unit/shared/spring-string.spec.ts
@@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: 2026 The BAR Lobby Authors
+//
+// SPDX-License-Identifier: MIT
+
+import { createSpringString } from "@shared/spring-string";
+import { expect, it } from "vitest";
+
+it("creates the Spring launch URI", () => {
+    expect(createSpringString({ ips: ["127.0.0.1"], port: 8452, username: "tester", password: "secret", battleId: "battle-1" })).toBe("spring://tester:secret@127.0.0.1:8452");
+});
diff --git a/tsconfig.node.json b/tsconfig.node.json
index b2a56fcd2..80df66f2a 100644
--- a/tsconfig.node.json
+++ b/tsconfig.node.json
@@ -5,6 +5,7 @@
         "electron-builder.config.*",
         "src/main/**/*",
         "src/preload/**/*",
+        "src/shared/**/*",
         "vendor/**/*",
         "tests/**/main/**/*.ts",
         "tests/**/shared/**/*.ts",
@@ -21,6 +22,7 @@
             "@main/*": ["src/main/*"],
             "@preload/*": ["src/preload/*"],
             "@renderer/*": ["src/renderer/*"],
+            "@shared/*": ["src/shared/*"],
             "$/*": ["vendor/*", "tools/*"]
         },
         "strict": true,
diff --git a/tsconfig.web.json b/tsconfig.web.json
index 8a9123f3b..33187f306 100644
--- a/tsconfig.web.json
+++ b/tsconfig.web.json
@@ -7,6 +7,7 @@
         "src/renderer/**/*",
         "src/renderer/**/*.vue",
         "src/preload/*.d.ts",
+        "src/shared/**/*",
         "tests/**/renderer/**/*.ts",
         "tests/setup.renderer.mts"
     ],
@@ -18,6 +19,7 @@
             "@main/*": ["src/main/*"], // TODO: Remove direct references to main
             "@preload/*": ["src/preload/*"],
             "@renderer/*": ["src/renderer/*"],
+            "@shared/*": ["src/shared/*"],
             "$/*": ["vendor/*"]
         },
         "strict": true,
diff --git a/vite.main.config.mts b/vite.main.config.mts
index e6f3bf951..b615afe90 100644
--- a/vite.main.config.mts
+++ b/vite.main.config.mts
@@ -8,6 +8,7 @@ export default defineConfig({
             "@main": path.join(__dirname, "src/main"),
             "@renderer": path.join(__dirname, "src/renderer"),
             "@preload": path.join(__dirname, "src/preload"),
+            "@shared": path.join(__dirname, "src/shared"),
             $: path.join(__dirname, "vendor"),
         },
     },
diff --git a/vite.renderer.config.mts b/vite.renderer.config.mts
index fa535297e..0ff566749 100644
--- a/vite.renderer.config.mts
+++ b/vite.renderer.config.mts
@@ -11,6 +11,7 @@ export default defineConfig({
             "@main": path.join(__dirname, "src/main"),
             "@renderer": path.join(__dirname, "src/renderer"),
             "@preload": path.join(__dirname, "src/preload"),
+            "@shared": path.join(__dirname, "src/shared"),
             $: path.join(__dirname, "vendor"),
         },
     },
diff --git a/vitest.config.mts b/vitest.config.mts
index b6eb3ee3a..d3889ccf1 100644
--- a/vitest.config.mts
+++ b/vitest.config.mts
@@ -11,6 +11,7 @@ const alias = {
     "@main": path.resolve(__dirname, "./src/main"),
     "@renderer": path.resolve(__dirname, "./src/renderer"),
     "@preload": path.resolve(__dirname, "./src/preload"),
+    "@shared": path.resolve(__dirname, "./src/shared"),
     $: path.join(__dirname, "vendor"),
 };