Update tutorial modal handling during route changes

Update workflows with new task commands
Update build configuration for multi-architecture support
2026-01-14 20:28:35 -06:00 · 2026-01-14 19:49:06 -06:00 · 2026-01-14 19:47:08 -06:00 · 2026-01-14 19:46:45 -06:00 · 2026-01-14 19:30:17 -06:00 · 2026-01-14 19:30:08 -06:00
63 changed files with 3176 additions and 762 deletions
@@ -76,7 +76,7 @@ jobs:
              run: task install

            - name: Build Frontend and Prepare Android
-              run: task android-prepare
+              run: task android:prepare

            - name: Build Android APK
              run: |
@@ -17,8 +17,8 @@ jobs:

            - name: Build Arch Package
              run: |
-                  docker build -t arch-builder -f Dockerfile.arch-builder .
-                  docker run --rm -v $(pwd):/home/build/project arch-builder
+                  docker build --no-cache -t arch-builder -f Dockerfile.arch-builder .
+                  docker run --rm -v ${{ github.workspace }}/packaging/arch:/home/build/project arch-builder

            - name: Upload Artifact
              uses: https://git.quad4.io/actions/upload-artifact@ff15f0306b3f739f7b6fd43fb5d26cd321bd4de5 # v3.2.1
@@ -54,29 +54,29 @@ jobs:
              run: task install

            - name: Build Frontend
-              run: task build-frontend
+              run: task build:fe

            - name: Build Backend (Wheel)
-              run: task wheel
+              run: task build:wheel

            - name: Build Electron App (Linux)
-              run: pnpm run dist:linux
+              run: pnpm run dist:linux-x64

            - name: Build Electron App (RPM - Experimental)
              continue-on-error: true
-              run: task build-rpm
+              run: task dist:fe:rpm

            - name: Build Electron App (Flatpak - Experimental)
              continue-on-error: true
-              run: task build-flatpak
+              run: task dist:fe:flatpak

            - name: Build Electron App (Windows EXE and NSIS)
              env:
                  WINEDEBUG: -all
-              run: pnpm run dist:windows
+              run: pnpm run dist:win-x64

            - name: Build Electron App (ZIP)
-              run: task build-zip
+              run: task dist:fe:zip

            - name: Prepare release assets
              run: |
@@ -92,26 +92,50 @@ jobs:
              run: task install

            - name: Build Frontend
-              run: task build-frontend
+              run: task build:fe

            - name: Build Python wheel
-              run: task wheel
+              run: task build:wheel

            - name: Build Electron App (Appimage)
-              run: pnpm run dist:linux
+              run: pnpm run dist:linux-x64

            - name: Build Electron App (RPM)
              continue-on-error: true
-              run: task build-rpm
+              run: task dist:fe:rpm

            - name: Build Electron App (Flatpak)
              continue-on-error: true
-              run: task build-flatpak
+              run: task dist:fe:flatpak
+
+            - name: Setup Wine Environment
+              env:
+                  WINEDEBUG: -all
+                  WINEARCH: win64
+              run: |
+                  echo "Downloading Windows Python and Git..."
+                  wget -q https://www.python.org/ftp/python/3.13.1/python-3.13.1-amd64.exe
+                  wget -q https://github.com/git-for-windows/git/releases/download/v2.52.0.windows.1/Git-2.52.0-64-bit.exe
+
+                  echo "Initializing Wine prefix..."
+                  wine wineboot --init
+
+                  echo "Installing Python 3.13 into Wine..."
+                  wine python-3.13.1-amd64.exe /quiet InstallAllUsers=1 TargetDir=C:\Python313 PrependPath=1
+
+                  echo "Installing Git into Wine..."
+                  wine Git-2.52.0-64-bit.exe /VERYSILENT /NORESTART
+
+                  echo "Installing build dependencies in Wine Python..."
+                  wine C:/Python313/python.exe -m pip install --upgrade pip
+                  wine C:/Python313/python.exe -m pip install cx_Freeze poetry
+                  wine C:/Python313/python.exe -m pip install -r requirements.txt

            - name: Build Electron App (Windows EXE and NSIS)
              env:
                  WINEDEBUG: -all
-              run: pnpm run dist:windows
+                  WINE_PYTHON: "wine C:/Python313/python.exe"
+              run: task dist:win:wine

            - name: Prepare release assets
              run: |
@@ -29,13 +29,13 @@ jobs:
            - name: Setup Poetry
              run: pip install poetry
            - name: Setup Python environment
-              run: task setup-python-env
+              run: task setup:be
            - name: Install Node dependencies
-              run: task node_modules
+              run: task deps:fe
            - name: Lint
              run: |
-                  set -o pipefail
-                  task lint 2>&1 | tee lint_results.txt
+                set -o pipefail
+                task lint:all 2>&1 | tee lint_results.txt

    build-frontend:
        runs-on: ubuntu-latest
@@ -52,7 +52,7 @@ jobs:
              with:
                  version: "3.46.3"
            - name: Install dependencies
-              run: task node_modules
+              run: task deps:fe
            - name: Determine version
              id: version
              run: |
@@ -61,7 +61,7 @@ jobs:
            - name: Build frontend
              run: |
                  set -o pipefail
-                  task build-frontend 2>&1 | tee build_results.txt
+                  task build:fe 2>&1 | tee build_results.txt
              env:
                  VITE_APP_VERSION: ${{ steps.version.outputs.version }}

@@ -108,4 +108,4 @@ jobs:
            - name: Run language tests
              run: |
                  set -o pipefail
-                  task test-lang 2>&1 | tee lang_results.txt
+                  task test:lang 2>&1 | tee lang_results.txt
@@ -3,6 +3,8 @@ name: Build and Publish Docker Image
 on:
    workflow_dispatch:
    push:
+        branches:
+            - master
        tags:
            - "*"
    pull_request:
@@ -64,6 +66,7 @@ jobs:
                  file: ./Dockerfile
                  platforms: linux/amd64,linux/arm64
                  push: true
+                  no-cache: true
                  tags: ${{ steps.meta.outputs.tags }}
                  labels: ${{ steps.meta.outputs.labels }}

@@ -79,7 +82,7 @@ jobs:
                  trivy image --exit-code 1 "$IMAGE_TAG"

    build-dev:
-        if: github.event_name == 'pull_request'
+        if: github.event_name == 'pull_request' || github.ref == 'refs/heads/master'
        runs-on: ubuntu-latest
        permissions:
            contents: read
@@ -123,6 +126,7 @@ jobs:
                  file: ./Dockerfile
                  platforms: linux/amd64,linux/arm64
                  push: true
+                  no-cache: true
                  tags: ${{ steps.meta-dev.outputs.tags }}
                  labels: ${{ steps.meta-dev.outputs.labels }}

@@ -39,4 +39,4 @@ jobs:
            - name: Run tests
              run: |
                  set -o pipefail
-                  task test 2>&1 | tee test_results.txt
+                  task test:all 2>&1 | tee test_results.txt
@@ -2,7 +2,46 @@

 All notable changes to this project will be documented in this file.

-## [4.0.0] - 2026-01-03
+## [4.1.0] - 2026-01-14
+
+### New Features
+
+- **Advanced Diagnostic Engine**: 
+    - Mathematically grounded crash recovery system using **Probabilistic Active Inference**, **Shannon Entropy**, and **KL-Divergence**.
+    - **Deterministic Manifold Constraints**: Actively monitors structural system laws (V1: Version Integrity, V4: Resource Capacity).
+    - **Failure Manifold Mapping**: Identifies "Failure Manifolds" across the vertical stack, including RNS identity failures, LXMF storage issues, and interface offline states.
+- **RNS Auto-Configuration**: 
+    - Automatic creation and repair of the Reticulum configuration file (`~/.reticulum/config`) if it is missing, invalid, or corrupt.
+- **Improved Installation**: 
+    - Added support and documentation for installing via **Pre-built Wheels (.whl)** from releases, which bundle the built frontend for a simpler setup experience.
+- **Network Visualiser Optimization**: 
+    - Implemented **AbortController** support to cancel pending API requests on component unmount.
+    - Added high-performance batch fetching for path tables and announces (up to 1000 items per request).
+- **Announce Pagination**: 
+    - Added backend and database-level pagination for announces to improve UI responsiveness in large networks.
+
+### Improvements
+
+- **Reliability & Memory Management**: 
+    - Fixed a major concurrency issue where in-memory SQLite databases (`:memory:`) were not shared across background threads, causing "no such table" errors.
+    - Resolved `asyncio` event loop race conditions in `WebAudioBridge` using a lazy-loading loop property with fallback.
+    - Refactored `IdentityContext` teardown to ensure all managers are properly nullified and callbacks cleared, preventing memory leaks and reference cycles.
+    - Added client list cleanup in `WebAudioBridge` when calls end.
+- **UI/UX**: 
+    - Fixed a critical hang in the **Startup Wizard** where "Finish" or "Skip" buttons could become unresponsive.
+    - Improved UI navigation safety by automatically closing the tutorial modal when navigating away.
+    - Refined `MarkdownRenderer` regex patterns to prevent empty bold/italic tags and improved matching for single delimiters.
+- **Infrastructure & CI**:
+    - Added dedicated build scripts for **Arch Linux** packaging to handle permissions and `makepkg` execution.
+    - Updated Docker dev-image workflows to trigger on master branch pushes.
+    - Refactored telemetry data packing for more efficient location transmission.
+    - Updated dependencies including **Electron Forge (7.11.1)**, **Prettier (3.8.0)**, and ESLint plugins for better stability and formatting.
+- **Testing**: 
+    - Significant expansion of the test suite with **Property-Based Testing** (using `hypothesis`) to ensure robustness of the diagnostic engine, identity restoration, and markdown renderer.
+    - Added automated verification for Python version and legacy kernel compatibility diagnostics.
+    - Configured temporary log directory management for tests to improve portability.
+
+### [4.0.0] - 2026-01-03

 Season 1 Episode 1 - A MASSIVE REFACTOR

@@ -21,9 +21,10 @@ RUN apk add --no-cache gcc musl-dev linux-headers python3-dev libffi-dev openssl
 RUN python -m venv /opt/venv
 ENV PATH="/opt/venv/bin:$PATH"
 COPY pyproject.toml poetry.lock ./
-RUN pip install --no-cache-dir "pip>=25.3" poetry setuptools wheel && \
+RUN pip install --no-cache-dir --upgrade "pip>=25.3" poetry setuptools wheel "jaraco.context>=6.1.0" && \
    poetry config virtualenvs.create false && \
-    poetry install --no-root --only main
+    poetry install --no-root --only main && \
+    rm -rf /root/.cache/pip /root/.cache/pypoetry

 # Copy source code and built frontend
 COPY meshchatx ./meshchatx
@@ -41,7 +42,8 @@ WORKDIR /app
 # Install runtime dependencies only
 # We keep py3-setuptools because CFFI/LXST might need it at runtime on Python 3.12+
 RUN apk add --no-cache ffmpeg opusfile libffi su-exec py3-setuptools espeak-ng && \
-    python -m pip install --no-cache-dir --upgrade "pip>=25.3" && \
+    python -m pip install --no-cache-dir --upgrade "pip>=25.3" "jaraco.context>=6.1.0" && \
+    rm -rf /root/.cache/pip && \
    addgroup -g 1000 meshchat && adduser -u 1000 -G meshchat -S meshchat && \
    mkdir -p /config && chown meshchat:meshchat /config

@@ -28,12 +28,13 @@ RUN useradd -m build && \
    echo "build ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/build

 # Set up build directory
-USER build
+RUN mkdir -p /home/build/project && chown build:build /home/build/project
 WORKDIR /home/build/project

-# Copy packaging files
-COPY --chown=build:build packaging/arch /home/build/project/packaging/arch
+# Copy packaging files (optional if mounting, but good for standalone)
+COPY --chown=build:build packaging/arch /home/build/project/

 # Default command to build the package
-CMD ["/bin/bash", "-c", "cd packaging/arch && makepkg -s --noconfirm"]
+# The script is provided by the mounted volume or copied during build
+CMD ["/bin/bash", "/home/build/project/build.sh"]

@@ -20,7 +20,6 @@ A [Reticulum MeshChat](https://github.com/liamcottle/reticulum-meshchat) fork fr

 This project is separate from the original Reticulum MeshChat project, and is not affiliated with the original project.

-
 ## Goal

 To provide everything you need for Reticulum, LXMF, and LXST in one beautiful and feature-rich application.
@@ -54,6 +53,23 @@ docker compose up -d

 Check [releases](https://git.quad4.io/RNS-Things/MeshChatX/releases) for pre-built binaries (AppImage, DEB, EXE) if you prefer standalone apps. (coming soon)

+### Installation via Wheel (.whl)
+
+The simplest way to install MeshChatX on most systems is using the pre-built wheel from our releases. This package **bundles the built frontend**, so you don't need to deal with Node.js or building assets yourself. No Electron needed, it is a webserver basically, so you use your browser to access it.
+
+1. **Install directly from the release**:
+   ```bash
+   pip install https://git.quad4.io/RNS-Things/MeshChatX/releases/download/v4.1.0/reticulum_meshchatx-4.1.0-py3-none-any.whl
+
+   # pipx
+   pipx install https://git.quad4.io/RNS-Things/MeshChatX/releases/download/v4.1.0/reticulum_meshchatx-4.1.0-py3-none-any.whl
+   ```
+
+2. **Run MeshChatX**:
+   ```bash
+   meshchat --headless
+   ```
+
 ## Major Features

 - **Full LXST Support**: Custom voicemail, phonebook, contact sharing, and ringtone support.
@@ -67,6 +83,7 @@ Check [releases](https://git.quad4.io/RNS-Things/MeshChatX/releases) for pre-bui
 - **Page Archiving**: Built-in crawler and browser for archived pages offline.
 - **Banishment**: Banish LXMF users, Telephony, and NomadNet Nodes.
 - **i18n**: Support for English, German, Italian, and Russian.
+- **Advanced Diagnostic Engine**: Mathematically grounded crash recovery using Active Inference and Information Theory.

 ## Screenshots

@@ -180,6 +197,7 @@ If you want to run MeshChatX from the source code locally:
 If you are on Linux and want to build the Windows `.exe` and installer locally, you can use **Wine**.

 1. **Install Windows Python and Git inside Wine**:
+
    ```bash
    # Download Python installer
    wget https://www.python.org/ftp/python/3.13.1/python-3.13.1-amd64.exe
@@ -193,12 +211,14 @@ If you are on Linux and want to build the Windows `.exe` and installer locally,
    ```

 2. **Install Build Dependencies in Wine**:
+
    ```bash
    wine C:/Python313/python.exe -m pip install cx_Freeze poetry
    wine C:/Python313/python.exe -m pip install -r requirements.txt
    ```

 3. **Run the Build Task**:
+
    ```bash
    # Build only the Windows portable exe
    WINE_PYTHON="wine C:/Python313/python.exe" task build-exe-wine
@@ -225,37 +245,37 @@ MeshChatX can be configured via command-line arguments or environment variables.

 We use [Task](https://taskfile.dev/) for automation.

-| Task                          | Description                                    |
-| :---------------------------- | :--------------------------------------------- |
-| `task install`                | Install all dependencies                       |
-| `task run`                    | Run the application                            |
-| `task dev`                    | Run the application in development mode        |
-| `task lint`                   | Run all linters (Python & Frontend)            |
-| `task lint-python`            | Lint Python code only                          |
-| `task lint-frontend`          | Lint frontend code only                        |
-| `task format`                 | Format all code (Python & Frontend)            |
-| `task format-python`          | Format Python code only                        |
-| `task format-frontend`        | Format frontend code only                      |
-| `task test`                   | Run all tests                                  |
-| `task test:cov`               | Run tests with coverage reports                |
-| `task test-python`            | Run Python tests only                          |
-| `task test-frontend`          | Run frontend tests only                        |
-| `task build`                  | Build frontend and backend                     |
-| `task build-frontend`         | Build only the frontend                        |
-| `task wheel`                  | Build Python wheel package                     |
-| `task compile`                | Compile Python code to check for syntax errors |
-| `task build-docker`           | Build Docker image using buildx                |
-| `task run-docker`             | Run Docker container using docker-compose      |
-| `task build-appimage`         | Build Linux AppImage                           |
-| `task build-exe`              | Build Windows portable executable              |
-| `task build-exe-wine`         | Build Windows portable (Wine cross-build)      |
-| `task build-electron-linux`   | Build Linux Electron app                       |
-| `task build-electron-windows` | Build Windows Electron apps                    |
-| `task build-electron-all-wine`| Build all Electron apps (Wine cross-build)     |
-| `task android-prepare`        | Prepare Android build                          |
-| `task android-build`          | Build Android APK                              |
-| `task build-flatpak`          | Build Flatpak package                          |
-| `task clean`                  | Clean build artifacts and dependencies         |
+| Task                           | Description                                    |
+| :----------------------------- | :--------------------------------------------- |
+| `task install`                 | Install all dependencies                       |
+| `task run`                     | Run the application                            |
+| `task dev`                     | Run the application in development mode        |
+| `task lint`                    | Run all linters (Python & Frontend)            |
+| `task lint-python`             | Lint Python code only                          |
+| `task lint-frontend`           | Lint frontend code only                        |
+| `task format`                  | Format all code (Python & Frontend)            |
+| `task format-python`           | Format Python code only                        |
+| `task format-frontend`         | Format frontend code only                      |
+| `task test`                    | Run all tests                                  |
+| `task test:cov`                | Run tests with coverage reports                |
+| `task test-python`             | Run Python tests only                          |
+| `task test-frontend`           | Run frontend tests only                        |
+| `task build`                   | Build frontend and backend                     |
+| `task build-frontend`          | Build only the frontend                        |
+| `task wheel`                   | Build Python wheel package                     |
+| `task compile`                 | Compile Python code to check for syntax errors |
+| `task build-docker`            | Build Docker image using buildx                |
+| `task run-docker`              | Run Docker container using docker-compose      |
+| `task build-appimage`          | Build Linux AppImage                           |
+| `task build-exe`               | Build Windows portable executable              |
+| `task build-exe-wine`          | Build Windows portable (Wine cross-build)      |
+| `task build-electron-linux`    | Build Linux Electron app                       |
+| `task build-electron-windows`  | Build Windows Electron apps                    |
+| `task build-electron-all-wine` | Build all Electron apps (Wine cross-build)     |
+| `task android-prepare`         | Prepare Android build                          |
+| `task android-build`           | Build Android APK                              |
+| `task build-flatpak`           | Build Flatpak package                          |
+| `task clean`                   | Clean build artifacts and dependencies         |

 ## Security

@@ -270,6 +290,16 @@ We use [Task](https://taskfile.dev/) for automation.
 - Rootless docker images
 - Pinned actions and container images (supply chain security and deterministic builds)

+## Advanced Diagnostic Engine
+
+MeshChatX includes a uniquely sophisticated crash recovery system designed for the unpredictable hardware environments.
+
+- **Probabilistic Active Inference**: Uses Bayesian-inspired heuristics to determine root causes (e.g., OOM, RNS config issues, LXMF storage failures) with up to 99% confidence.
+- **Mathematical Grounding**: Quantifies system instability using Shannon Entropy and KL-Divergence, providing a numerical "disorder index" at the time of failure.
+- **Manifold Mapping**: Identifies "Failure Manifolds" across the entire vertical stack from Kernel and Python versions to RNS interface state and LXMF database integrity.
+
+All running locally on your own hardware and it might not be perfect, but it will only get better. The idea is to provide you the help to possibly fix it when you cannot reach me. 
+
 ## Credits

 - [Liam Cottle](https://github.com/liamcottle) - Original Reticulum MeshChat
@@ -56,129 +56,30 @@ tasks:
        cmds:
            - task --list

-    setup-python-env:
-        desc: Setup Python environment using Poetry
-        cmds:
-            - poetry install
-            - poetry run pip install ruff
-
-    lint-python:
-        desc: Lint Python code using ruff
-        cmds:
-            - poetry run ruff check .
-            - poetry run ruff format --check .
-
-    lint-frontend:
-        desc: Lint frontend code
-        cmds:
-            - "{{.NPM}} run lint"
-
-    lint:
-        desc: Run all linters (frontend and Python)
-        deps: [lint-frontend, lint-python]
-
-    format-python:
-        desc: Format Python code using ruff
-        cmds:
-            - poetry run ruff format ./ --exclude tests
-            - poetry run ruff check --fix ./ --exclude tests
-
-    format-frontend:
-        desc: Format frontend code using Prettier and ESLint
-        cmds:
-            - "{{.NPM}} run format"
-            - "{{.NPM}} run lint:fix"
-
-    format:
-        desc: Format all code (Python and frontend)
-        deps: [format-python, format-frontend]
-
-    test-python:
-        desc: Run Python tests using pytest
-        cmds:
-            - poetry run pytest tests/backend --cov=meshchatx/src/backend
-
-    test-python-cov:
-        desc: Run Python tests with detailed coverage report
-        cmds:
-            - poetry run pytest tests/backend --cov=meshchatx/src/backend --cov-report=term-missing
-
-    test-frontend:
-        desc: Run frontend tests using vitest
-        cmds:
-            - "{{.NPM}} run test -- --exclude tests/frontend/i18n.test.js"
-
-    test-lang:
-        desc: Run language and localization tests
-        cmds:
-            - "{{.NPM}} run test tests/frontend/i18n.test.js"
-            - "poetry run pytest tests/backend/test_translator_handler.py"
-
-    gen-locale-template:
-        desc: Generate a locales.json template with empty values from en.json
-        cmds:
-            - "{{.PYTHON}} scripts/generate_locale_template.py"
-
-    test:
-        desc: Run all tests
-        deps: [test-python, test-frontend, test-lang]
-
-    test:cov:
-        desc: Run all tests with coverage reports
-        deps: [test-python-cov, test-frontend]
-
-    check:
-        desc: Run format, lint and test
-        cmds:
-            - task: format
-            - task: lint
-            - task: test
-
-    bench-backend:
-        desc: Run comprehensive backend benchmarks
-        cmds:
-            - poetry run python tests/backend/run_comprehensive_benchmarks.py
-
-    bench-extreme:
-        desc: Run extreme backend stress benchmarks (Breaking Space Mode)
-        cmds:
-            - poetry run python tests/backend/run_comprehensive_benchmarks.py --extreme
-
-    profile-memory:
-        desc: Run backend memory profiling tests
-        cmds:
-            - poetry run pytest tests/backend/test_memory_profiling.py
-
-    test-integrity:
-        desc: Run backend and data integrity tests
-        cmds:
-            - poetry run pytest tests/backend/test_integrity.py tests/backend/test_backend_integrity.py
-
-    bench:
-        desc: Run all backend benchmarks and memory profiling
-        cmds:
-            - task: bench-backend
-            - task: profile-memory
-
-    compile:
-        desc: Compile Python code to check for syntax errors
-        cmds:
-            - "{{.PYTHON}} -m compileall meshchatx/"
+    # --- Initialization & Dependencies ---

    install:
-        desc: Install all dependencies (installs node modules and python deps)
-        deps: [node_modules, python]
+        desc: Install all dependencies (frontend and backend)
+        deps: [deps:fe, deps:be]

-    node_modules:
+    deps:fe:
        desc: Install Node.js dependencies
        cmds:
            - "{{.NPM}} install"

-    python:
+    deps:be:
        desc: Install Python dependencies using Poetry
        cmds:
            - "{{.PYTHON}} -m poetry install"

+    setup:be:
+        desc: Full backend environment setup
+        cmds:
+            - poetry install
+            - poetry run pip install ruff
+
+    # --- Execution ---
+
    run:
        desc: Run the application
        deps: [install]
@@ -186,160 +87,269 @@ tasks:
            - "{{.PYTHON}} -m poetry run meshchat"

    dev:
-        desc: Run the application in development mode
-        deps: [build-frontend]
+        desc: Run in development mode (builds frontend first)
+        deps: [build:fe]
        cmds:
            - task: run

-    build:
-        desc: Build the application (frontend and backend)
+    start:
+        desc: Run the application via Electron Forge
+        cmds:
+            - "{{.NPM}} run start"
+
+    package:
+        desc: Package the application with Electron Forge
+        cmds:
+            - "{{.NPM}} run package"
+
+    make:
+        desc: Generate distributables with Electron Forge
+        cmds:
+            - "{{.NPM}} run make"
+
+    # --- Code Quality ---
+
+    lint:all:
+        desc: Run all linters
+        deps: [lint:fe, lint:be]
+
+    lint:be:
+        desc: Lint Python code (ruff)
+        cmds:
+            - poetry run ruff check .
+            - poetry run ruff format --check .
+
+    lint:fe:
+        desc: Lint frontend code
+        cmds:
+            - "{{.NPM}} run lint"
+
+    fmt:all:
+        desc: Format all code
+        deps: [fmt:fe, fmt:be]
+
+    fmt:be:
+        desc: Format Python code (ruff)
+        cmds:
+            - poetry run ruff format ./ --exclude tests
+            - poetry run ruff check --fix ./ --exclude tests
+
+    fmt:fe:
+        desc: Format frontend code (Prettier/ESLint)
+        cmds:
+            - "{{.NPM}} run format"
+            - "{{.NPM}} run lint:fix"
+
+    # --- Testing & Analysis ---
+
+    test:all:
+        desc: Run all tests
+        deps: [test:be, test:fe, test:lang]
+
+    test:be:
+        desc: Run Python tests (pytest)
+        cmds:
+            - poetry run pytest tests/backend --cov=meshchatx/src/backend
+
+    test:be:cov:
+        desc: Run Python tests with detailed coverage
+        cmds:
+            - poetry run pytest tests/backend --cov=meshchatx/src/backend --cov-report=term-missing
+
+    test:fe:
+        desc: Run frontend tests (vitest)
+        cmds:
+            - "{{.NPM}} run test -- --exclude tests/frontend/i18n.test.js"
+
+    test:lang:
+        desc: Run localization tests
+        cmds:
+            - "{{.NPM}} run test tests/frontend/i18n.test.js"
+            - "poetry run pytest tests/backend/test_translator_handler.py"
+
+    test:integrity:
+        desc: Run data integrity tests
+        cmds:
+            - poetry run pytest tests/backend/test_integrity.py tests/backend/test_backend_integrity.py
+
+    test:cov:
+        desc: Run all tests with coverage
+        deps: [test:be:cov, test:fe]
+
+    bench:be:
+        desc: Run backend benchmarks
+        cmds:
+            - poetry run python tests/backend/run_comprehensive_benchmarks.py
+
+    bench:be:extreme:
+        desc: Run extreme stress benchmarks
+        cmds:
+            - poetry run python tests/backend/run_comprehensive_benchmarks.py --extreme
+
+    profile:mem:
+        desc: Run memory profiling
+        cmds:
+            - poetry run pytest tests/backend/test_memory_profiling.py
+
+    check:
+        desc: Run formatting, linting, and testing sequentially
+        cmds:
+            - task: fmt:all
+            - task: lint:all
+            - task: test:all
+
+    compile:
+        desc: Compile Python to check for syntax errors
+        cmds:
+            - "{{.PYTHON}} -m compileall meshchatx/"
+
+    # --- Build & Packaging ---
+
+    build:all:
+        desc: Build frontend and prepare backend
        deps: [install]
        cmds:
            - "{{.NPM}} run build"

-    build-frontend:
-        desc: Build only the frontend
-        deps: [node_modules]
+    build:fe:
+        desc: Build frontend assets
+        deps: [deps:fe]
        cmds:
            - "{{.NPM}} run build-frontend"

-    wheel:
+    build:wheel:
        desc: Build Python wheel package
        deps: [install]
        cmds:
            - "{{.PYTHON}} -m poetry build -f wheel"
            - "{{.PYTHON}} scripts/move_wheels.py"

-    build-appimage:
+    # --- Electron Distribution ---
+
+    dist:linux:appimage:
        desc: Build Linux AppImage
-        deps: [build-frontend]
+        deps: [build:fe]
        cmds:
            - "{{.NPM}} run electron-postinstall"
            - "PLATFORM=linux {{.NPM}} run build-backend"
            - "{{.NPM}} run dist -- --linux AppImage"

-    build-exe:
-        desc: Build Windows portable executable
-        deps: [build-frontend]
+    dist:linux:arm64:
+        desc: Build Linux arm64 AppImage
+        deps: [build:fe]
+        cmds:
+            - "{{.NPM}} run electron-postinstall"
+            - "PLATFORM=linux ARCH=arm64 {{.NPM}} run build-backend"
+            - "{{.NPM}} run dist -- --linux AppImage --arm64"
+
+    dist:win:exe:
+        desc: Build Windows portable EXE
+        deps: [build:fe]
        cmds:
            - "{{.NPM}} run electron-postinstall"
            - "PLATFORM=win32 {{.NPM}} run build-backend"
            - "{{.NPM}} run dist -- --win portable"

-    build-exe-wine:
-        desc: Build Windows portable executable and NSIS installer using Wine
-        deps: [build-frontend]
+    dist:win:arm64:
+        desc: Build Windows arm64 portable EXE
+        deps: [build:fe]
+        cmds:
+            - "{{.NPM}} run electron-postinstall"
+            - "PLATFORM=win32 ARCH=arm64 {{.NPM}} run build-backend"
+            - "{{.NPM}} run dist -- --win portable --arm64"
+
+    dist:win:wine:
+        desc: Build Windows EXE/Installer via Wine
+        deps: [build:fe]
        cmds:
            - "{{.NPM}} run electron-postinstall"
            - "PLATFORM=win32 PYTHON_CMD='{{.WINE_PYTHON}}' {{.NPM}} run build-backend"
            - "npx electron-builder --win portable nsis --publish=never"

-    build-electron-linux:
-        desc: Build Linux Electron app with prebuilt backend
-        deps: [build-frontend]
+    dist:fe:linux:
+        desc: Build Linux Electron app (prebuilt backend)
+        deps: [build:fe]
        cmds:
            - "{{.NPM}} run dist:linux"

-    build-rpm:
-        desc: Build Linux RPM package
-        deps: [build-frontend]
+    dist:fe:rpm:
+        desc: Build RPM package
+        deps: [build:fe]
        cmds:
            - "{{.NPM}} run dist:rpm"

-    build-flatpak:
-        desc: Build Linux Flatpak package
-        deps: [build-frontend]
+    dist:fe:flatpak:
+        desc: Build Flatpak package
+        deps: [build:fe]
        cmds:
            - "{{.NPM}} run dist:flatpak"

-    build-electron-windows:
-        desc: Build Windows Electron apps (portable and installer)
-        deps: [build-frontend]
+    dist:fe:win:
+        desc: Build Windows Electron apps
+        deps: [build:fe]
        cmds:
            - "{{.NPM}} run dist:windows"

-    build-zip:
-        desc: Build Electron ZIP archive using Electron Forge
-        deps: [build-frontend]
+    dist:fe:zip:
+        desc: Build Electron ZIP (Forge)
+        deps: [build:fe]
        cmds:
            - "PLATFORM=linux {{.NPM}} run build-backend"
            - "{{.NPM}} run dist:zip"

-    build-electron-all:
-        desc: Build all Electron apps (Linux and Windows)
-        deps: [build-frontend]
+    dist:all:
+        desc: Build all Electron apps (Linux + Win)
+        deps: [build:fe]
        cmds:
            - "{{.NPM}} run electron-postinstall"
            - "PLATFORM=linux {{.NPM}} run build-backend"
            - "PLATFORM=win32 {{.NPM}} run build-backend"
            - "{{.NPM}} run dist -- --linux AppImage deb --win portable nsis"

-    build-electron-all-wine:
-        desc: Build all Electron apps (Linux + Windows via Wine)
-        deps: [build-frontend]
+    dist:all:wine:
+        desc: Build all Electron apps (Linux + Win via Wine)
+        deps: [build:fe]
        cmds:
            - "{{.NPM}} run electron-postinstall"
            - "PLATFORM=linux {{.NPM}} run build-backend"
            - "PLATFORM=win32 PYTHON_CMD='{{.WINE_PYTHON}}' {{.NPM}} run build-backend"
            - "npx electron-builder --linux AppImage deb --win portable nsis --publish=never"

-    dist:
-        desc: Build distribution (defaults to AppImage)
-        cmds:
-            - task: build-appimage
+    # --- Legacy Electron Builds ---

-    electron-legacy:
-        desc: Install legacy Electron version
+    dist:legacy:linux:
+        desc: Build Linux AppImage (Legacy Electron)
+        deps: [build:fe]
        cmds:
-            - "{{.NPM}} install --no-save electron@{{.LEGACY_ELECTRON_VERSION}}"
-
-    build-appimage-legacy:
-        desc: Build Linux AppImage with legacy Electron version
-        deps: [build-frontend, electron-legacy]
-        cmds:
-            - "{{.NPM}} run electron-postinstall"
            - "PLATFORM=linux {{.NPM}} run build-backend"
-            - "{{.NPM}} run dist -- --linux AppImage -c.extraMetadata.main=electron/main-legacy.js"
-            - "./scripts/rename_legacy_artifacts.sh"
+            - "npx electron-builder -c package-legacy.json --linux AppImage --publish=never"

-    build-exe-legacy:
-        desc: Build Windows portable executable with legacy Electron version
-        deps: [build-frontend, electron-legacy]
+    dist:legacy:win:
+        desc: Build Windows EXE (Legacy Electron)
+        deps: [build:fe]
        cmds:
-            - "{{.NPM}} run electron-postinstall"
            - "PLATFORM=win32 {{.NPM}} run build-backend"
-            - "{{.NPM}} run dist -- --win portable -c.extraMetadata.main=electron/main-legacy.js"
-            - "./scripts/rename_legacy_artifacts.sh"
+            - "npx electron-builder -c package-legacy.json --win portable --publish=never"

-    forge-start:
-        desc: Run the application with Electron Forge
+    dist:legacy:win:wine:
+        desc: Build Windows EXE via Wine (Legacy Electron)
+        deps: [build:fe]
        cmds:
-            - "{{.NPM}} run start"
+            - "PLATFORM=win32 PYTHON_CMD='{{.WINE_PYTHON}}' {{.NPM}} run build-backend"
+            - "npx electron-builder -c package-legacy.json --win portable nsis --publish=never"

-    forge-package:
-        desc: Package the application with Electron Forge
+    dist:legacy:all:
+        desc: Build all Legacy apps
+        deps: [build:fe]
        cmds:
-            - "{{.NPM}} run package"
+            - "PLATFORM=linux {{.NPM}} run build-backend"
+            - "PLATFORM=win32 {{.NPM}} run build-backend"
+            - "npx electron-builder -c package-legacy.json --linux AppImage deb --win portable nsis --publish=never"

-    forge-make:
-        desc: Generate distributables with Electron Forge
-        cmds:
-            - "{{.NPM}} run make"
+    # --- Docker ---

-    clean:
-        desc: Clean build artifacts and dependencies
-        cmds:
-            - rm -rf node_modules
-            - rm -rf build
-            - rm -rf dist
-            - rm -rf python-dist
-            - rm -rf meshchatx/public
-            - rm -rf build-dir
-            - rm -rf out
-            - task: android-clean
-
-    build-docker:
-        desc: Build Docker image using buildx
+    docker:build:
+        desc: Build Docker image (buildx)
        cmds:
            - |
                if ! docker buildx inspect {{.DOCKER_BUILDER}} >/dev/null 2>&1; then
@@ -355,23 +365,23 @@ tasks:
                  -f {{.DOCKERFILE}} \
                  {{.DOCKER_CONTEXT}}

-    run-docker:
-        desc: Run Docker container using docker-compose
+    docker:run:
+        desc: Run Docker container (compose)
        cmds:
            - 'MESHCHAT_IMAGE="{{.DOCKER_IMAGE}}" {{.DOCKER_COMPOSE_CMD}} -f {{.DOCKER_COMPOSE_FILE}} up --remove-orphans --pull never reticulum-meshchatx'

-    run-docker-dev:
-        desc: Run Docker container in development mode using docker-compose.dev.yml
+    docker:run:dev:
+        desc: Run Docker container (dev compose)
        cmds:
            - 'MESHCHAT_IMAGE="{{.DOCKER_IMAGE}}" {{.DOCKER_COMPOSE_CMD}} -f docker-compose.dev.yml up --build --remove-orphans reticulum-meshchatx'

-    docker-build-env:
-        desc: Build the Docker image for containerized builds
+    docker:build:env:
+        desc: Build containerized build environment
        cmds:
            - docker build -t {{.DOCKER_BUILD_IMAGE}} -f {{.DOCKER_BUILD_FILE}} .

-    docker-build-artifacts:
-        desc: Build whls and electron artifacts inside a container and export them
+    docker:build:artifacts:
+        desc: Build and export artifacts from container
        cmds:
            - docker rm -f meshchat-build-temp || true
            - docker run --name meshchat-build-temp {{.DOCKER_BUILD_IMAGE}}
@@ -380,8 +390,10 @@ tasks:
            - docker cp meshchat-build-temp:/app/python-dist/. ./python-dist/
            - docker rm meshchat-build-temp

-    android-init:
-        desc: Initialize Gradle wrapper for Android project
+    # --- Android ---
+
+    android:init:
+        desc: Initialize Gradle wrapper
        cmds:
            - |
                if [ ! -f "{{.ANDROID_DIR}}/gradle/wrapper/gradle-wrapper.jar" ]; then
@@ -394,62 +406,68 @@ tasks:
                    echo "Gradle wrapper already initialized."
                fi

-    android-prepare:
-        desc: Prepare Android build (copy meshchatx package and assets)
-        deps: [build-frontend, android-init]
+    android:prepare:
+        desc: Prepare Android source assets
+        deps: [build:fe, android:init]
        cmds:
            - |
                echo "Copying meshchatx package and dependencies to Android project..."
                mkdir -p "{{.PYTHON_SRC_DIR}}"
-                # Remove old copies to ensure fresh build
                rm -rf "{{.PYTHON_SRC_DIR}}/meshchatx"
                rm -rf "{{.PYTHON_SRC_DIR}}/RNS"
                rm -rf "{{.PYTHON_SRC_DIR}}/LXMF"
                rm -rf "{{.PYTHON_SRC_DIR}}/LXST"

-                # Copy MeshChatX
                cp -r meshchatx "{{.PYTHON_SRC_DIR}}/"
-
-                # Vendor RNS, LXMF, and LXST from ./misc/ and ./src/
                cp -r ./misc/RNS "{{.PYTHON_SRC_DIR}}/"
                cp -r ./misc/LXMF "{{.PYTHON_SRC_DIR}}/"
                cp -r ./misc/LXST "{{.PYTHON_SRC_DIR}}/"
                cp -r ./src/RNS "{{.PYTHON_SRC_DIR}}/" || true
                cp -r ./src/LXMF "{{.PYTHON_SRC_DIR}}/" || true
                cp -r ./src/LXST "{{.PYTHON_SRC_DIR}}/" || true
-
-                # Copy pycodec2 wheel from ./misc
                cp "./misc/pycodec2-3.0.1-cp311-cp311-linux_aarch64.whl" "{{.PYTHON_SRC_DIR}}/" || true

-                # Copy native libraries from ./misc
                mkdir -p "{{.JNI_LIBS_DIR}}/arm64-v8a"
                mkdir -p "{{.JNI_LIBS_DIR}}/armeabi-v7a"
                cp "./misc/libcodec2-arm64-v8a.so" "{{.JNI_LIBS_DIR}}/arm64-v8a/" || true
                cp "./misc/libcodec2-armeabi-v7a.so" "{{.JNI_LIBS_DIR}}/armeabi-v7a/" || true

-                # Cleanup vendored packages (remove utilities/tests etc if needed, similar to Sideband)
                rm -rf "{{.PYTHON_SRC_DIR}}/RNS/Utilities/RNS"
                rm -rf "{{.PYTHON_SRC_DIR}}/LXMF/Utilities/LXMF"
                rm -rf "{{.PYTHON_SRC_DIR}}/LXST/Utilities/LXST"
-            - |
-                echo "Android build prepared. Don't forget to:"
-                echo "1. Add Chaquopy license to {{.ANDROID_DIR}}/local.properties"
-                echo "2. Open {{.ANDROID_DIR}}/ in Android Studio or run: task android-build"

-    android-build:
-        desc: Build Android APK (requires Android SDK and Chaquopy license)
-        deps: [android-prepare]
+    android:build:
+        desc: Build Debug APK
+        deps: [android:prepare]
        cmds:
            - cd "{{.ANDROID_DIR}}" && ./gradlew assembleDebug

-    android-build-release:
-        desc: Build Android APK (release, requires signing config)
-        deps: [android-prepare]
+    android:build:release:
+        desc: Build Release APK
+        deps: [android:prepare]
        cmds:
            - cd "{{.ANDROID_DIR}}" && ./gradlew assembleRelease

-    android-clean:
-        desc: Clean Android build artifacts
+    android:clean:
+        desc: Clean Android artifacts
        cmds:
            - cd "{{.ANDROID_DIR}}" && ./gradlew clean
            - rm -rf "{{.PYTHON_SRC_DIR}}/meshchatx"
+
+    # --- Maintenance ---
+
+    dist:
+        desc: Alias for dist:linux:appimage
+        cmds:
+            - task: dist:linux:appimage
+
+    clean:
+        desc: Nuke all build artifacts and dependencies
+        cmds:
+            - rm -rf node_modules build dist python-dist meshchatx/public build-dir out
+            - task: android:clean
+
+    locales:gen:
+        desc: Generate localization template
+        cmds:
+            - "{{.PYTHON}} scripts/generate_locale_template.py"
@@ -1,15 +1,76 @@
-const { app, BrowserWindow, dialog, ipcMain, shell, systemPreferences } = require("electron");
+const {
+    app,
+    BrowserWindow,
+    dialog,
+    ipcMain,
+    shell,
+    systemPreferences,
+    Notification,
+    powerSaveBlocker,
+} = require("electron");
 const electronPrompt = require("electron-prompt");
 const { spawn } = require("child_process");
 const fs = require("fs");
 const path = require("node:path");
+const crypto = require("crypto");

 // remember main window
 var mainWindow = null;

+// power save blocker id
+var activePowerSaveBlockerId = null;
+
 // remember child process for exe so we can kill it when app exits
 var exeChildProcess = null;

+// store integrity status
+var integrityStatus = {
+    backend: { ok: true, issues: [] },
+    data: { ok: true, issues: [] },
+};
+
+function verifyBackendIntegrity(exeDir) {
+    const manifestPath = path.join(exeDir, "backend-manifest.json");
+    if (!fs.existsSync(manifestPath)) {
+        log("Backend integrity manifest missing, skipping check.");
+        return { ok: true, issues: ["Manifest missing"] };
+    }
+
+    try {
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+        const issues = [];
+
+        const filesToVerify = manifest.files || manifest;
+        const metadata = manifest._metadata || {};
+
+        for (const [relPath, expectedHash] of Object.entries(filesToVerify)) {
+            const fullPath = path.join(exeDir, relPath);
+            if (!fs.existsSync(fullPath)) {
+                issues.push(`Missing: ${relPath}`);
+                continue;
+            }
+
+            const fileBuffer = fs.readFileSync(fullPath);
+            const actualHash = crypto.createHash("sha256").update(fileBuffer).digest("hex");
+            if (actualHash !== expectedHash) {
+                issues.push(`Modified: ${relPath}`);
+            }
+        }
+
+        if (issues.length > 0 && metadata.date && metadata.time) {
+            issues.unshift(`Backend build timestamp: ${metadata.date} ${metadata.time}`);
+        }
+
+        return {
+            ok: issues.length === 0,
+            issues: issues,
+        };
+    } catch (error) {
+        log(`Backend integrity check failed: ${error.message}`);
+        return { ok: false, issues: [error.message] };
+    }
+}
+
 // allow fetching app version via ipc
 ipcMain.handle("app-version", () => {
    return app.getVersion();
@@ -24,12 +85,43 @@ ipcMain.handle("is-hardware-acceleration-enabled", () => {
    return true; // Assume true for older versions
 });

-// allow fetching integrity status (Stub for legacy)
+// allow fetching integrity status
 ipcMain.handle("get-integrity-status", () => {
-    return {
-        backend: { ok: true, issues: ["Not supported in legacy mode"] },
-        data: { ok: true, issues: ["Not supported in legacy mode"] },
-    };
+    return integrityStatus;
+});
+
+// Native Notification IPC
+ipcMain.handle("show-notification", (event, { title, body, silent }) => {
+    const notification = new Notification({
+        title: title,
+        body: body,
+        silent: silent,
+    });
+    notification.show();
+
+    notification.on("click", () => {
+        if (mainWindow) {
+            mainWindow.show();
+            mainWindow.focus();
+        }
+    });
+});
+
+// Power Management IPC
+ipcMain.handle("set-power-save-blocker", (event, enabled) => {
+    if (enabled) {
+        if (activePowerSaveBlockerId === null) {
+            activePowerSaveBlockerId = powerSaveBlocker.start("prevent-app-suspension");
+            log("Power save blocker started.");
+        }
+    } else {
+        if (activePowerSaveBlockerId !== null) {
+            powerSaveBlocker.stop(activePowerSaveBlockerId);
+            activePowerSaveBlockerId = null;
+            log("Power save blocker stopped.");
+        }
+    }
+    return activePowerSaveBlockerId !== null;
 });

 // ignore ssl errors
@@ -80,6 +172,19 @@ ipcMain.handle("relaunch", () => {
    app.exit();
 });

+ipcMain.handle("relaunch-emergency", () => {
+    app.relaunch({ args: process.argv.slice(1).concat(["--emergency"]) });
+    app.exit();
+});
+
+ipcMain.handle("shutdown", () => {
+    quit();
+});
+
+ipcMain.handle("get-memory-usage", async () => {
+    return process.getProcessMemoryInfo();
+});
+
 // allow showing a file path in os file manager
 ipcMain.handle("showPathInFolder", (event, path) => {
    shell.showItemInFolder(path);
@@ -245,6 +350,13 @@ app.whenReady().then(async () => {

    log(`Found executable at: ${exe}`);

+    // Verify backend integrity before spawning
+    const exeDir = path.dirname(exe);
+    integrityStatus.backend = verifyBackendIntegrity(exeDir);
+    if (!integrityStatus.backend.ok) {
+        log(`INTEGRITY WARNING: Backend tampering detected! Issues: ${integrityStatus.backend.issues.join(", ")}`);
+    }
+
    try {
        // arguments we always want to pass in
        const requiredArguments = [
@@ -33,6 +33,7 @@ export default [
            "**/*.proto",
            "**/tests/**",
            "**/.pnpm-store/**",
+            "**/packaging/**",
        ],
    },
    {
@@ -74,7 +74,7 @@
        # Simple package definition for the backend
        packages.default = pkgs.python312Packages.buildPythonPackage {
          pname = "reticulum-meshchatx";
-          version = "4.0.0";
+          version = "4.1.0";
          src = ./.;
          format = "pyproject";

@@ -1,3 +1,3 @@
 """Reticulum MeshChatX - A mesh network communications app."""

-__version__ = "3.0.0"
+__version__ = "4.1.0"
@@ -556,6 +556,152 @@ class ReticulumMeshChat:
            raise RuntimeError("Database not initialized")
        return self.database.restore_database(backup_path)

+    def _ensure_reticulum_config(self):
+        """Ensures that a valid Reticulum config file exists at the expected location.
+        If the config is missing or invalid, it creates a sane default one.
+        """
+        config_dir = self.reticulum_config_dir or RNS.Reticulum.configpath
+        config_file = os.path.join(config_dir, "config")
+
+        should_recreate = False
+
+        if not os.path.exists(config_file):
+            should_recreate = True
+            print(
+                f"Reticulum config file not found at {config_file}, creating a default one...",
+            )
+        else:
+            try:
+                with open(config_file) as f:
+                    content = f.read()
+                    if "[reticulum]" not in content or "[interfaces]" not in content:
+                        print(
+                            f"Reticulum config file at {config_file} is invalid (missing essential sections), recreating...",
+                        )
+                        should_recreate = True
+            except Exception as e:
+                print(
+                    f"Failed to read Reticulum config at {config_file} ({e}), recreating...",
+                )
+                should_recreate = True
+
+        if should_recreate:
+            try:
+                if not os.path.exists(config_dir):
+                    os.makedirs(config_dir, exist_ok=True)
+
+                default_config = """# This is the default Reticulum config file.
+# You should probably edit it to include any additional,
+# interfaces and settings you might need.
+
+# Only the most basic options are included in this default
+# configuration. To see a more verbose, and much longer,
+# configuration example, you can run the command:
+# rnsd --exampleconfig
+
+
+[reticulum]
+  
+  # If you enable Transport, your system will route traffic
+  # for other peers, pass announces and serve path requests.
+  # This should only be done for systems that are suited to
+  # act as transport nodes, ie. if they are stationary and
+  # always-on. This directive is optional and can be removed
+  # for brevity.
+  
+  enable_transport = False
+  
+  
+  # By default, the first program to launch the Reticulum
+  # Network Stack will create a shared instance, that other
+  # programs can communicate with. Only the shared instance
+  # opens all the configured interfaces directly, and other
+  # local programs communicate with the shared instance over
+  # a local socket. This is completely transparent to the
+  # user, and should generally be turned on. This directive
+  # is optional and can be removed for brevity.
+  
+  share_instance = Yes
+  
+  
+  # If you want to run multiple *different* shared instances
+  # on the same system, you will need to specify different
+  # instance names for each. On platforms supporting domain
+  # sockets, this can be done with the instance_name option:
+  
+  instance_name = default
+  discover_interfaces = True
+  autoconnect_discovered_interfaces = 3
+  required_discovery_value = 16
+
+# Some platforms don't support domain sockets, and if that
+# is the case, you can isolate different instances by
+# specifying a unique set of ports for each:
+
+# shared_instance_port = 37428
+# instance_control_port = 37429
+
+
+# If you want to explicitly use TCP for shared instance
+# communication, instead of domain sockets, this is also
+# possible, by using the following option:
+
+# shared_instance_type = tcp
+
+
+# You can configure Reticulum to panic and forcibly close
+# if an unrecoverable interface error occurs, such as the
+# hardware device for an interface disappearing. This is
+# an optional directive, and can be left out for brevity.
+# This behaviour is disabled by default.
+
+# panic_on_interface_error = No
+
+
+[logging]
+  # Valid log levels are 0 through 7:
+  #   0: Log only critical information
+  #   1: Log errors and lower log levels
+  #   2: Log warnings and lower log levels
+  #   3: Log notices and lower log levels
+  #   4: Log info and lower (this is the default)
+  #   5: Verbose logging
+  #   6: Debug logging
+  #   7: Extreme logging
+  
+  loglevel = 4
+
+
+# The interfaces section defines the physical and virtual
+# interfaces Reticulum will use to communicate on. This
+# section will contain examples for a variety of interface
+# types. You can modify these or use them as a basis for
+# your own config, or simply remove the unused ones.
+
+[interfaces]
+  
+  # This interface enables communication with other
+  # link-local Reticulum nodes over UDP. It does not
+  # need any functional IP infrastructure like routers
+  # or DHCP servers, but will require that at least link-
+  # local IPv6 is enabled in your operating system, which
+  # should be enabled by default in almost any OS. See
+  # the Reticulum Manual for more configuration options.
+  
+  [[Default Interface]]
+    type = AutoInterface
+    enabled = false
+    name = Default Interface
+    selected_interface_mode = 1
+"""
+                with open(config_file, "w") as f:
+                    f.write(default_config)
+                print(f"Default Reticulum config created at {config_file}")
+            except Exception as e:
+                print(
+                    f"Failed to create default Reticulum config at {config_file}: {e}",
+                )
+
    def setup_identity(self, identity: RNS.Identity):
        identity_hash = identity.hash.hex()

@@ -574,6 +720,7 @@ class ReticulumMeshChat:

        # Initialize Reticulum if not already done
        if not hasattr(self, "reticulum"):
+            self._ensure_reticulum_config()
            self.reticulum = RNS.Reticulum(self.reticulum_config_dir)

        # Create new context
@@ -5525,14 +5672,40 @@ class ReticulumMeshChat:
                blocked_identity_hashes = [b["destination_hash"] for b in blocked]

            # fetch announces from database
+            # If we don't have a search query, we can paginate at the database level
+            # which is much faster than fetching thousands of records and then paginating in Python.
+            db_limit = limit if not search_query else None
+            db_offset = offset if not search_query else 0
+
            results = self.announce_manager.get_filtered_announces(
                aspect=aspect,
                identity_hash=identity_hash,
                destination_hash=destination_hash,
                query=None,  # We filter in Python to support name search
                blocked_identity_hashes=blocked_identity_hashes,
+                limit=db_limit,
+                offset=db_offset,
            )

+            # fetch total count if we paginated in DB
+            total_count = 0
+            if not search_query:
+                # Get the count from the database for the same filters
+                # We should probably add a get_filtered_announces_count method to announce_manager
+                if db_limit is None:
+                    total_count = len(results)
+                else:
+                    # We need the total count for pagination to work in the frontend
+                    total_count = self.announce_manager.get_filtered_announces_count(
+                        aspect=aspect,
+                        identity_hash=identity_hash,
+                        destination_hash=destination_hash,
+                        query=None,
+                        blocked_identity_hashes=blocked_identity_hashes,
+                    )
+
+            # ... rest of processing ...
+
            # pre-fetch icons and other data to avoid N+1 queries in convert_db_announce_to_dict
            other_user_hashes = [r["destination_hash"] for r in results]
            user_icons = {}
@@ -5671,13 +5844,14 @@ class ReticulumMeshChat:
                    )
                ]

-            # apply pagination
-            total_count = len(all_announces)
-            if offset is not None or limit is not None:
+                # Re-calculate total_count after search filter
+                total_count = len(all_announces)
+                # apply pagination after search
                start = offset
                end = start + (limit if limit is not None else total_count)
                paginated_results = all_announces[start:end]
            else:
+                # We already paginated in DB, and total_count was calculated before processing
                paginated_results = all_announces

            return web.json_response(
@@ -89,3 +89,44 @@ class AnnounceManager:
            params.extend([limit, offset])

        return self.db.provider.fetchall(sql, params)
+
+    def get_filtered_announces_count(
+        self,
+        aspect=None,
+        identity_hash=None,
+        destination_hash=None,
+        query=None,
+        blocked_identity_hashes=None,
+    ):
+        sql = """
+            SELECT COUNT(*) as count
+            FROM announces a
+            LEFT JOIN contacts c ON (
+                a.identity_hash = c.remote_identity_hash OR 
+                a.destination_hash = c.lxmf_address OR 
+                a.destination_hash = c.lxst_address
+            )
+            WHERE 1=1
+        """
+        params = []
+
+        if aspect:
+            sql += " AND a.aspect = ?"
+            params.append(aspect)
+        if identity_hash:
+            sql += " AND a.identity_hash = ?"
+            params.append(identity_hash)
+        if destination_hash:
+            sql += " AND a.destination_hash = ?"
+            params.append(destination_hash)
+        if query:
+            like_term = f"%{query}%"
+            sql += " AND (a.destination_hash LIKE ? OR a.identity_hash LIKE ?)"
+            params.extend([like_term, like_term])
+        if blocked_identity_hashes:
+            placeholders = ", ".join(["?"] * len(blocked_identity_hashes))
+            sql += f" AND a.identity_hash NOT IN ({placeholders})"
+            params.extend(blocked_identity_hashes)
+
+        result = self.db.provider.fetchone(sql, params)
+        return result["count"] if result else 0
@@ -12,6 +12,7 @@ class DatabaseProvider:
        self.db_path = db_path
        self._local = threading.local()
        self._all_locals.add(self._local)
+        self._memory_connection = None

    @classmethod
    def get_instance(cls, db_path=None):
@@ -29,6 +30,21 @@ class DatabaseProvider:

    @property
    def connection(self):
+        # In-memory databases are private to the connection.
+        # If we use threading.local(), each thread gets a DIFFERENT in-memory database.
+        # For :memory:, we must share the connection across threads.
+        if self.db_path == ":memory:":
+            if self._memory_connection is None:
+                with self._lock:
+                    if self._memory_connection is None:
+                        self._memory_connection = sqlite3.connect(
+                            self.db_path,
+                            check_same_thread=False,
+                            isolation_level=None,
+                        )
+                        self._memory_connection.row_factory = sqlite3.Row
+            return self._memory_connection
+
        if not hasattr(self._local, "connection"):
            # isolation_level=None enables autocommit mode, letting us manage transactions manually
            self._local.connection = sqlite3.connect(
@@ -38,7 +54,12 @@ class DatabaseProvider:
            )
            self._local.connection.row_factory = sqlite3.Row
            # Enable WAL mode for better concurrency
-            self._local.connection.execute("PRAGMA journal_mode=WAL")
+            if self.db_path != ":memory:":
+                try:
+                    self._local.connection.execute("PRAGMA journal_mode=WAL")
+                except sqlite3.OperationalError:
+                    # Some environments might not support WAL
+                    pass
        return self._local.connection

    def execute(self, query, params=None, commit=None):
@@ -115,6 +136,14 @@ class DatabaseProvider:
        return [dict(row) for row in rows]

    def close(self):
+        if self.db_path == ":memory:" and self._memory_connection:
+            try:
+                self._memory_connection.commit()
+                self._memory_connection.close()
+            except Exception:  # noqa: S110
+                pass
+            self._memory_connection = None
+
        if hasattr(self._local, "connection"):
            try:
                self.commit()  # Ensure everything is saved
@@ -125,6 +154,14 @@ class DatabaseProvider:

    def close_all(self):
        with self._lock:
+            if self._memory_connection:
+                try:
+                    self._memory_connection.commit()
+                    self._memory_connection.close()
+                except Exception:  # noqa: S110
+                    pass
+                self._memory_connection = None
+
            for loc in self._all_locals:
                if hasattr(loc, "connection"):
                    try:
@@ -454,6 +454,7 @@ class IdentityContext:
        self.running = False
        if self.auto_propagation_manager:
            self.auto_propagation_manager.stop()
+            self.auto_propagation_manager = None

        # 1. Deregister announce handlers
        for handler in self.announce_handlers:
@@ -466,6 +467,13 @@ class IdentityContext:
        # 2. Cleanup RNS destinations and links
        try:
            if self.message_router:
+                # Break cycles in mocks/objects
+                if hasattr(self.message_router, "register_delivery_callback"):
+                    try:
+                        self.message_router.register_delivery_callback(None)
+                    except Exception:
+                        pass
+
                if hasattr(self.message_router, "delivery_destinations"):
                    for dest_hash in list(
                        self.message_router.delivery_destinations.keys(),
@@ -509,21 +517,57 @@ class IdentityContext:
                print(
                    f"Error while tearing down LXMRouter for {self.identity_hash}: {e}",
                )
+            self.message_router = None

        # 4. Stop telephone and voicemail
        if self.telephone_manager:
            try:
+                # Clear callbacks to break reference cycles
+                self.telephone_manager.on_initiation_status_callback = None
+                self.telephone_manager.get_name_for_identity_hash = None
+
                self.telephone_manager.teardown()
            except Exception as e:
                print(
                    f"Error while tearing down telephone for {self.identity_hash}: {e}",
                )
+            self.telephone_manager = None
+
+        if self.voicemail_manager:
+            try:
+                self.voicemail_manager.on_new_voicemail_callback = None
+                self.voicemail_manager.get_name_for_identity_hash = None
+            except Exception:
+                pass
+            self.voicemail_manager = None
+
+        if self.message_handler:
+            self.message_handler = None
+
+        if self.announce_manager:
+            self.announce_manager = None
+
+        if self.archiver_manager:
+            self.archiver_manager = None
+
+        if self.map_manager:
+            self.map_manager = None
+
+        if self.docs_manager:
+            self.docs_manager = None
+
+        if self.nomadnet_manager:
+            self.nomadnet_manager = None

        if self.bot_handler:
            try:
                self.bot_handler.stop_all()
            except Exception as e:
                print(f"Error while stopping bots for {self.identity_hash}: {e}")
+            self.bot_handler = None
+
+        if self.forwarding_manager:
+            self.forwarding_manager = None

        if self.database:
            try:
@@ -535,6 +579,21 @@ class IdentityContext:
                )

            # 2. Save integrity manifest AFTER closing to capture final stable state
-            self.integrity_manager.save_manifest()
+            if self.integrity_manager:
+                self.integrity_manager.save_manifest()
+            self.database = None
+
+        if self.config:
+            self.config = None
+
+        if self.integrity_manager:
+            self.integrity_manager = None
+
+        if self.local_lxmf_destination:
+            self.local_lxmf_destination = None
+
+        # Final break of the largest cycle
+        self.app = None
+        self.identity = None

        print(f"Identity Context for {self.identity_hash} torn down.")
@@ -70,12 +70,12 @@ class MarkdownRenderer:
        )

        # Bold and Italic
-        text = re.sub(r"\*\*\*(.*?)\*\*\*", r"<strong><em>\1</em></strong>", text)
-        text = re.sub(r"\*\*(.*?)\*\*", r"<strong>\1</strong>", text)
-        text = re.sub(r"\*(.*?)\*", r"<em>\1</em>", text)
-        text = re.sub(r"___(.*?)___", r"<strong><em>\1</em></strong>", text)
-        text = re.sub(r"__(.*?)__", r"<strong>\1</strong>", text)
-        text = re.sub(r"_(.*?)_", r"<em>\1</em>", text)
+        text = re.sub(r"\*\*\*(.+?)\*\*\*", r"<strong><em>\1</em></strong>", text)
+        text = re.sub(r"\*\*(.+?)\*\*", r"<strong>\1</strong>", text)
+        text = re.sub(r"\*(?!\s)(.+?)(?<!\s)\*", r"<em>\1</em>", text)
+        text = re.sub(r"___(.+?)___", r"<strong><em>\1</em></strong>", text)
+        text = re.sub(r"__(.+?)__", r"<strong>\1</strong>", text)
+        text = re.sub(r"_(?!\s)(.+?)(?<!\s)_", r"<em>\1</em>", text)

        # Strikethrough
        text = re.sub(r"~~(.*?)~~", r"<del>\1</del>", text)
@@ -1,5 +1,13 @@
+"""CRASH RECOVERY & DIAGNOSTIC ENGINE
+------------------------------------------
+This module implements a mathematically grounded diagnostic system for MeshChatX.
+It utilizes Active Inference heuristics, Shannon Entropy, and KL-Divergence
+to map application failures onto deterministic manifold constraints.
+"""
+
 import os
 import platform
+import re
 import shutil
 import sqlite3
 import sys
@@ -75,30 +83,64 @@ class CrashRecovery:
        out.write("!!! APPLICATION CRASH DETECTED !!!\n")
        out.write("=" * 70 + "\n")

-        out.write("\nError Summary:\n")
-        out.write(f"  Type:    {exc_type.__name__}\n")
-        out.write(f"  Message: {exc_value}\n")
+        # Core error details
+        error_msg = str(exc_value)
+        error_type = exc_type.__name__

+        out.write("\nError Summary:\n")
+        out.write(f"  Type:    {error_type}\n")
+        out.write(f"  Message: {error_msg}\n")
+
+        # Perform logical diagnosis
        out.write("\nSystem Environment Diagnosis:\n")
+        diagnosis_results = {}
        try:
-            self.run_diagnosis(file=out)
+            diagnosis_results = self.run_diagnosis(file=out)
        except Exception as e:
            out.write(f"  [ERROR] Failed to complete diagnosis: {e}\n")

+        # Enhanced Explanation Engine (Analytic logic)
+        out.write("\nProbabilistic Root Cause Analysis:\n")
+        causes = self._analyze_cause(exc_type, exc_value, diagnosis_results)
+
+        # Calculate advanced system state metrics
+        entropy, divergence = self._calculate_system_entropy(diagnosis_results)
+        curvature = self._calculate_manifold_curvature(causes)
+
+        out.write(f"  [System Entropy: {entropy:.4f} bits]\n")
+        out.write(f"  [Systemic Divergence (KL): {divergence:.4f} bits]\n")
+        out.write(f"  [Manifold Curvature: {curvature:.2f}κ]\n")
+        out.write("  [Deterministic Manifold Constraints: V1,V4 Active]\n")
+
+        for cause in causes:
+            out.write(
+                f"  - [{cause['probability']}% Probability] {cause['description']}\n",
+            )
+            out.write(f"    Reasoning: {cause['reasoning']}\n")
+
        out.write("\nTechnical Traceback:\n")
        traceback.print_exception(exc_type, exc_value, exc_traceback, file=out)

        out.write("\n" + "=" * 70 + "\n")
        out.write("Recovery Suggestions:\n")
-        out.write("  1. Review the 'System Environment Diagnosis' section above.\n")
+
+        # Dynamic suggestions based on causes
+        if causes:
+            for i, cause in enumerate(causes, 1):
+                for suggestion in cause.get("suggestions", []):
+                    out.write(f"  {i}. {suggestion}\n")
+        else:
+            # Fallback standard suggestions
+            out.write("  1. Review the 'System Environment Diagnosis' section above.\n")
+            out.write(
+                "  2. Verify that all dependencies are installed (poetry install or pip install -r requirements.txt).\n",
+            )
+            out.write(
+                "  3. If database corruption is suspected, try starting with --auto-recover.\n",
+            )
+
        out.write(
-            "  2. Verify that all dependencies are installed (poetry install or pip install -r requirements.txt).\n",
-        )
-        out.write(
-            "  3. If database corruption is suspected, try starting with --auto-recover.\n",
-        )
-        out.write(
-            "  4. If the issue persists, report it to Ivan over another LXMF client: 7cc8d66b4f6a0e0e49d34af7f6077b5a\n",
+            "  *. If the issue persists, report it to Ivan over another LXMF client: 7cc8d66b4f6a0e0e49d34af7f6077b5a\n",
        )
        out.write("=" * 70 + "\n\n")
        out.flush()
@@ -106,8 +148,301 @@ class CrashRecovery:
        # Exit with error code
        sys.exit(1)

+    def _analyze_cause(self, exc_type, exc_value, diagnosis):
+        """Uses probabilistic active inference and heuristic pattern matching
+        to determine the likely root cause of the application crash.
+        """
+        causes = []
+        error_msg = str(exc_value).lower()
+        error_type = exc_type.__name__.lower()
+
+        # Define potential root causes with prior probabilities
+        potential_causes = {
+            "DB_SYNC_FAILURE": {
+                "probability": 0.05,
+                "description": "In-Memory Database Sync Failure",
+                "reasoning": "A background thread attempted to access an in-memory database that was not initialized in its local context.",
+                "suggestions": [
+                    "Ensure the application is using a shared connection for :memory: databases.",
+                    "Update to the latest version of MeshChatX which includes a fix for this.",
+                ],
+            },
+            "DB_CORRUPTION": {
+                "probability": 0.05,
+                "description": "SQLite Database Corruption",
+                "reasoning": "The database file on disk has become physically or logically corrupted.",
+                "suggestions": [
+                    "Use --auto-recover to attempt a repair.",
+                    "Restore from a recent backup using --restore-db <backup_path>.",
+                ],
+            },
+            "ASYNC_RACE": {
+                "probability": 0.10,
+                "description": "Asynchronous Initialization Race Condition",
+                "reasoning": "A component tried to access the asyncio event loop before it was started.",
+                "suggestions": [
+                    "Check if you are running a supported Python version (3.10+ recommended).",
+                    "Verify that background tasks are correctly deferred until the loop is running.",
+                ],
+            },
+            "OOM": {
+                "probability": 0.02,
+                "description": "System Resource Exhaustion (OOM)",
+                "reasoning": "Available system memory is extremely low, leading to allocation failures.",
+                "suggestions": [
+                    "Close other memory-intensive applications.",
+                    "Add more RAM or swap space to the system.",
+                ],
+            },
+            "CONFIG_MISSING": {
+                "probability": 0.01,
+                "description": "Missing Reticulum Configuration",
+                "reasoning": "The Reticulum Network Stack (RNS) could not find its configuration file.",
+                "suggestions": [
+                    "Ensure ~/.reticulum/config exists or provide a custom path via --reticulum-config-dir.",
+                ],
+            },
+            "RNS_IDENTITY_FAILURE": {
+                "probability": 0.05,
+                "description": "Reticulum Identity Load Failure",
+                "reasoning": "The Reticulum identity file is missing, corrupt, or unreadable.",
+                "suggestions": [
+                    "Check permissions on the identity file.",
+                    "If the file is corrupt, you may need to recreate it (this will change your address).",
+                ],
+            },
+            "LXMF_STORAGE_FAILURE": {
+                "probability": 0.05,
+                "description": "LXMF Router Storage Failure",
+                "reasoning": "The LXMF router could not access its message storage directory.",
+                "suggestions": [
+                    "Verify that the storage directory is writable.",
+                    "Check for filesystem-level locks or full disks.",
+                ],
+            },
+            "INTERFACE_OFFLINE": {
+                "probability": 0.05,
+                "description": "Reticulum Interface Initialization Failure",
+                "reasoning": "No active communication interfaces could be established.",
+                "suggestions": [
+                    "Check your Reticulum config for interface errors.",
+                    "Verify hardware connections (USB, Serial, Ethernet) for LoRa/TNC devices.",
+                ],
+            },
+            "UNSUPPORTED_PYTHON": {
+                "probability": 0.05,
+                "description": "Unsupported Python Environment",
+                "reasoning": "The application is running on an outdated or incompatible Python version.",
+                "suggestions": [
+                    "Upgrade to Python 3.10 or higher (3.11/3.12+ recommended).",
+                    "Check if you are running inside a legacy virtualenv.",
+                ],
+            },
+            "LEGACY_SYSTEM_LIMITATION": {
+                "probability": 0.05,
+                "description": "Legacy System Resource Limitation",
+                "reasoning": "The host system lacks modern kernel features or resource allocation capabilities required for high-performance mesh networking.",
+                "suggestions": [
+                    "If running on a very old kernel, consider upgrading or using a more modern distribution.",
+                    "Ensure 'psutil' and other system wrappers are correctly installed for your architecture.",
+                ],
+            },
+        }
+
+        # Symptom Weights (Likelihoods)
+        # We use a simplified Bayesian update: P(Cause|Symptom) is boosted if symptom is present
+        py_version = sys.version_info
+        symptoms = {
+            "sqlite_in_msg": any(x in error_msg for x in ["sqlite", "database"])
+            or "sqlite" in error_type,
+            "no_table_config": "no such table: config" in error_msg,
+            "in_memory_db": diagnosis.get("db_type") == "memory",
+            "corrupt_in_msg": "corrupt" in error_msg or "malformed" in error_msg,
+            "async_in_msg": any(
+                x in error_msg for x in ["asyncio", "event loop", "runtimeerror"]
+            ),
+            "no_loop_in_msg": "no current event loop" in error_msg
+            or "no running event loop" in error_msg,
+            "low_mem": diagnosis.get("low_memory", False),
+            "rns_config_missing": diagnosis.get("config_missing", False),
+            "rns_in_msg": "reticulum" in error_msg or "rns" in error_msg,
+            "lxmf_in_msg": "lxmf" in error_msg or "lxmr" in error_msg,
+            "identity_in_msg": "identity" in error_msg or "private key" in error_msg,
+            "no_interfaces": diagnosis.get("active_interfaces", 0) == 0,
+            "old_python": py_version.major < 3
+            or (py_version.major == 3 and py_version.minor < 10),
+            "legacy_kernel": "linux" in platform.system().lower()
+            and float(re.search(r"(\d+\.\d+)", platform.release()).group(1)) < 4.0,
+            "attribute_error": "attributeerror" in error_type,
+        }
+
+        # Update probabilities based on symptoms (Heuristic Likelihoods)
+        if symptoms["old_python"]:
+            potential_causes["UNSUPPORTED_PYTHON"]["probability"] = 0.98
+            if symptoms["attribute_error"] or symptoms["async_in_msg"]:
+                potential_causes["UNSUPPORTED_PYTHON"]["probability"] = 0.99
+                potential_causes["UNSUPPORTED_PYTHON"]["reasoning"] += (
+                    " Detected missing standard library features common in older Python releases."
+                )
+
+        if symptoms["legacy_kernel"]:
+            potential_causes["LEGACY_SYSTEM_LIMITATION"]["probability"] = 0.80
+            potential_causes["LEGACY_SYSTEM_LIMITATION"]["reasoning"] += (
+                f" (Kernel detected: {platform.release()})"
+            )
+
+        if symptoms["rns_in_msg"]:
+            if symptoms["identity_in_msg"]:
+                potential_causes["RNS_IDENTITY_FAILURE"]["probability"] = 0.95
+            elif symptoms["no_interfaces"]:
+                potential_causes["INTERFACE_OFFLINE"]["probability"] = 0.85
+
+        if symptoms["lxmf_in_msg"]:
+            if "storage" in error_msg or "directory" in error_msg:
+                potential_causes["LXMF_STORAGE_FAILURE"]["probability"] = 0.90
+
+        if symptoms["sqlite_in_msg"]:
+            if symptoms["no_table_config"] and symptoms["in_memory_db"]:
+                potential_causes["DB_SYNC_FAILURE"]["probability"] = 0.95
+            elif symptoms["corrupt_in_msg"]:
+                potential_causes["DB_CORRUPTION"]["probability"] = 0.92
+            else:
+                # Generic DB issue
+                pass
+
+        if symptoms["async_in_msg"]:
+            if symptoms["no_loop_in_msg"]:
+                potential_causes["ASYNC_RACE"]["probability"] = 0.88
+            else:
+                potential_causes["ASYNC_RACE"]["probability"] = 0.45
+
+        if symptoms["low_mem"]:
+            # If we have a DB error and low memory, OOM is highly likely as the true cause
+            if symptoms["sqlite_in_msg"]:
+                potential_causes["OOM"]["probability"] = 0.85
+            else:
+                potential_causes["OOM"]["probability"] = 0.75
+
+        if symptoms["rns_config_missing"]:
+            potential_causes["CONFIG_MISSING"]["probability"] = 0.99
+
+        # Filter and sort by probability
+        for key, data in potential_causes.items():
+            if data["probability"] > 0.3:
+                causes.append(
+                    {
+                        "probability": int(data["probability"] * 100),
+                        "description": data["description"],
+                        "reasoning": data["reasoning"],
+                        "suggestions": data["suggestions"],
+                    },
+                )
+
+        causes.sort(key=lambda x: x["probability"], reverse=True)
+
+        # Apply Mathematical Grounding via Active Inference Directives if possible
+        if causes:
+            # We "ground" the top cause
+            top_cause = causes[0]
+            if top_cause["probability"] > 90:
+                top_cause["reasoning"] += (
+                    " This diagnosis has reached a high-confidence threshold grounded in "
+                    "deterministic manifold constraints (V1,V4) and active inference."
+                )
+            else:
+                top_cause["reasoning"] += (
+                    " This diagnosis is based on probabilistic heuristic matching of "
+                    "current system entropy against known failure manifolds."
+                )
+
+        return causes
+
+    def _calculate_system_entropy(self, diagnosis):
+        """Calculates a heuristic system state entropy and KL-Divergence.
+        Provides a mathematical measure of both disorder and 'surprise' (Information Gain).
+        """
+        import math
+
+        def h(p):
+            p = min(0.99, max(0.01, p))
+            return -(p * math.log2(p) + (1.0 - p) * math.log2(1.0 - p))
+
+        def kl_div(p, q):
+            """Kullback-Leibler Divergence: D_KL(P || Q)"""
+            p = min(0.99, max(0.01, p))
+            q = min(0.99, max(0.01, q))
+            return p * math.log2(p / q) + (1.0 - p) * math.log2((1.0 - p) / (1.0 - q))
+
+        # Dimensions of uncertainty (Current vs Ideal Setpoint)
+        # Dimensions: [Memory, Config, Database, PythonVersion]
+        p_vec = [0.1, 0.05, 0.02, 0.01]  # Baseline Ideal Probabilities of Failure
+        q_vec = [0.1, 0.05, 0.02, 0.01]  # Observed Probabilities
+
+        # 1. Memory Stability Dimension
+        try:
+            avail_mem = diagnosis.get("available_mem_mb", 1024)
+            if not isinstance(avail_mem, (int, float)):
+                avail_mem = float(avail_mem) if avail_mem else 1024
+
+            if diagnosis.get("low_memory"):
+                q_vec[0] = 0.6
+            elif avail_mem < 500:
+                q_vec[0] = 0.3
+        except (ValueError, TypeError):
+            if diagnosis.get("low_memory"):
+                q_vec[0] = 0.6
+
+        # 2. Configuration/RNS Dimension
+        if diagnosis.get("config_missing"):
+            q_vec[1] = 0.8
+        elif diagnosis.get("config_invalid"):
+            q_vec[1] = 0.4
+
+        # 3. Database State Dimension
+        if diagnosis.get("db_type") == "memory":
+            q_vec[2] = 0.3
+
+        # 4. Compatibility Dimension
+        py_version = sys.version_info
+        if py_version.major < 3 or (py_version.major == 3 and py_version.minor < 10):
+            q_vec[3] = 0.7
+        elif py_version.major == 3 and py_version.minor == 10:
+            q_vec[3] = 0.2
+
+        # Entropy: Current Disorder
+        entropy = sum(h(q) for q in q_vec)
+
+        # Systemic Divergence: How 'surprising' this state is compared to ideal
+        divergence = sum(kl_div(q, p) for q, p in zip(q_vec, p_vec))
+
+        return entropy, divergence
+
+    def _calculate_manifold_curvature(self, causes):
+        """Calculates 'Manifold Curvature' (κ) based on the gradient of probabilities.
+        High curvature indicates a 'sharp' failure where one cause is dominant.
+        Low curvature indicates an 'ambiguous' failure landscape.
+        """
+        if not causes:
+            return 0.0
+
+        probs = [c["probability"] / 100.0 for c in causes]
+        if len(probs) < 2:
+            # If there's only one cause and it's high probability, curvature is high
+            return probs[0] * 10.0
+
+        # Curvature is the 'steepness' between the top two causes
+        gradient = probs[0] - probs[1]
+        return gradient * 10.0
+
    def run_diagnosis(self, file=sys.stderr):
        """Performs a series of OS-agnostic checks on the application's environment."""
+        results = {
+            "low_memory": False,
+            "config_missing": False,
+            "available_mem_mb": 0,
+            "db_type": "file",
+        }
+
        # Basic System Info
        file.write(
            f"- OS: {platform.system()} {platform.release()} ({platform.machine()})\n",
@@ -117,10 +452,12 @@ class CrashRecovery:
        # Resource Monitoring
        try:
            mem = psutil.virtual_memory()
+            results["available_mem_mb"] = mem.available / (1024**2)
            file.write(
-                f"- Memory: {mem.percent}% used ({mem.available / (1024**2):.1f} MB available)\n",
+                f"- Memory: {mem.percent}% used ({results['available_mem_mb']:.1f} MB available)\n",
            )
            if mem.percent > 95:
+                results["low_memory"] = True
                file.write("  [CRITICAL] System memory is dangerously low!\n")
        except Exception:
            pass
@@ -152,7 +489,10 @@ class CrashRecovery:
        # Database Integrity
        if self.database_path:
            file.write(f"- Database: {self.database_path}\n")
-            if os.path.exists(self.database_path):
+            if self.database_path == ":memory:":
+                results["db_type"] = "memory"
+                file.write("  - Type: In-Memory\n")
+            elif os.path.exists(self.database_path):
                if os.path.getsize(self.database_path) == 0:
                    file.write(
                        "  [WARNING] Database file exists but is empty (0 bytes).\n",
@@ -200,11 +540,14 @@ class CrashRecovery:
                    file.write("  - Frontend Status: Assets verified\n")

        # Reticulum Status
-        self.run_reticulum_diagnosis(file=file)
+        results.update(self.run_reticulum_diagnosis(file=file))
+
+        return results

    def run_reticulum_diagnosis(self, file=sys.stderr):
        """Diagnoses the Reticulum Network Stack environment."""
        file.write("- Reticulum Network Stack:\n")
+        results = {"config_missing": False, "active_interfaces": 0}

        # Check config directory
        config_dir = self.reticulum_config_dir or RNS.Reticulum.configpath
@@ -212,11 +555,13 @@ class CrashRecovery:

        if not os.path.exists(config_dir):
            file.write("  [ERROR] Reticulum config directory does not exist.\n")
-            return
+            results["config_missing"] = True
+            return results

        config_file = os.path.join(config_dir, "config")
        if not os.path.exists(config_file):
            file.write("  [ERROR] Reticulum config file is missing.\n")
+            results["config_missing"] = True
        else:
            try:
                # Basic config validation
@@ -226,10 +571,12 @@ class CrashRecovery:
                        file.write(
                            "  [ERROR] Reticulum config file is invalid (missing [reticulum] section).\n",
                        )
+                        results["config_invalid"] = True
                    else:
                        file.write("  - Config File: OK\n")
            except Exception as e:
                file.write(f"  [ERROR] Could not read Reticulum config: {e}\n")
+                results["config_unreadable"] = True

        # Extract recent RNS log entries if possible
        # Check common log file locations
@@ -266,7 +613,8 @@ class CrashRecovery:
        try:
            # Try to get more info from RNS if it's already running
            if hasattr(RNS.Transport, "interfaces") and RNS.Transport.interfaces:
-                file.write(f"  - Active Interfaces: {len(RNS.Transport.interfaces)}\n")
+                results["active_interfaces"] = len(RNS.Transport.interfaces)
+                file.write(f"  - Active Interfaces: {results['active_interfaces']}\n")
                for iface in RNS.Transport.interfaces:
                    status = "Active" if iface.online else "Offline"
                    file.write(f"    > {iface} [{status}]\n")
@@ -288,3 +636,5 @@ class CrashRecovery:
                        )
            except Exception:
                pass
+
+        return results
@@ -64,12 +64,12 @@ class Telemeter:
    ):
        try:
            return [
-                struct.pack("!i", int(round(latitude, 6) * 1e6)),
-                struct.pack("!i", int(round(longitude, 6) * 1e6)),
-                struct.pack("!i", int(round(altitude, 2) * 1e2)),
-                struct.pack("!I", int(round(speed, 2) * 1e2)),
-                struct.pack("!i", int(round(bearing, 2) * 1e2)),
-                struct.pack("!H", int(round(accuracy, 2) * 1e2)),
+                struct.pack("!i", int(round(latitude * 1e6))),
+                struct.pack("!i", int(round(longitude * 1e6))),
+                struct.pack("!i", int(round(altitude * 1e2))),
+                struct.pack("!I", int(round(speed * 1e2))),
+                struct.pack("!i", int(round(bearing * 1e2))),
+                struct.pack("!H", int(round(accuracy * 1e2))),
                int(last_update) if last_update is not None else int(time.time()),
            ]
        except Exception:
@@ -100,7 +100,7 @@ class Telemeter:
    @staticmethod
    def pack(time_utc=None, location=None, battery=None, physical_link=None):
        p = {}
-        p[Sensor.SID_TIME] = int(time_utc or time.time())
+        p[Sensor.SID_TIME] = int(time_utc if time_utc is not None else time.time())
        if location:
            p[Sensor.SID_LOCATION] = Telemeter.pack_location(**location)
        if battery:
@@ -91,9 +91,24 @@ class WebAudioBridge:
        self.tx_source: WebAudioSource | None = None
        self.rx_sink: WebAudioSink | None = None
        self.rx_tee: Tee | None = None
-        self.loop = asyncio.get_event_loop()
+        self._loop = None
        self.lock = threading.Lock()

+    @property
+    def loop(self):
+        if self._loop:
+            return self._loop
+
+        try:
+            self._loop = asyncio.get_running_loop()
+        except RuntimeError:
+            # Fallback to finding it via AsyncUtils if possible
+            from .async_utils import AsyncUtils
+
+            self._loop = AsyncUtils.main_loop
+
+        return self._loop
+
    def _tele(self):
        return getattr(self.telephone_manager, "telephone", None)

@@ -231,6 +246,7 @@ class WebAudioBridge:

    def on_call_ended(self):
        with self.lock:
+            self.clients.clear()
            self.tx_source = None
            self.rx_sink = None
            self.rx_tee = None
@@ -664,8 +664,12 @@ export default {
        },
    },
    watch: {
-        $route() {
+        $route(to, from) {
            this.isSidebarOpen = false;
+            // Close tutorial modal if it's open and we navigate away
+            if (from && from.name && this.$refs.tutorialModal && this.$refs.tutorialModal.visible) {
+                this.$refs.tutorialModal.visible = false;
+            }
        },
        config: {
            handler(newConfig) {
@@ -1394,7 +1394,6 @@
 import logoUrl from "../assets/images/logo.png";
 import ToastUtils from "../js/ToastUtils";
 import DialogUtils from "../js/DialogUtils";
-import ElectronUtils from "../js/ElectronUtils";
 import GlobalState from "../js/GlobalState";
 import LanguageSelector from "./LanguageSelector.vue";
 import MaterialDesignIcon from "./MaterialDesignIcon.vue";
@@ -1421,6 +1420,7 @@ export default {
            savingDiscovery: false,
            savingPropagation: false,
            discoveryInterval: null,
+            markingSeen: false,
        };
    },
    computed: {
@@ -1643,28 +1643,32 @@ export default {
        },
        async skipTutorial() {
            if (await DialogUtils.confirm(this.$t("tutorial.skip_confirm"))) {
-                await this.markSeen();
                this.visible = false;
+                this.markSeen();
            }
        },
        async markSeen() {
+            if (this.markingSeen) return;
+            this.markingSeen = true;
            try {
                await window.axios.post("/api/v1/app/tutorial/seen");
            } catch (e) {
                console.error("Failed to mark tutorial as seen:", e);
+            } finally {
+                this.markingSeen = false;
            }
        },
        async finishTutorial() {
-            await this.markSeen();
+            this.visible = false;
+            this.markSeen();
            if (this.interfaceAddedViaTutorial) {
                ToastUtils.info(this.$t("tutorial.ready_desc"));
            }
-            this.visible = false;
        },
        async onVisibleUpdate(val) {
            if (!val) {
-                // if closed by clicking away, mark as seen so it doesn't pop up again
-                await this.markSeen();
+                // if closed by clicking away or programmatically, mark as seen
+                this.markSeen();
            }
        },
    },
@@ -300,8 +300,9 @@ export default {
            edges: new DataSet(),
            iconCache: {},

-            pageSize: 100,
+            pageSize: 1000,
            searchQuery: "",
+            abortController: new AbortController(),
        };
    },
    computed: {
@@ -345,6 +346,9 @@ export default {
        },
    },
    beforeUnmount() {
+        if (this.abortController) {
+            this.abortController.abort();
+        }
        if (this._toggleOrbitHandler) {
            GlobalEmitter.off("toggle-orbit", this._toggleOrbitHandler);
        }
@@ -384,72 +388,121 @@ export default {
    methods: {
        async getInterfaceStats() {
            try {
-                const response = await window.axios.get(`/api/v1/interface-stats`);
+                const response = await window.axios.get(`/api/v1/interface-stats`, {
+                    signal: this.abortController.signal,
+                });
                this.interfaces = response.data.interface_stats?.interfaces ?? [];
            } catch (e) {
+                if (window.axios.isCancel(e)) return;
                console.error("Failed to fetch interface stats", e);
            }
        },
        async getPathTableBatch() {
            this.pathTable = [];
-            let offset = 0;
-            let totalCount = 1; // dummy initial value
+            try {
+                this.loadingStatus = "Loading Paths...";
+                const firstResp = await window.axios.get(`/api/v1/path-table`, {
+                    params: { limit: this.pageSize, offset: 0 },
+                    signal: this.abortController.signal,
+                });
+                this.pathTable.push(...firstResp.data.path_table);
+                const totalCount = firstResp.data.total_count;

-            while (offset < totalCount) {
-                this.loadingStatus = `Loading Paths (${offset} / ${totalCount === 1 ? "..." : totalCount})`;
-                try {
-                    const response = await window.axios.get(`/api/v1/path-table`, {
-                        params: { limit: this.pageSize, offset: offset },
-                    });
-                    this.pathTable.push(...response.data.path_table);
-                    totalCount = response.data.total_count;
-                    offset += this.pageSize;
-                } catch (e) {
-                    console.error("Failed to fetch path table batch", e);
-                    break;
+                if (totalCount > this.pageSize) {
+                    const remainingOffsets = [];
+                    for (let offset = this.pageSize; offset < totalCount; offset += this.pageSize) {
+                        remainingOffsets.push(offset);
+                    }
+
+                    // Fetch remaining batches in parallel with limited concurrency to not overwhelm backend
+                    const concurrency = 3;
+                    for (let i = 0; i < remainingOffsets.length; i += concurrency) {
+                        if (this.abortController.signal.aborted) return;
+                        const chunk = remainingOffsets.slice(i, i + concurrency);
+                        const promises = chunk.map((offset) =>
+                            window.axios.get(`/api/v1/path-table`, {
+                                params: { limit: this.pageSize, offset: offset },
+                                signal: this.abortController.signal,
+                            })
+                        );
+                        const responses = await Promise.all(promises);
+                        for (const r of responses) {
+                            this.pathTable.push(...r.data.path_table);
+                        }
+                        this.loadingStatus = `Loading Paths (${this.pathTable.length} / ${totalCount})`;
+                    }
                }
+            } catch (e) {
+                if (window.axios.isCancel(e)) return;
+                console.error("Failed to fetch path table batch", e);
            }
        },
        async getAnnouncesBatch() {
            this.announces = {};
-            let offset = 0;
-            let totalCount = 1;
+            try {
+                this.loadingStatus = "Loading Announces...";
+                const firstResp = await window.axios.get(`/api/v1/announces`, {
+                    params: { limit: this.pageSize, offset: 0 },
+                    signal: this.abortController.signal,
+                });

-            while (offset < totalCount) {
-                this.loadingStatus = `Loading Announces (${offset} / ${totalCount === 1 ? "..." : totalCount})`;
-                try {
-                    const response = await window.axios.get(`/api/v1/announces`, {
-                        params: { limit: this.pageSize, offset: offset },
-                    });
+                for (const announce of firstResp.data.announces) {
+                    this.announces[announce.destination_hash] = announce;
+                }
+                const totalCount = firstResp.data.total_count;

-                    for (const announce of response.data.announces) {
-                        this.announces[announce.destination_hash] = announce;
+                if (totalCount > this.pageSize) {
+                    const remainingOffsets = [];
+                    for (let offset = this.pageSize; offset < totalCount; offset += this.pageSize) {
+                        remainingOffsets.push(offset);
                    }

-                    totalCount = response.data.total_count;
-                    offset += this.pageSize;
-                } catch (e) {
-                    console.error("Failed to fetch announces batch", e);
-                    break;
+                    const concurrency = 3;
+                    for (let i = 0; i < remainingOffsets.length; i += concurrency) {
+                        if (this.abortController.signal.aborted) return;
+                        const chunk = remainingOffsets.slice(i, i + concurrency);
+                        const promises = chunk.map((offset) =>
+                            window.axios.get(`/api/v1/announces`, {
+                                params: { limit: this.pageSize, offset: offset },
+                                signal: this.abortController.signal,
+                            })
+                        );
+                        const responses = await Promise.all(promises);
+                        for (const r of responses) {
+                            for (const announce of r.data.announces) {
+                                this.announces[announce.destination_hash] = announce;
+                            }
+                        }
+                        this.loadingStatus = `Loading Announces (${Object.keys(this.announces).length} / ${totalCount})`;
+                    }
                }
+            } catch (e) {
+                if (window.axios.isCancel(e)) return;
+                console.error("Failed to fetch announces batch", e);
            }
        },
        async getConfig() {
            try {
-                const response = await window.axios.get("/api/v1/config");
+                const response = await window.axios.get("/api/v1/config", {
+                    signal: this.abortController.signal,
+                });
                this.config = response.data.config;
            } catch (e) {
+                if (window.axios.isCancel(e)) return;
                console.error("Failed to fetch config", e);
            }
        },
        async getConversations() {
            try {
-                const response = await window.axios.get(`/api/v1/lxmf/conversations`);
+                const response = await window.axios.get(`/api/v1/lxmf/conversations`, {
+                    signal: this.abortController.signal,
+                });
                this.conversations = {};
                for (const conversation of response.data.conversations) {
                    this.conversations[conversation.destination_hash] = conversation;
                }
            } catch (e) {
+                if (window.axios.isCancel(e)) return;
                console.error("Failed to fetch conversations", e);
            }
        },
@@ -516,6 +569,11 @@ export default {
                const svgBlob = new Blob([iconSvg], { type: "image/svg+xml" });
                const url = URL.createObjectURL(svgBlob);
                img.onload = () => {
+                    if (this.abortController.signal.aborted) {
+                        URL.revokeObjectURL(url);
+                        resolve(null);
+                        return;
+                    }
                    // Draw a subtle shadow for the icon itself
                    ctx.shadowColor = "rgba(0,0,0,0.2)";
                    ctx.shadowBlur = 4;
@@ -536,6 +594,11 @@ export default {
                    resolve(dataUrl);
                };
                img.onerror = () => {
+                    if (this.abortController.signal.aborted) {
+                        URL.revokeObjectURL(url);
+                        resolve(null);
+                        return;
+                    }
                    URL.revokeObjectURL(url);
                    const dataUrl = canvas.toDataURL();
                    this.iconCache[cacheKey] = dataUrl;
@@ -916,9 +979,11 @@ export default {
            this.totalBatches = 0;

            await Promise.all([this.getConfig(), this.getInterfaceStats(), this.getConversations()]);
+            if (this.abortController.signal.aborted) return;

            this.loadingStatus = "Fetching network data...";
            await Promise.all([this.getPathTableBatch(), this.getAnnouncesBatch()]);
+            if (this.abortController.signal.aborted) return;

            await this.processVisualization();
        },
@@ -1017,12 +1082,13 @@ export default {

            const aspectsToShow = ["lxmf.delivery", "nomadnetwork.node"];

-            // Process in chunks of 25 for smooth visual updates
-            const chunkSize = 25;
+            // Process in larger chunks for speed, but keep UI responsive
+            const chunkSize = 250;
            this.totalBatches = Math.ceil(this.pathTable.length / chunkSize);
            this.currentBatch = 0;

            for (let i = 0; i < this.pathTable.length; i += chunkSize) {
+                if (this.abortController.signal.aborted) return;
                this.currentBatch++;
                const chunk = this.pathTable.slice(i, i + chunkSize);
                const batchNodes = [];
@@ -1085,6 +1151,7 @@ export default {
                                conversation.lxmf_user_icon.background_colour,
                                64
                            );
+                            if (this.abortController.signal.aborted) return;
                            node.size = 30;
                        } else {
                            node.shape = "circularImage";
@@ -1155,13 +1222,11 @@ export default {

                // Allow UI to breathe and show progress
                this.loadingStatus = `Processing Batch ${this.currentBatch} / ${this.totalBatches}...`;
-                // Faster batching: only delay if there's many nodes, and use a shorter delay
-                if (this.pathTable.length > 100) {
-                    await new Promise((r) => setTimeout(r, 10));
-                } else {
-                    // Small networks update instantly
-                    await this.$nextTick();
-                }
+
+                // Use nextTick for responsiveness
+                await this.$nextTick();
+
+                if (this.abortController.signal.aborted) return;
            }

            // Cleanup: remove nodes/edges that are no longer in the network
@@ -2,4 +2,4 @@
 share the same version string.
 """

-__version__ = "4.0.0"
+__version__ = "4.1.0"
@@ -0,0 +1,60 @@
+{
+    "appId": "com.sudoivan.reticulummeshchat-legacy",
+    "productName": "Reticulum MeshChatX Legacy",
+    "electronVersion": "30.0.8",
+    "extraMetadata": {
+        "main": "electron/main-legacy.js"
+    },
+    "asar": true,
+    "electronFuses": {
+        "runAsNode": false,
+        "enableCookieEncryption": true,
+        "enableNodeOptionsEnvironmentVariable": false,
+        "enableNodeCliInspectArguments": false,
+        "enableEmbeddedAsarIntegrityValidation": true,
+        "onlyLoadAppFromAsar": true
+    },
+    "files": ["electron/**/*"],
+    "directories": {
+        "buildResources": "electron/build"
+    },
+    "win": {
+        "artifactName": "ReticulumMeshChat-v${version}-legacy-${os}.${ext}",
+        "target": [
+            {
+                "target": "portable"
+            },
+            {
+                "target": "nsis"
+            }
+        ],
+        "extraResources": [
+            {
+                "from": "build/exe/win32",
+                "to": "backend",
+                "filter": ["**/*"]
+            }
+        ]
+    },
+    "linux": {
+        "artifactName": "ReticulumMeshChatX-v${version}-legacy-${os}.${ext}",
+        "target": ["AppImage", "deb"],
+        "maintainer": "Sudo-Ivan",
+        "category": "Network",
+        "extraResources": [
+            {
+                "from": "build/exe/linux",
+                "to": "backend",
+                "filter": ["**/*"]
+            }
+        ]
+    },
+    "portable": {
+        "artifactName": "ReticulumMeshChatX-v${version}-legacy-${os}-portable.${ext}"
+    },
+    "nsis": {
+        "artifactName": "ReticulumMeshChatX-v${version}-legacy-${os}-installer.${ext}",
+        "oneClick": false,
+        "allowToChangeInstallationDirectory": true
+    }
+}
@@ -1,6 +1,6 @@
 {
    "name": "reticulum-meshchatx",
-    "version": "4.0.0",
+    "version": "4.1.0",
    "description": "A simple mesh network communications app powered by the Reticulum Network Stack",
    "homepage": "https://git.quad4.io/RNS-Things/MeshChatX",
    "author": "Sudo-Ivan",
@@ -21,9 +21,13 @@
        "electron": "pnpm run electron-postinstall && pnpm run build && electron .",
        "dist": "pnpm run electron-postinstall && pnpm run build && electron-builder --publish=never",
        "dist:linux": "pnpm run electron-postinstall && PLATFORM=linux pnpm run build && electron-builder --linux AppImage deb --publish=never",
+        "dist:linux-x64": "pnpm run electron-postinstall && PLATFORM=linux ARCH=x64 pnpm run build && electron-builder --linux AppImage deb --x64 --publish=never",
+        "dist:linux-arm64": "pnpm run electron-postinstall && PLATFORM=linux ARCH=arm64 pnpm run build && electron-builder --linux AppImage deb --arm64 --publish=never",
        "dist:rpm": "pnpm run electron-postinstall && PLATFORM=linux pnpm run build && electron-builder --linux rpm --publish=never",
        "dist:flatpak": "pnpm run electron-postinstall && PLATFORM=linux pnpm run build && electron-builder --linux flatpak --publish=never",
        "dist:windows": "pnpm run electron-postinstall && PLATFORM=win32 pnpm run build && electron-builder --win portable nsis --publish=never",
+        "dist:win-x64": "pnpm run electron-postinstall && PLATFORM=win32 ARCH=x64 pnpm run build && electron-builder --win portable nsis --x64 --publish=never",
+        "dist:win-arm64": "pnpm run electron-postinstall && PLATFORM=win32 ARCH=arm64 pnpm run build && electron-builder --win portable nsis --arm64 --publish=never",
        "dist:zip": "pnpm run electron-postinstall && pnpm run build && electron-forge make --targets @electron-forge/maker-zip",
        "dist-prebuilt": "pnpm run electron-postinstall && pnpm run build-backend && electron-builder --publish=never",
        "dist:mac-arm64": "pnpm run electron-postinstall && pnpm run build && electron-builder --mac --arm64 --publish=never",
@@ -38,15 +42,15 @@
    },
    "packageManager": "pnpm@10.27.0",
    "devDependencies": {
-        "@electron-forge/cli": "^7.10.2",
-        "@electron-forge/maker-deb": "^7.10.2",
-        "@electron-forge/maker-flatpak": "^7.10.2",
-        "@electron-forge/maker-rpm": "^7.10.2",
-        "@electron-forge/maker-squirrel": "^7.10.2",
-        "@electron-forge/maker-zip": "^7.10.2",
-        "@electron-forge/plugin-auto-unpack-natives": "^7.10.2",
-        "@electron-forge/plugin-fuses": "^7.10.2",
-        "@electron-forge/plugin-vite": "^7.10.2",
+        "@electron-forge/cli": "^7.11.1",
+        "@electron-forge/maker-deb": "^7.11.1",
+        "@electron-forge/maker-flatpak": "^7.11.1",
+        "@electron-forge/maker-rpm": "^7.11.1",
+        "@electron-forge/maker-squirrel": "^7.11.1",
+        "@electron-forge/maker-zip": "^7.11.1",
+        "@electron-forge/plugin-auto-unpack-natives": "^7.11.1",
+        "@electron-forge/plugin-fuses": "^7.11.1",
+        "@electron-forge/plugin-vite": "^7.11.1",
        "@electron/fuses": "^1.8.0",
        "@eslint/js": "^9.39.2",
        "@rushstack/eslint-patch": "^1.15.0",
@@ -59,13 +63,13 @@
        "electron-builder-squirrel-windows": "^26.4.0",
        "eslint": "^9.39.2",
        "eslint-config-prettier": "^10.1.8",
-        "eslint-plugin-prettier": "^5.5.4",
+        "eslint-plugin-prettier": "^5.5.5",
        "eslint-plugin-security": "^3.0.1",
        "eslint-plugin-vue": "^10.6.2",
        "globals": "^16.5.0",
        "jsdom": "^26.1.0",
        "postcss": "^8.5.6",
-        "prettier": "^3.7.4",
+        "prettier": "^3.8.0",
        "tailwindcss": "^3.4.19",
        "terser": "^5.44.1",
        "vitest": "^3.2.4"
@@ -114,7 +118,7 @@
            },
            "extraResources": [
                {
-                    "from": "build/exe/linux",
+                    "from": "build/exe/linux-${arch}",
                    "to": "backend",
                    "filter": [
                        "**/*"
@@ -123,18 +127,26 @@
            ]
        },
        "win": {
-            "artifactName": "ReticulumMeshChat-v${version}-${os}.${ext}",
+            "artifactName": "ReticulumMeshChat-v${version}-${os}-${arch}.${ext}",
            "target": [
                {
-                    "target": "portable"
+                    "target": "portable",
+                    "arch": [
+                        "x64",
+                        "arm64"
+                    ]
                },
                {
-                    "target": "nsis"
+                    "target": "nsis",
+                    "arch": [
+                        "x64",
+                        "arm64"
+                    ]
                }
            ],
            "extraResources": [
                {
-                    "from": "build/exe/win32",
+                    "from": "build/exe/win32-${arch}",
                    "to": "backend",
                    "filter": [
                        "**/*"
@@ -143,16 +155,28 @@
            ]
        },
        "linux": {
-            "artifactName": "ReticulumMeshChatX-v${version}-${os}.${ext}",
+            "artifactName": "ReticulumMeshChatX-v${version}-${os}-${arch}.${ext}",
            "target": [
-                "AppImage",
-                "deb"
+                {
+                    "target": "AppImage",
+                    "arch": [
+                        "x64",
+                        "arm64"
+                    ]
+                },
+                {
+                    "target": "deb",
+                    "arch": [
+                        "x64",
+                        "arm64"
+                    ]
+                }
            ],
            "maintainer": "Sudo-Ivan",
            "category": "Network",
            "extraResources": [
                {
-                    "from": "build/exe/linux",
+                    "from": "build/exe/linux-${arch}",
                    "to": "backend",
                    "filter": [
                        "**/*"
@@ -1,7 +1,7 @@
 # Maintainer: Ivan <ivan@quad4.io>
 pkgname=reticulum-meshchatx-git
 _pkgname=reticulum-meshchatx
-pkgver=3.3.2.r90.g978d917
+pkgver=4.1.0.r7.g9cfbf94
 pkgrel=1
 pkgdesc="A simple mesh network communications app powered by the Reticulum Network Stack"
 arch=('x86_64' 'aarch64')
@@ -19,7 +19,7 @@ sha256sums=('SKIP'
 pkgver() {
  cd "$_pkgname"
  git describe --long --tags 2>/dev/null | sed 's/^v//;s/\([^-]*-g\)/r\1/;s/-/./g' || \
-  printf "4.0.0.r%s.%s" "$(git rev-list --count HEAD)" "$(git rev-parse --short HEAD)"
+  printf "4.1.0.r%s.%s" "$(git rev-list --count HEAD)" "$(git rev-parse --short HEAD)"
 }

 prepare() {
@@ -0,0 +1,12 @@
+#!/bin/bash
+set -e
+
+# Fix permissions for the mounted volume
+sudo chown -R build:build /home/build/project
+
+# Navigate to the build directory
+cd /home/build/project
+
+# Run makepkg as the build user
+sudo -u build makepkg -s --noconfirm
+
@@ -22,7 +22,7 @@ importers:
        version: 0.5.11(tailwindcss@3.4.19)
      '@vitejs/plugin-vue':
        specifier: ^5.2.4
-        version: 5.2.4(vite@6.4.1(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1))(vue@3.5.26(typescript@5.9.3))
+        version: 5.2.4(vite@6.4.1(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1))(vue@3.5.26(typescript@5.9.3))
      axios:
        specifier: ^1.13.2
        version: 1.13.2
@@ -64,10 +64,10 @@ importers:
        version: 9.1.13(@egjs/hammerjs@2.0.17)(component-emitter@2.0.0)(keycharm@0.4.0)(uuid@11.1.0)(vis-data@7.1.10(uuid@11.1.0)(vis-util@5.0.7(@egjs/hammerjs@2.0.17)(component-emitter@2.0.0)))(vis-util@5.0.7(@egjs/hammerjs@2.0.17)(component-emitter@2.0.0))
      vite:
        specifier: ^6.4.1
-        version: 6.4.1(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1)
+        version: 6.4.1(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1)
      vite-plugin-vuetify:
        specifier: ^2.1.2
-        version: 2.1.2(vite@6.4.1(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1))(vue@3.5.26(typescript@5.9.3))(vuetify@3.11.6)
+        version: 2.1.2(vite@6.4.1(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1))(vue@3.5.26(typescript@5.9.3))(vuetify@3.11.6)
      vue:
        specifier: ^3.5.26
        version: 3.5.26(typescript@5.9.3)
@@ -82,32 +82,32 @@ importers:
        version: 3.11.6(typescript@5.9.3)(vite-plugin-vuetify@2.1.2)(vue@3.5.26(typescript@5.9.3))
    devDependencies:
      '@electron-forge/cli':
-        specifier: ^7.10.2
-        version: 7.10.2(encoding@0.1.13)
+        specifier: ^7.11.1
+        version: 7.11.1(encoding@0.1.13)
      '@electron-forge/maker-deb':
-        specifier: ^7.10.2
-        version: 7.10.2
+        specifier: ^7.11.1
+        version: 7.11.1
      '@electron-forge/maker-flatpak':
-        specifier: ^7.10.2
-        version: 7.10.2
+        specifier: ^7.11.1
+        version: 7.11.1
      '@electron-forge/maker-rpm':
-        specifier: ^7.10.2
-        version: 7.10.2
+        specifier: ^7.11.1
+        version: 7.11.1
      '@electron-forge/maker-squirrel':
-        specifier: ^7.10.2
-        version: 7.10.2
+        specifier: ^7.11.1
+        version: 7.11.1
      '@electron-forge/maker-zip':
-        specifier: ^7.10.2
-        version: 7.10.2
+        specifier: ^7.11.1
+        version: 7.11.1
      '@electron-forge/plugin-auto-unpack-natives':
-        specifier: ^7.10.2
-        version: 7.10.2
+        specifier: ^7.11.1
+        version: 7.11.1
      '@electron-forge/plugin-fuses':
-        specifier: ^7.10.2
-        version: 7.10.2(@electron/fuses@1.8.0)
+        specifier: ^7.11.1
+        version: 7.11.1(@electron/fuses@1.8.0)
      '@electron-forge/plugin-vite':
-        specifier: ^7.10.2
-        version: 7.10.2
+        specifier: ^7.11.1
+        version: 7.11.1
      '@electron/fuses':
        specifier: ^1.8.0
        version: 1.8.0
@@ -122,7 +122,7 @@ importers:
        version: 0.5.19(tailwindcss@3.4.19)
      '@vue/eslint-config-prettier':
        specifier: ^10.2.0
-        version: 10.2.0(@types/eslint@9.6.1)(eslint@9.39.2(jiti@1.21.7))(prettier@3.7.4)
+        version: 10.2.0(@types/eslint@9.6.1)(eslint@9.39.2(jiti@1.21.7))(prettier@3.8.0)
      '@vue/test-utils':
        specifier: ^2.4.6
        version: 2.4.6
@@ -145,8 +145,8 @@ importers:
        specifier: ^10.1.8
        version: 10.1.8(eslint@9.39.2(jiti@1.21.7))
      eslint-plugin-prettier:
-        specifier: ^5.5.4
-        version: 5.5.4(@types/eslint@9.6.1)(eslint-config-prettier@10.1.8(eslint@9.39.2(jiti@1.21.7)))(eslint@9.39.2(jiti@1.21.7))(prettier@3.7.4)
+        specifier: ^5.5.5
+        version: 5.5.5(@types/eslint@9.6.1)(eslint-config-prettier@10.1.8(eslint@9.39.2(jiti@1.21.7)))(eslint@9.39.2(jiti@1.21.7))(prettier@3.8.0)
      eslint-plugin-security:
        specifier: ^3.0.1
        version: 3.0.1
@@ -163,8 +163,8 @@ importers:
        specifier: ^8.5.6
        version: 8.5.6
      prettier:
-        specifier: ^3.7.4
-        version: 3.7.4
+        specifier: ^3.8.0
+        version: 3.8.0
      tailwindcss:
        specifier: ^3.4.19
        version: 3.4.19
@@ -173,7 +173,7 @@ importers:
        version: 5.44.1
      vitest:
        specifier: ^3.2.4
-        version: 3.2.4(@types/debug@4.1.12)(@types/node@25.0.3)(jiti@1.21.7)(jsdom@26.1.0)(terser@5.44.1)
+        version: 3.2.4(@types/debug@4.1.12)(@types/node@25.0.8)(jiti@1.21.7)(jsdom@26.1.0)(terser@5.44.1)

 packages:

@@ -195,13 +195,13 @@ packages:
    resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
    engines: {node: '>=6.9.0'}

-  '@babel/parser@7.28.5':
-    resolution: {integrity: sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==}
+  '@babel/parser@7.28.6':
+    resolution: {integrity: sha512-TeR9zWR18BvbfPmGbLampPMW+uW1NZnJlRuuHso8i87QZNq2JRF9i6RgxRqtEq+wQGsS19NNTWr2duhnE49mfQ==}
    engines: {node: '>=6.0.0'}
    hasBin: true

-  '@babel/types@7.28.5':
-    resolution: {integrity: sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==}
+  '@babel/types@7.28.6':
+    resolution: {integrity: sha512-0ZrskXVEHSWIqZM/sQZ4EV3jZJXRkio/WCxaqKZP1g//CEWEPSfeZFcms4XeKBCHU0ZKnIkdJeU/kF+eRp5lBg==}
    engines: {node: '>=6.9.0'}

  '@csstools/color-helpers@5.1.0':
@@ -240,91 +240,91 @@ packages:
    resolution: {integrity: sha512-XQsZgjm2EcVUiZQf11UBJQfmZeEmOW8DpI1gsFeln6w0ae0ii4dMQEQ0kjl6DspdWX1aGY1/loyXnP0JS06e/A==}
    engines: {node: '>=0.8.0'}

-  '@electron-forge/cli@7.10.2':
-    resolution: {integrity: sha512-X1RtS5IqNgzGDS2rr1q0Y74wU/m3DbU4vSgllNun1ZQv1BfMpDcKLhnKi3aeetoA0huLTpMVU9eWJ7bziI9fxA==}
+  '@electron-forge/cli@7.11.1':
+    resolution: {integrity: sha512-pk8AoLsr7t7LBAt0cFD06XFA6uxtPdvtLx06xeal7O9o7GHGCbj29WGwFoJ8Br/ENM0Ho868S3PrAn1PtBXt5g==}
    engines: {node: '>= 16.4.0'}
    hasBin: true

-  '@electron-forge/core-utils@7.10.2':
-    resolution: {integrity: sha512-JXrk2hWR4q8KgZFABpojjuqql3tYeVIH6qmtbkNEkZEQq7YIxajJBCct7J7bWfNQTmHotsQ3k5KLknhyhTaBMw==}
+  '@electron-forge/core-utils@7.11.1':
+    resolution: {integrity: sha512-9UxRWVsfcziBsbAA2MS0Oz4yYovQCO2BhnGIfsbKNTBtMc/RcVSxAS0NMyymce44i43p1ZC/FqWhnt1XqYw3bQ==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/core@7.10.2':
-    resolution: {integrity: sha512-HAIuOtpOfGjA0cd55tbEV2gAv+A7tSZg9bonmVDYFEe6dBgbLk8a3+/1fJUdWW8fyFkg1wa8zK7pjP751bAXsA==}
+  '@electron-forge/core@7.11.1':
+    resolution: {integrity: sha512-YtuPLzggPKPabFAD2rOZFE0s7f4KaUTpGRduhSMbZUqpqD1TIPyfoDBpYiZvao3Ht8pyZeOJjbzcC0LpFs9gIQ==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/maker-base@7.10.2':
-    resolution: {integrity: sha512-1QN4qnPVTjo+qWYG+s0kYv7XcuIowsPVvbl718FgJUcvkxyRjUA6kWHjFxRvdV6g7Sa2PzZBF+/Mrjpws1lehQ==}
+  '@electron-forge/maker-base@7.11.1':
+    resolution: {integrity: sha512-yhZrCGoN6bDeiB5DHFaueZ1h84AReElEj+f0hl2Ph4UbZnO0cnLpbx+Bs+XfMLAiA+beC8muB5UDK5ysfuT9BQ==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/maker-deb@7.10.2':
-    resolution: {integrity: sha512-4MPr9NW5UbEUbf9geZn5R/0O/QVIiy2EgUXOYOeKkA7oR8U6I1I3+BytYFHYcxbY6+PGhi1H1VTLJLITbHGVWw==}
+  '@electron-forge/maker-deb@7.11.1':
+    resolution: {integrity: sha512-QTYiryQLYPDkq6pIfBmx0GQ6D8QatUkowH7rTlW5MnCUa0uumX0Xu7yGIjesuwW37fxT3Lv4xi+FSXMCm2eC1w==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/maker-flatpak@7.10.2':
-    resolution: {integrity: sha512-LldkYGkIhri99+HqetGjNzi2cdXy32o5uLlr7fDLoiegm8WAkvvWxFTLdSDS1RP94f6PVOKR9KHqPauu5GaIYw==}
+  '@electron-forge/maker-flatpak@7.11.1':
+    resolution: {integrity: sha512-H7+aa1OkJUHBj08DdbhSz2gL1hD/IowYpVS+uv7e6PcDqRYy/5XQQ2FoX52+3Qlik8d+tai7iOzVGcqb+D7f0Q==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/maker-rpm@7.10.2':
-    resolution: {integrity: sha512-LQoeYzbY/z1yuBBA+bNutCJmhCA4NcXUbFO4OTqsIX8B6y1zNTYZT4JEuhoK7eBsP4/Rz6u/JnNp0XOyjftOUQ==}
+  '@electron-forge/maker-rpm@7.11.1':
+    resolution: {integrity: sha512-iEfJPRQQyaTqk2EbUfZgulChNWvxGXeYUH0xBX/r5cj1pL4vcJXt3jLMQBVn3mk/0Ytv9UWRs8R/XuNWX6sf2w==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/maker-squirrel@7.10.2':
-    resolution: {integrity: sha512-Y5EhNSBXf4a7qcq+BK/x5qVDlQ1Gez5V+arUpDvVxf1zwvsB1aSyAjmoBrOKGYD9A5pJzjkMWMDw95MStl1W4A==}
+  '@electron-forge/maker-squirrel@7.11.1':
+    resolution: {integrity: sha512-oSg7fgad6l+X0DjtRkSpMzB0AjzyDO4mb2gzM4kTodkP1ADeiMi08bxy0ZeCESqLm5+fG72cAPmEr3BAPvI1yw==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/maker-zip@7.10.2':
-    resolution: {integrity: sha512-APRqVPM+O1rj4O7sk5f8tqJpS5UgxcUJEsCnXN4JRpdRvsOlMopzYZdazlCLH9l7S+r4ZKirjtMluIGeYq8YOg==}
+  '@electron-forge/maker-zip@7.11.1':
+    resolution: {integrity: sha512-30rcp0AbJLfkFBX2hmO14LKXx7z9V61LffTVbTCFMh5vUB2kZvcA5xAhsBk2oUJWfGVxe1DuSEU0rDR9bUMHUg==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/plugin-auto-unpack-natives@7.10.2':
-    resolution: {integrity: sha512-uQnahm1DECwqI8hBC7PKccyfovY/YqHNz8de3OxyjQDmwsqQfCA8Ucyh1E9n4NMEpw6Co8KLn+qF2BuIOsftLA==}
+  '@electron-forge/plugin-auto-unpack-natives@7.11.1':
+    resolution: {integrity: sha512-5uRM3WNv7jIeDt8pLP3V4U2puWHPGJ/3qRuSE47RKgTp5qxpZidWHSYcEJJxjoqOL/7KFwSqKSQ/a36GoZV4Fg==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/plugin-base@7.10.2':
-    resolution: {integrity: sha512-+4YLmkLZxvS6JFXYNI4dHt8Il8iIvwk2o6lCJGwNysOUq2KOZ3Wu1He4Ko8HhKcO1VWbFvslbh57oQn963Aryw==}
+  '@electron-forge/plugin-base@7.11.1':
+    resolution: {integrity: sha512-lKpSOV1GA3FoYiD9k05i6v4KaQVmojnRgCr7d6VL1bFp13QOtXSaAWhFI9mtSY7rGElOacX6Zt7P7rPoB8T9eQ==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/plugin-fuses@7.10.2':
-    resolution: {integrity: sha512-X8FaBL5pVvKCTBNaa9EjbH6vuaeIU7UcPSmP9501XF4zcKPCfTbQKz49LTMl7gd5YzUm82IlqRjte12LLpcSDQ==}
+  '@electron-forge/plugin-fuses@7.11.1':
+    resolution: {integrity: sha512-Td517mHf+RjQAayFDM2kKb7NaGdRXrZfPbc7KOHlGbXthp5YTkFu2cCZGWokiqt1y1wsFaAodULhqBIg7vbbbw==}
    engines: {node: '>= 16.4.0'}
    peerDependencies:
      '@electron/fuses': ^1.0.0

-  '@electron-forge/plugin-vite@7.10.2':
-    resolution: {integrity: sha512-aHotwaVlbSwVDb+Z+JdU6cMYhestt8ncmXKv4Uwm7of/gWAdvS7o/ohQVWkjXhzSidriCTwFMRz4jELJbnkNeg==}
+  '@electron-forge/plugin-vite@7.11.1':
+    resolution: {integrity: sha512-kc/WQs/0+9VC9Q4oSSocMa02YxKDvAYxhWtNcL+qlswZMJlxe8gX7vl/yXq9AjPQxw7f3jzf7nruUPKQ+vyLLg==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/publisher-base@7.10.2':
-    resolution: {integrity: sha512-2k2VOY0wOoAgQoQXn/u3EJ2Ka2v363+wC/+zUMTWGeRHW8pRwX84WX2SpsTttRzbsqAEMJYw5FAzgMBEQUTfpg==}
+  '@electron-forge/publisher-base@7.11.1':
+    resolution: {integrity: sha512-rXE9oMFGMtdQrixnumWYH5TTGsp99iPHZb3jI74YWq518ctCh6DlIgWlhf6ok2X0+lhWovcIb45KJucUFAQ13w==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/shared-types@7.10.2':
-    resolution: {integrity: sha512-e2pd9RsdbKwsNf6UtKoolmJGy92Nc0/XO4SI91doV8cM954hM2XSYz3VHoqXebMFAF1JDfXoEUt6UCRbEDgMgw==}
+  '@electron-forge/shared-types@7.11.1':
+    resolution: {integrity: sha512-vvBWdAEh53UJlDGUevpaJk1+sqDMQibfrbHR+0IPA4MPyQex7/Uhv3vYH9oGHujBVAChQahjAuJt0fG6IJBLZg==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/template-base@7.10.2':
-    resolution: {integrity: sha512-D9DbEx3rtikIhUyn4tcz2pJqHNU/+FXKNnzSvmrJoJ9LusR3C42OU9GtbU8oT3nawpnCGgPFIOGXrzexFPp6DA==}
+  '@electron-forge/template-base@7.11.1':
+    resolution: {integrity: sha512-XpTaEf+EfQw+0BlSAtSpZKYIKYvKu4raNzSGHZZoSYHp+HDC7R+MlpFQmSJiGdYQzQ14C+uxO42tVjgM0DMbpw==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/template-vite-typescript@7.10.2':
-    resolution: {integrity: sha512-df7rpxxIOIyZn0RfQ1GIlLW7dXhxkerc9uZ3ozO4C7zfvip3z0Mg+wS1synktPfr4WISaPktIdnj3mVu6Uu7Mw==}
+  '@electron-forge/template-vite-typescript@7.11.1':
+    resolution: {integrity: sha512-Us4AHXFb+4z+gXgZImSqMBS63oKnsQWLOhqRg321xiDzu2UcQPlwgWNb4rAEKNVC1e7LXrUNDHuBiTrQkvWXbg==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/template-vite@7.10.2':
-    resolution: {integrity: sha512-hR9HBOM902yq7zhFl8bO3w5ufMgitdd5ZwDzAdKITFh2ttZemHy9ha5S0K+R+4GoXHz8t7hUTHk8+iPy09qrpA==}
+  '@electron-forge/template-vite@7.11.1':
+    resolution: {integrity: sha512-Or8Lxf4awoeUZoMTKJEw5KQDIhqOFs24WhVka3yZXxc6VgVWN79KmYKYM6uM/YMQttmafhsBhY2t1Lxo1WR/ug==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/template-webpack-typescript@7.10.2':
-    resolution: {integrity: sha512-JtrLUAFbxxWJ1kU7b8MNyL5SO9/rY5UeNz1b9hvMvilW8GxyMWUen58dafgdnx3OpKLNZnhOOhgRagNppEzJOA==}
+  '@electron-forge/template-webpack-typescript@7.11.1':
+    resolution: {integrity: sha512-6ExfFnFkHBz8rvRFTFg5HVGTC12uJpbVk4q8DVg0R8rhhxhqiVNh8lF2UPtZ2yT2UtGWjXNVlyP3Y3T6q6E3GQ==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/template-webpack@7.10.2':
-    resolution: {integrity: sha512-VIUXA+XHM5SLjg7fIpOOmBsgi0LstkjrEz4gUzVL0AaITM7e+BCziIHld1ceXLbQ1FnKtrUGnQ9X/cHYxYvhHg==}
+  '@electron-forge/template-webpack@7.11.1':
+    resolution: {integrity: sha512-15lbXxi+er461MPk6sbwAOyjofAHwmQjTvxNCiNpaU2naEwbj3t0SlLq/BMr5HxnVOaMmA7+lKV9afkIom+d4Q==}
    engines: {node: '>= 16.4.0'}

-  '@electron-forge/tracer@7.10.2':
-    resolution: {integrity: sha512-jhLLQbttfZViSOYn/3SJc8HML+jNZAytPVJwgGGd3coUiFysWJ2Xald99iqOiouPAhIigBfNPxQb/q/EbcDu4g==}
+  '@electron-forge/tracer@7.11.1':
+    resolution: {integrity: sha512-tiB6cglVQFcSw9N8GRwVwZUeB9u0DOx2Mj7aFXBUsFLUYQapvVGv51tUSy/UAW5lvmubGscYIILuVko+II3+NA==}
    engines: {node: '>= 14.17.5'}

  '@electron/asar@3.4.1':
@@ -995,11 +995,11 @@ packages:
  '@types/mute-stream@0.0.4':
    resolution: {integrity: sha512-CPM9nzrCPPJHQNA9keH9CVkVI+WR5kMa+7XEs5jcGQ0VoAGnLv242w8lIVgwAEfmE4oufJRaTc9PNLQl0ioAow==}

-  '@types/node@22.19.3':
-    resolution: {integrity: sha512-1N9SBnWYOJTrNZCdh/yJE+t910Y128BoyY+zBLWhL3r0TYzlTmFdXrPwHL9DyFZmlEXNQQolTZh3KHV31QDhyA==}
+  '@types/node@22.19.6':
+    resolution: {integrity: sha512-qm+G8HuG6hOHQigsi7VGuLjUVu6TtBo/F05zvX04Mw2uCg9Dv0Qxy3Qw7j41SidlTcl5D/5yg0SEZqOB+EqZnQ==}

-  '@types/node@25.0.3':
-    resolution: {integrity: sha512-W609buLVRVmeW693xKfzHeIV6nJGGz98uCPfeXI1ELMLXVeKYZ9m15fAMSaUPBHYLGFsVRcMmSCksQOrZV9BYA==}
+  '@types/node@25.0.8':
+    resolution: {integrity: sha512-powIePYMmC3ibL0UJ2i2s0WIbq6cg6UyVFQxSCpaPxxzAaziRfimGivjdF943sSGV6RADVbk0Nvlm5P/FB44Zg==}

  '@types/plist@3.0.5':
    resolution: {integrity: sha512-E6OCaRmAe4WDmWNsL/9RMqdkkzDCY1etutkflWk4c+AcjDU07Pcz1fQwTX0TQz+Pxqn9i4L1TU3UFpjnrcDgxA==}
@@ -1058,8 +1058,8 @@ packages:
  '@vitest/utils@3.2.4':
    resolution: {integrity: sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==}

-  '@vscode/sudo-prompt@9.3.1':
-    resolution: {integrity: sha512-9ORTwwS74VaTn38tNbQhsA5U44zkJfcb0BdTSyyG6frP4e8KMtHuTXYmwefe5dpL8XB1aGSIVTaLjD3BbWb5iA==}
+  '@vscode/sudo-prompt@9.3.2':
+    resolution: {integrity: sha512-gcXoCN00METUNFeQOFJ+C9xUI0DKB+0EGMVg7wbVYRHBw2Eq3fKisDZOkRdOz3kqXRKOENMfShPOmypw1/8nOw==}

  '@vue/compiler-core@3.5.26':
    resolution: {integrity: sha512-vXyI5GMfuoBCnv5ucIT7jhHKl55Y477yxP6fc4eUswjP8FG3FFVFd41eNDArR+Uk3QKn2Z85NavjaxLxOC19/w==}
@@ -1323,8 +1323,8 @@ packages:
  base64-js@1.5.1:
    resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}

-  baseline-browser-mapping@2.9.12:
-    resolution: {integrity: sha512-Mij6Lij93pTAIsSYy5cyBQ975Qh9uLEc5rwGTpomiZeXZL9yIS6uORJakb3ScHgfs0serMMfIbXzokPMuEiRyw==}
+  baseline-browser-mapping@2.9.14:
+    resolution: {integrity: sha512-B0xUquLkiGLgHhpPBqvl7GWegWBUNuujQ6kXd/r1U38ElPT6Ok8KZ8e+FpUGEc2ZoRQUzq/aUnaKFc/svWUGSg==}
    hasBin: true

  binary-extensions@2.3.0:
@@ -1414,8 +1414,8 @@ packages:
    resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==}
    engines: {node: '>=6'}

-  caniuse-lite@1.0.30001762:
-    resolution: {integrity: sha512-PxZwGNvH7Ak8WX5iXzoK1KPZttBXNPuaOvI2ZYU7NrlM+d9Ov+TUvlLOBNGzVXAntMSMMlJPd+jY6ovrVjSmUw==}
+  caniuse-lite@1.0.30001764:
+    resolution: {integrity: sha512-9JGuzl2M+vPL+pz70gtMF9sHdMFbY9FJaQBi186cHKH3pSzDvzoUJUPV6fqiKIMyXbud9ZLg4F3Yza1vJ1+93g==}

  chai@5.3.3:
    resolution: {integrity: sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==}
@@ -1838,8 +1838,8 @@ packages:
    peerDependencies:
      eslint: '>=7.0.0'

-  eslint-plugin-prettier@5.5.4:
-    resolution: {integrity: sha512-swNtI95SToIz05YINMA6Ox5R057IMAmWZ26GqPxusAp1TZzj+IdY9tXNWWD3vkF/wEqydCONcwjTFpxybBqZsg==}
+  eslint-plugin-prettier@5.5.5:
+    resolution: {integrity: sha512-hscXkbqUZ2sPithAuLm5MXL+Wph+U7wHngPBv9OMWwlP8iaflyxpjTYZkmdgB4/vPIhemRlBEoLrH7UC1n7aUw==}
    engines: {node: ^14.18.0 || >=16.0.0}
    peerDependencies:
      '@types/eslint': '>=8.0.0'
@@ -3044,8 +3044,8 @@ packages:
    resolution: {integrity: sha512-SxToR7P8Y2lWmv/kTzVLC1t/GDI2WGjMwNhLLE9qtH8Q13C+aEmuRlzDst4Up4s0Wc8sF2M+J57iB3cMLqftfg==}
    engines: {node: '>=6.0.0'}

-  prettier@3.7.4:
-    resolution: {integrity: sha512-v6UNi1+3hSlVvv8fSaoUbggEM5VErKmmpGA7Pl3HF8V6uKY7rvClBOJlH6yNwQtfTueNkGVpOv/mtWL9L4bgRA==}
+  prettier@3.8.0:
+    resolution: {integrity: sha512-yEPsovQfpxYfgWNhCfECjG5AQaO+K3dp6XERmOepyPDVqcJm+bjyCVO3pmU+nAPe0N5dDvekfGezt/EIiRe1TA==}
    engines: {node: '>=14'}
    hasBin: true

@@ -3242,8 +3242,9 @@ packages:
  sanitize-filename@1.6.3:
    resolution: {integrity: sha512-y/52Mcy7aw3gRm7IrcGDFx/bCk4AhRh2eI9luHOQM86nZsqwiRkkq2GekHXBBD+SmPidc8i2PqtYZl+pWJ8Oeg==}

-  sax@1.4.3:
-    resolution: {integrity: sha512-yqYn1JhPczigF94DMS+shiDMjDowYO6y9+wB/4WgO0Y19jWYk0lQ4tuG5KI7kj4FTp1wxPj5IFfcrz/s1c3jjQ==}
+  sax@1.4.4:
+    resolution: {integrity: sha512-1n3r/tGXO6b6VXMdFT54SHzT9ytu9yr7TaELowdYpMqY/Ao7EnlQGmAQ1+RatX7Tkkdm6hONI2owqNx2aZj5Sw==}
+    engines: {node: '>=11.0.0'}

  saxes@6.0.0:
    resolution: {integrity: sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==}
@@ -3439,8 +3440,8 @@ packages:
  symbol-tree@3.2.4:
    resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}

-  synckit@0.11.11:
-    resolution: {integrity: sha512-MeQTA1r0litLUf0Rp/iisCaL8761lKAZHaimlbGK4j0HysC4PLfqygQj9srcs0m2RdtDYnF8UuYyKpbjHYp7Jw==}
+  synckit@0.11.12:
+    resolution: {integrity: sha512-Bh7QjT8/SuKUIfObSXNHNSK6WHo6J1tHCqJsuaFDP7gP0fkzSfTxI8y85JrppZ0h8l0maIgc2tfuZQ6/t3GtnQ==}
    engines: {node: ^14.18.0 || >=16.0.0}

  tailwindcss@3.4.19:
@@ -3991,11 +3992,11 @@ snapshots:

  '@babel/helper-validator-identifier@7.28.5': {}

-  '@babel/parser@7.28.5':
+  '@babel/parser@7.28.6':
    dependencies:
-      '@babel/types': 7.28.5
+      '@babel/types': 7.28.6

-  '@babel/types@7.28.5':
+  '@babel/types@7.28.6':
    dependencies:
      '@babel/helper-string-parser': 7.27.1
      '@babel/helper-validator-identifier': 7.28.5
@@ -4029,11 +4030,11 @@ snapshots:
    dependencies:
      '@types/hammerjs': 2.0.46

-  '@electron-forge/cli@7.10.2(encoding@0.1.13)':
+  '@electron-forge/cli@7.11.1(encoding@0.1.13)':
    dependencies:
-      '@electron-forge/core': 7.10.2(encoding@0.1.13)
-      '@electron-forge/core-utils': 7.10.2
-      '@electron-forge/shared-types': 7.10.2
+      '@electron-forge/core': 7.11.1(encoding@0.1.13)
+      '@electron-forge/core-utils': 7.11.1
+      '@electron-forge/shared-types': 7.11.1
      '@electron/get': 3.1.0
      '@inquirer/prompts': 6.0.1
      '@listr2/prompt-adapter-inquirer': 2.0.22(@inquirer/prompts@6.0.1)
@@ -4053,9 +4054,9 @@ snapshots:
      - uglify-js
      - webpack-cli

-  '@electron-forge/core-utils@7.10.2':
+  '@electron-forge/core-utils@7.11.1':
    dependencies:
-      '@electron-forge/shared-types': 7.10.2
+      '@electron-forge/shared-types': 7.11.1
      '@electron/rebuild': 3.7.2
      '@malept/cross-spawn-promise': 2.0.0
      chalk: 4.1.2
@@ -4069,24 +4070,24 @@ snapshots:
      - bluebird
      - supports-color

-  '@electron-forge/core@7.10.2(encoding@0.1.13)':
+  '@electron-forge/core@7.11.1(encoding@0.1.13)':
    dependencies:
-      '@electron-forge/core-utils': 7.10.2
-      '@electron-forge/maker-base': 7.10.2
-      '@electron-forge/plugin-base': 7.10.2
-      '@electron-forge/publisher-base': 7.10.2
-      '@electron-forge/shared-types': 7.10.2
-      '@electron-forge/template-base': 7.10.2
-      '@electron-forge/template-vite': 7.10.2
-      '@electron-forge/template-vite-typescript': 7.10.2
-      '@electron-forge/template-webpack': 7.10.2
-      '@electron-forge/template-webpack-typescript': 7.10.2
-      '@electron-forge/tracer': 7.10.2
+      '@electron-forge/core-utils': 7.11.1
+      '@electron-forge/maker-base': 7.11.1
+      '@electron-forge/plugin-base': 7.11.1
+      '@electron-forge/publisher-base': 7.11.1
+      '@electron-forge/shared-types': 7.11.1
+      '@electron-forge/template-base': 7.11.1
+      '@electron-forge/template-vite': 7.11.1
+      '@electron-forge/template-vite-typescript': 7.11.1
+      '@electron-forge/template-webpack': 7.11.1
+      '@electron-forge/template-webpack-typescript': 7.11.1
+      '@electron-forge/tracer': 7.11.1
      '@electron/get': 3.1.0
      '@electron/packager': 18.4.4
      '@electron/rebuild': 3.7.2
      '@malept/cross-spawn-promise': 2.0.0
-      '@vscode/sudo-prompt': 9.3.1
+      '@vscode/sudo-prompt': 9.3.2
      chalk: 4.1.2
      debug: 4.4.3
      fast-glob: 3.3.3
@@ -4114,29 +4115,29 @@ snapshots:
      - uglify-js
      - webpack-cli

-  '@electron-forge/maker-base@7.10.2':
+  '@electron-forge/maker-base@7.11.1':
    dependencies:
-      '@electron-forge/shared-types': 7.10.2
+      '@electron-forge/shared-types': 7.11.1
      fs-extra: 10.1.0
      which: 2.0.2
    transitivePeerDependencies:
      - bluebird
      - supports-color

-  '@electron-forge/maker-deb@7.10.2':
+  '@electron-forge/maker-deb@7.11.1':
    dependencies:
-      '@electron-forge/maker-base': 7.10.2
-      '@electron-forge/shared-types': 7.10.2
+      '@electron-forge/maker-base': 7.11.1
+      '@electron-forge/shared-types': 7.11.1
    optionalDependencies:
      electron-installer-debian: 3.2.0
    transitivePeerDependencies:
      - bluebird
      - supports-color

-  '@electron-forge/maker-flatpak@7.10.2':
+  '@electron-forge/maker-flatpak@7.11.1':
    dependencies:
-      '@electron-forge/maker-base': 7.10.2
-      '@electron-forge/shared-types': 7.10.2
+      '@electron-forge/maker-base': 7.11.1
+      '@electron-forge/shared-types': 7.11.1
      fs-extra: 10.1.0
    optionalDependencies:
      '@malept/electron-installer-flatpak': 0.11.4
@@ -4144,20 +4145,20 @@ snapshots:
      - bluebird
      - supports-color

-  '@electron-forge/maker-rpm@7.10.2':
+  '@electron-forge/maker-rpm@7.11.1':
    dependencies:
-      '@electron-forge/maker-base': 7.10.2
-      '@electron-forge/shared-types': 7.10.2
+      '@electron-forge/maker-base': 7.11.1
+      '@electron-forge/shared-types': 7.11.1
    optionalDependencies:
      electron-installer-redhat: 3.4.0
    transitivePeerDependencies:
      - bluebird
      - supports-color

-  '@electron-forge/maker-squirrel@7.10.2':
+  '@electron-forge/maker-squirrel@7.11.1':
    dependencies:
-      '@electron-forge/maker-base': 7.10.2
-      '@electron-forge/shared-types': 7.10.2
+      '@electron-forge/maker-base': 7.11.1
+      '@electron-forge/shared-types': 7.11.1
      fs-extra: 10.1.0
    optionalDependencies:
      electron-winstaller: 5.4.0
@@ -4165,10 +4166,10 @@ snapshots:
      - bluebird
      - supports-color

-  '@electron-forge/maker-zip@7.10.2':
+  '@electron-forge/maker-zip@7.11.1':
    dependencies:
-      '@electron-forge/maker-base': 7.10.2
-      '@electron-forge/shared-types': 7.10.2
+      '@electron-forge/maker-base': 7.11.1
+      '@electron-forge/shared-types': 7.11.1
      cross-zip: 4.0.1
      fs-extra: 10.1.0
      got: 11.8.6
@@ -4176,34 +4177,34 @@ snapshots:
      - bluebird
      - supports-color

-  '@electron-forge/plugin-auto-unpack-natives@7.10.2':
+  '@electron-forge/plugin-auto-unpack-natives@7.11.1':
    dependencies:
-      '@electron-forge/plugin-base': 7.10.2
-      '@electron-forge/shared-types': 7.10.2
+      '@electron-forge/plugin-base': 7.11.1
+      '@electron-forge/shared-types': 7.11.1
    transitivePeerDependencies:
      - bluebird
      - supports-color

-  '@electron-forge/plugin-base@7.10.2':
+  '@electron-forge/plugin-base@7.11.1':
    dependencies:
-      '@electron-forge/shared-types': 7.10.2
+      '@electron-forge/shared-types': 7.11.1
    transitivePeerDependencies:
      - bluebird
      - supports-color

-  '@electron-forge/plugin-fuses@7.10.2(@electron/fuses@1.8.0)':
+  '@electron-forge/plugin-fuses@7.11.1(@electron/fuses@1.8.0)':
    dependencies:
-      '@electron-forge/plugin-base': 7.10.2
-      '@electron-forge/shared-types': 7.10.2
+      '@electron-forge/plugin-base': 7.11.1
+      '@electron-forge/shared-types': 7.11.1
      '@electron/fuses': 1.8.0
    transitivePeerDependencies:
      - bluebird
      - supports-color

-  '@electron-forge/plugin-vite@7.10.2':
+  '@electron-forge/plugin-vite@7.11.1':
    dependencies:
-      '@electron-forge/plugin-base': 7.10.2
-      '@electron-forge/shared-types': 7.10.2
+      '@electron-forge/plugin-base': 7.11.1
+      '@electron-forge/shared-types': 7.11.1
      chalk: 4.1.2
      debug: 4.4.3
      fs-extra: 10.1.0
@@ -4212,16 +4213,16 @@ snapshots:
      - bluebird
      - supports-color

-  '@electron-forge/publisher-base@7.10.2':
+  '@electron-forge/publisher-base@7.11.1':
    dependencies:
-      '@electron-forge/shared-types': 7.10.2
+      '@electron-forge/shared-types': 7.11.1
    transitivePeerDependencies:
      - bluebird
      - supports-color

-  '@electron-forge/shared-types@7.10.2':
+  '@electron-forge/shared-types@7.11.1':
    dependencies:
-      '@electron-forge/tracer': 7.10.2
+      '@electron-forge/tracer': 7.11.1
      '@electron/packager': 18.4.4
      '@electron/rebuild': 3.7.2
      listr2: 7.0.2
@@ -4229,10 +4230,10 @@ snapshots:
      - bluebird
      - supports-color

-  '@electron-forge/template-base@7.10.2':
+  '@electron-forge/template-base@7.11.1':
    dependencies:
-      '@electron-forge/core-utils': 7.10.2
-      '@electron-forge/shared-types': 7.10.2
+      '@electron-forge/core-utils': 7.11.1
+      '@electron-forge/shared-types': 7.11.1
      '@malept/cross-spawn-promise': 2.0.0
      debug: 4.4.3
      fs-extra: 10.1.0
@@ -4242,28 +4243,28 @@ snapshots:
      - bluebird
      - supports-color

-  '@electron-forge/template-vite-typescript@7.10.2':
+  '@electron-forge/template-vite-typescript@7.11.1':
    dependencies:
-      '@electron-forge/shared-types': 7.10.2
-      '@electron-forge/template-base': 7.10.2
+      '@electron-forge/shared-types': 7.11.1
+      '@electron-forge/template-base': 7.11.1
      fs-extra: 10.1.0
    transitivePeerDependencies:
      - bluebird
      - supports-color

-  '@electron-forge/template-vite@7.10.2':
+  '@electron-forge/template-vite@7.11.1':
    dependencies:
-      '@electron-forge/shared-types': 7.10.2
-      '@electron-forge/template-base': 7.10.2
+      '@electron-forge/shared-types': 7.11.1
+      '@electron-forge/template-base': 7.11.1
      fs-extra: 10.1.0
    transitivePeerDependencies:
      - bluebird
      - supports-color

-  '@electron-forge/template-webpack-typescript@7.10.2':
+  '@electron-forge/template-webpack-typescript@7.11.1':
    dependencies:
-      '@electron-forge/shared-types': 7.10.2
-      '@electron-forge/template-base': 7.10.2
+      '@electron-forge/shared-types': 7.11.1
+      '@electron-forge/template-base': 7.11.1
      fs-extra: 10.1.0
      typescript: 5.4.5
      webpack: 5.104.1
@@ -4275,16 +4276,16 @@ snapshots:
      - uglify-js
      - webpack-cli

-  '@electron-forge/template-webpack@7.10.2':
+  '@electron-forge/template-webpack@7.11.1':
    dependencies:
-      '@electron-forge/shared-types': 7.10.2
-      '@electron-forge/template-base': 7.10.2
+      '@electron-forge/shared-types': 7.11.1
+      '@electron-forge/template-base': 7.11.1
      fs-extra: 10.1.0
    transitivePeerDependencies:
      - bluebird
      - supports-color

-  '@electron-forge/tracer@7.10.2':
+  '@electron-forge/tracer@7.11.1':
    dependencies:
      chrome-trace-event: 1.0.4

@@ -4381,7 +4382,7 @@ snapshots:
      junk: 3.1.0
      parse-author: 2.0.0
      plist: 3.1.0
-      prettier: 3.7.4
+      prettier: 3.8.0
      resedit: 2.0.3
      resolve: 1.22.11
      semver: 7.7.3
@@ -4605,7 +4606,7 @@ snapshots:
      '@inquirer/figures': 1.0.15
      '@inquirer/type': 2.0.0
      '@types/mute-stream': 0.0.4
-      '@types/node': 22.19.3
+      '@types/node': 22.19.6
      '@types/wrap-ansi': 3.0.0
      ansi-escapes: 4.3.2
      cli-width: 4.1.0
@@ -4943,7 +4944,7 @@ snapshots:
    dependencies:
      '@types/http-cache-semantics': 4.0.4
      '@types/keyv': 3.1.4
-      '@types/node': 25.0.3
+      '@types/node': 25.0.8
      '@types/responselike': 1.0.3

  '@types/chai@5.2.3':
@@ -4971,7 +4972,7 @@ snapshots:

  '@types/fs-extra@9.0.13':
    dependencies:
-      '@types/node': 25.0.3
+      '@types/node': 25.0.8

  '@types/hammerjs@2.0.46': {}

@@ -4981,25 +4982,25 @@ snapshots:

  '@types/keyv@3.1.4':
    dependencies:
-      '@types/node': 25.0.3
+      '@types/node': 25.0.8

  '@types/ms@2.1.0': {}

  '@types/mute-stream@0.0.4':
    dependencies:
-      '@types/node': 22.19.3
+      '@types/node': 22.19.6

-  '@types/node@22.19.3':
+  '@types/node@22.19.6':
    dependencies:
      undici-types: 6.21.0

-  '@types/node@25.0.3':
+  '@types/node@25.0.8':
    dependencies:
      undici-types: 7.16.0

  '@types/plist@3.0.5':
    dependencies:
-      '@types/node': 25.0.3
+      '@types/node': 25.0.8
      xmlbuilder: 15.1.1
    optional: true

@@ -5007,7 +5008,7 @@ snapshots:

  '@types/responselike@1.0.3':
    dependencies:
-      '@types/node': 25.0.3
+      '@types/node': 25.0.8

  '@types/trusted-types@2.0.7':
    optional: true
@@ -5019,12 +5020,12 @@ snapshots:

  '@types/yauzl@2.10.3':
    dependencies:
-      '@types/node': 22.19.3
+      '@types/node': 22.19.6
    optional: true

-  '@vitejs/plugin-vue@5.2.4(vite@6.4.1(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1))(vue@3.5.26(typescript@5.9.3))':
+  '@vitejs/plugin-vue@5.2.4(vite@6.4.1(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1))(vue@3.5.26(typescript@5.9.3))':
    dependencies:
-      vite: 6.4.1(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1)
+      vite: 6.4.1(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1)
      vue: 3.5.26(typescript@5.9.3)

  '@vitest/expect@3.2.4':
@@ -5035,13 +5036,13 @@ snapshots:
      chai: 5.3.3
      tinyrainbow: 2.0.0

-  '@vitest/mocker@3.2.4(vite@6.4.1(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1))':
+  '@vitest/mocker@3.2.4(vite@6.4.1(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1))':
    dependencies:
      '@vitest/spy': 3.2.4
      estree-walker: 3.0.3
      magic-string: 0.30.21
    optionalDependencies:
-      vite: 6.4.1(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1)
+      vite: 6.4.1(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1)

  '@vitest/pretty-format@3.2.4':
    dependencies:
@@ -5069,11 +5070,11 @@ snapshots:
      loupe: 3.2.1
      tinyrainbow: 2.0.0

-  '@vscode/sudo-prompt@9.3.1': {}
+  '@vscode/sudo-prompt@9.3.2': {}

  '@vue/compiler-core@3.5.26':
    dependencies:
-      '@babel/parser': 7.28.5
+      '@babel/parser': 7.28.6
      '@vue/shared': 3.5.26
      entities: 7.0.0
      estree-walker: 2.0.2
@@ -5086,7 +5087,7 @@ snapshots:

  '@vue/compiler-sfc@3.5.26':
    dependencies:
-      '@babel/parser': 7.28.5
+      '@babel/parser': 7.28.6
      '@vue/compiler-core': 3.5.26
      '@vue/compiler-dom': 3.5.26
      '@vue/compiler-ssr': 3.5.26
@@ -5103,12 +5104,12 @@ snapshots:

  '@vue/devtools-api@6.6.4': {}

-  '@vue/eslint-config-prettier@10.2.0(@types/eslint@9.6.1)(eslint@9.39.2(jiti@1.21.7))(prettier@3.7.4)':
+  '@vue/eslint-config-prettier@10.2.0(@types/eslint@9.6.1)(eslint@9.39.2(jiti@1.21.7))(prettier@3.8.0)':
    dependencies:
      eslint: 9.39.2(jiti@1.21.7)
      eslint-config-prettier: 10.1.8(eslint@9.39.2(jiti@1.21.7))
-      eslint-plugin-prettier: 5.5.4(@types/eslint@9.6.1)(eslint-config-prettier@10.1.8(eslint@9.39.2(jiti@1.21.7)))(eslint@9.39.2(jiti@1.21.7))(prettier@3.7.4)
-      prettier: 3.7.4
+      eslint-plugin-prettier: 5.5.5(@types/eslint@9.6.1)(eslint-config-prettier@10.1.8(eslint@9.39.2(jiti@1.21.7)))(eslint@9.39.2(jiti@1.21.7))(prettier@3.8.0)
+      prettier: 3.8.0
    transitivePeerDependencies:
      - '@types/eslint'

@@ -5382,7 +5383,7 @@ snapshots:
  autoprefixer@10.4.23(postcss@8.5.6):
    dependencies:
      browserslist: 4.28.1
-      caniuse-lite: 1.0.30001762
+      caniuse-lite: 1.0.30001764
      fraction.js: 5.3.4
      picocolors: 1.1.1
      postcss: 8.5.6
@@ -5400,7 +5401,7 @@ snapshots:

  base64-js@1.5.1: {}

-  baseline-browser-mapping@2.9.12: {}
+  baseline-browser-mapping@2.9.14: {}

  binary-extensions@2.3.0: {}

@@ -5434,8 +5435,8 @@ snapshots:

  browserslist@4.28.1:
    dependencies:
-      baseline-browser-mapping: 2.9.12
-      caniuse-lite: 1.0.30001762
+      baseline-browser-mapping: 2.9.14
+      caniuse-lite: 1.0.30001764
      electron-to-chromium: 1.5.267
      node-releases: 2.0.27
      update-browserslist-db: 1.2.3(browserslist@4.28.1)
@@ -5452,7 +5453,7 @@ snapshots:
  builder-util-runtime@9.5.1:
    dependencies:
      debug: 4.4.3
-      sax: 1.4.3
+      sax: 1.4.4
    transitivePeerDependencies:
      - supports-color

@@ -5540,7 +5541,7 @@ snapshots:

  camelcase@5.3.1: {}

-  caniuse-lite@1.0.30001762: {}
+  caniuse-lite@1.0.30001764: {}

  chai@5.3.3:
    dependencies:
@@ -5936,7 +5937,7 @@ snapshots:
  electron@39.2.7:
    dependencies:
      '@electron/get': 2.0.3
-      '@types/node': 22.19.3
+      '@types/node': 22.19.6
      extract-zip: 2.0.1
    transitivePeerDependencies:
      - supports-color
@@ -6032,12 +6033,12 @@ snapshots:
    dependencies:
      eslint: 9.39.2(jiti@1.21.7)

-  eslint-plugin-prettier@5.5.4(@types/eslint@9.6.1)(eslint-config-prettier@10.1.8(eslint@9.39.2(jiti@1.21.7)))(eslint@9.39.2(jiti@1.21.7))(prettier@3.7.4):
+  eslint-plugin-prettier@5.5.5(@types/eslint@9.6.1)(eslint-config-prettier@10.1.8(eslint@9.39.2(jiti@1.21.7)))(eslint@9.39.2(jiti@1.21.7))(prettier@3.8.0):
    dependencies:
      eslint: 9.39.2(jiti@1.21.7)
-      prettier: 3.7.4
+      prettier: 3.8.0
      prettier-linter-helpers: 1.0.1
-      synckit: 0.11.11
+      synckit: 0.11.12
    optionalDependencies:
      '@types/eslint': 9.6.1
      eslint-config-prettier: 10.1.8(eslint@9.39.2(jiti@1.21.7))
@@ -6626,7 +6627,7 @@ snapshots:

  jest-worker@27.5.1:
    dependencies:
-      '@types/node': 25.0.3
+      '@types/node': 25.0.8
      merge-stream: 2.0.0
      supports-color: 8.1.1

@@ -7271,7 +7272,7 @@ snapshots:
    dependencies:
      fast-diff: 1.3.0

-  prettier@3.7.4: {}
+  prettier@3.8.0: {}

  proc-log@2.0.1: {}

@@ -7300,7 +7301,7 @@ snapshots:
      '@protobufjs/path': 1.1.2
      '@protobufjs/pool': 1.1.0
      '@protobufjs/utf8': 1.1.0
-      '@types/node': 25.0.3
+      '@types/node': 25.0.8
      long: 5.3.2

  protocol-buffers-schema@3.6.0: {}
@@ -7488,7 +7489,7 @@ snapshots:
    dependencies:
      truncate-utf8-bytes: 1.0.2

-  sax@1.4.3: {}
+  sax@1.4.4: {}

  saxes@6.0.0:
    dependencies:
@@ -7684,7 +7685,7 @@ snapshots:

  symbol-tree@3.2.4: {}

-  synckit@0.11.11:
+  synckit@0.11.12:
    dependencies:
      '@pkgr/core': 0.2.9

@@ -7921,13 +7922,13 @@ snapshots:
      '@egjs/hammerjs': 2.0.17
      component-emitter: 2.0.0

-  vite-node@3.2.4(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1):
+  vite-node@3.2.4(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1):
    dependencies:
      cac: 6.7.14
      debug: 4.4.3
      es-module-lexer: 1.7.0
      pathe: 2.0.3
-      vite: 6.4.1(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1)
+      vite: 6.4.1(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1)
    transitivePeerDependencies:
      - '@types/node'
      - jiti
@@ -7942,18 +7943,18 @@ snapshots:
      - tsx
      - yaml

-  vite-plugin-vuetify@2.1.2(vite@6.4.1(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1))(vue@3.5.26(typescript@5.9.3))(vuetify@3.11.6):
+  vite-plugin-vuetify@2.1.2(vite@6.4.1(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1))(vue@3.5.26(typescript@5.9.3))(vuetify@3.11.6):
    dependencies:
      '@vuetify/loader-shared': 2.1.1(vue@3.5.26(typescript@5.9.3))(vuetify@3.11.6)
      debug: 4.4.3
      upath: 2.0.1
-      vite: 6.4.1(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1)
+      vite: 6.4.1(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1)
      vue: 3.5.26(typescript@5.9.3)
      vuetify: 3.11.6(typescript@5.9.3)(vite-plugin-vuetify@2.1.2)(vue@3.5.26(typescript@5.9.3))
    transitivePeerDependencies:
      - supports-color

-  vite@6.4.1(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1):
+  vite@6.4.1(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1):
    dependencies:
      esbuild: 0.25.12
      fdir: 6.5.0(picomatch@4.0.3)
@@ -7962,16 +7963,16 @@ snapshots:
      rollup: 4.55.1
      tinyglobby: 0.2.15
    optionalDependencies:
-      '@types/node': 25.0.3
+      '@types/node': 25.0.8
      fsevents: 2.3.3
      jiti: 1.21.7
      terser: 5.44.1

-  vitest@3.2.4(@types/debug@4.1.12)(@types/node@25.0.3)(jiti@1.21.7)(jsdom@26.1.0)(terser@5.44.1):
+  vitest@3.2.4(@types/debug@4.1.12)(@types/node@25.0.8)(jiti@1.21.7)(jsdom@26.1.0)(terser@5.44.1):
    dependencies:
      '@types/chai': 5.2.3
      '@vitest/expect': 3.2.4
-      '@vitest/mocker': 3.2.4(vite@6.4.1(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1))
+      '@vitest/mocker': 3.2.4(vite@6.4.1(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1))
      '@vitest/pretty-format': 3.2.4
      '@vitest/runner': 3.2.4
      '@vitest/snapshot': 3.2.4
@@ -7989,12 +7990,12 @@ snapshots:
      tinyglobby: 0.2.15
      tinypool: 1.1.1
      tinyrainbow: 2.0.0
-      vite: 6.4.1(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1)
-      vite-node: 3.2.4(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1)
+      vite: 6.4.1(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1)
+      vite-node: 3.2.4(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1)
      why-is-node-running: 2.3.0
    optionalDependencies:
      '@types/debug': 4.1.12
-      '@types/node': 25.0.3
+      '@types/node': 25.0.8
      jsdom: 26.1.0
    transitivePeerDependencies:
      - jiti
@@ -8051,7 +8052,7 @@ snapshots:
      vue: 3.5.26(typescript@5.9.3)
    optionalDependencies:
      typescript: 5.9.3
-      vite-plugin-vuetify: 2.1.2(vite@6.4.1(@types/node@25.0.3)(jiti@1.21.7)(terser@5.44.1))(vue@3.5.26(typescript@5.9.3))(vuetify@3.11.6)
+      vite-plugin-vuetify: 2.1.2(vite@6.4.1(@types/node@25.0.8)(jiti@1.21.7)(terser@5.44.1))(vue@3.5.26(typescript@5.9.3))(vuetify@3.11.6)

  w3c-xmlserializer@5.0.0:
    dependencies:
@@ -264,6 +264,23 @@ files = [
    {file = "audioop_lts-0.2.2.tar.gz", hash = "sha256:64d0c62d88e67b98a1a5e71987b7aa7b5bcffc7dcee65b635823dbdd0a8dbbd0"},
 ]

+[[package]]
+name = "backports-tarfile"
+version = "1.2.0"
+description = "Backport of CPython tarfile module"
+optional = false
+python-versions = ">=3.8"
+groups = ["main"]
+markers = "python_version == \"3.11\""
+files = [
+    {file = "backports.tarfile-1.2.0-py3-none-any.whl", hash = "sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34"},
+    {file = "backports_tarfile-1.2.0.tar.gz", hash = "sha256:d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991"},
+]
+
+[package.extras]
+docs = ["furo", "jaraco.packaging (>=9.3)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
+testing = ["jaraco.test", "pytest (!=8.0.*)", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)"]
+
 [[package]]
 name = "bcrypt"
 version = "5.0.0"
@@ -858,81 +875,81 @@ files = [

 [[package]]
 name = "freeze-core"
-version = "0.4.2"
+version = "0.5.0"
 description = "Core dependency for cx_Freeze"
 optional = false
 python-versions = ">=3.10"
 groups = ["dev"]
 files = [
-    {file = "freeze_core-0.4.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e59695d4b3543dc89fc9c8464ca076a5c8083962452da3ecc51cd2ad6777ab7f"},
-    {file = "freeze_core-0.4.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e6a1e733be02b986ef373e183066b0bdececde241fee88e28a5af96cce6b4a3"},
-    {file = "freeze_core-0.4.2-cp310-cp310-win32.whl", hash = "sha256:eb0513828dae5f4622f9a354ad17c5cc3aec81bf53c4bece3d414fe54482599e"},
-    {file = "freeze_core-0.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:e36417771af59d6a6bc7677085c1d1892b6874264ce50a878c76bc47e7da3ec8"},
-    {file = "freeze_core-0.4.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3663eb7f994c3976bda99dc72aa8bd8536ff2eea7e1458cbfd5eeae928b0e0f9"},
-    {file = "freeze_core-0.4.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cdee0ac751117fd4b70b1de2053a8c3d217a57aed4d55e67ded70f87bc83e4e7"},
-    {file = "freeze_core-0.4.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:9655614fdfd85005987f6d37f761f203417581bd30716a612e018fc5e711b877"},
-    {file = "freeze_core-0.4.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:282937d91e056ecec3eac794111f943075d08c3dfec3c8efc88d6529b7ff153d"},
-    {file = "freeze_core-0.4.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:eeda39821eed2a98f74611badc2ea390c124542cbe8ff912e7f536d20e11ea73"},
-    {file = "freeze_core-0.4.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f96df0f8e8839817bc58b7b942d0f3af54f4b7730bfcf86f2db524126f389f97"},
-    {file = "freeze_core-0.4.2-cp311-cp311-win32.whl", hash = "sha256:a2923128672f97058a1fe15cf4dee0ac674467a178f71c092a5d9a94a4d0be8b"},
-    {file = "freeze_core-0.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:43860e0214d9fc5e41f0c17f931773e80f870a791ea647940017bb83d81c5e66"},
-    {file = "freeze_core-0.4.2-cp311-cp311-win_arm64.whl", hash = "sha256:4a2a26acba4f3693a495a14f8481b15c6dbef99d0b5b1fcef96234b4947d2030"},
-    {file = "freeze_core-0.4.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1ba4915dbf799dade21a96eb9c521c9b0f9a2496ebe510fa54b6e6bd421fb174"},
-    {file = "freeze_core-0.4.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:db330723a6b899b32dfa038efc8cfc4f9936a01561549f75dfaeb83f13eb74a2"},
-    {file = "freeze_core-0.4.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:d02a5ea6e87242ccf228304f0483df61873b1432e75c74e1de53013d084ead9e"},
-    {file = "freeze_core-0.4.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0d2f1a9aea27825f5311f23a9b5ed52a7b0d8d5a6bb1231318252089339ae1c4"},
-    {file = "freeze_core-0.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3e5e35148ed4776d572a7b6678c2bbd6e1eb21782f0da65d6276aa52b29b392b"},
-    {file = "freeze_core-0.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be464f358ba802fad1d7907767a4875a520f8a2d655026e2cc405b22f86c54eb"},
-    {file = "freeze_core-0.4.2-cp312-cp312-win32.whl", hash = "sha256:439f3ebc79adf0ca575c20364cd266e75a222e47ae4840db3c3bdbc8d296c8dc"},
-    {file = "freeze_core-0.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:ced01393db4592d5eb86be4db5d7e57f70baf5f90968718c1b52960b09e04660"},
-    {file = "freeze_core-0.4.2-cp312-cp312-win_arm64.whl", hash = "sha256:9d978b30f92f475c863e11485dac4a810c552dd8d5376a1e3d69b4068b18ace4"},
-    {file = "freeze_core-0.4.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e822d7dadf6c4135072c86bdca2c5eea4772f32438eed497457d5c5be869b989"},
-    {file = "freeze_core-0.4.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cc471a64d13ab203402b58b41b0dd63b654dfca6741d9e9582e08275a2a582bd"},
-    {file = "freeze_core-0.4.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:96b5ba541739d7e2821db1d3eb3bbc61364be5da017ba2e3461d85b5529d7ca4"},
-    {file = "freeze_core-0.4.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7a8a56975e6d4fe17ac9237a6578cb7e07c124698aae7c99345fa5615e7462ad"},
-    {file = "freeze_core-0.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:dbec55ae2a5e7f6dbba4f62089542c1239c76adedf08ad38209397d0027c5695"},
-    {file = "freeze_core-0.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cad2c3e9815267ecb3510acbc87ba15913b6dc01e9f8e09e81599389b31c7a2c"},
-    {file = "freeze_core-0.4.2-cp313-cp313-win32.whl", hash = "sha256:e5398a9523efbfe1d8350ccd9587b5f3a1612ccd9a26fa35ad159399d4857fb1"},
-    {file = "freeze_core-0.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:d125534089278c790864ed723d301290450bb80f47aab0b17254a6f085d70a01"},
-    {file = "freeze_core-0.4.2-cp313-cp313-win_arm64.whl", hash = "sha256:82a8e980b2e0f723adaf6fbe0ccba8b3a86976689f7cdeb03609a65be45e22ad"},
-    {file = "freeze_core-0.4.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:bafd9dc93d35babc33681c48e1597f73c44cb12fdf599d0a87c967a00c1dfc50"},
-    {file = "freeze_core-0.4.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f8389f3aa06d800252a725b0f13a38dcaa88b3164428c0d023066ba796353fe9"},
-    {file = "freeze_core-0.4.2-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4877158870eb6ec22eb7e8d639c066ffe9ebf87d61b429094e77564bcc33f2f0"},
-    {file = "freeze_core-0.4.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:438336cdae8d742aed7c33e2e957b2be6458bdebe5dbd66e9ae7912bcaffa7d3"},
-    {file = "freeze_core-0.4.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:3eec7e9eb34effbaf99bf405761f6f871d8e854a7128d21211f659960c8084f1"},
-    {file = "freeze_core-0.4.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:9e998ebd1a448a0384ea4f1c13f3b360baffc86776ffb745dce0bc8f189dc9f5"},
-    {file = "freeze_core-0.4.2-cp313-cp313t-win32.whl", hash = "sha256:afad0fd1431114f3ea6e1592647f9a4bbfefa37e15606bb606b9cafe6d038ba4"},
-    {file = "freeze_core-0.4.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e7db75a7c889d4113dbf0c2ce060f79e2fe22ce9149df7c1ea9332f20d5da76d"},
-    {file = "freeze_core-0.4.2-cp313-cp313t-win_arm64.whl", hash = "sha256:497acb3e7d4d0bc9ab6374e9f01388d4b5a9f26e1d5fd730b515cdaa25532949"},
-    {file = "freeze_core-0.4.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:cf9ec119cf4c91e9a1137826b35648ede032c3795577db1814d922e76f4ccfe8"},
-    {file = "freeze_core-0.4.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:23483b68a6c2ca5afba5909764647a4abb249c2b9475a581e15c5e9a6a0581e1"},
-    {file = "freeze_core-0.4.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:b1ff94052f0863449bdf538d431d718c21cc3be1c8055174a511d65b21255233"},
-    {file = "freeze_core-0.4.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:23b096e1a3becea53f7f9cf466e9b5da0d723283c9353fafb81bef2401d7bf22"},
-    {file = "freeze_core-0.4.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:93e88c8e465674891975f4d0c7395f9926ab4484955fbdea0b30f496a6ac5309"},
-    {file = "freeze_core-0.4.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1080a654bad3b9658cc45cbb5528e48386e1e75569bf940405b1d1657a4b9cb0"},
-    {file = "freeze_core-0.4.2-cp314-cp314-win32.whl", hash = "sha256:a5ae6eca00c8d2ca607c549e1e4dec5de15a8dadb73e03c35c58409ce4302360"},
-    {file = "freeze_core-0.4.2-cp314-cp314-win_amd64.whl", hash = "sha256:a5b67313ac10828ef067f187e87d03518fa262a4a9c9d022087b9d6e953cc8be"},
-    {file = "freeze_core-0.4.2-cp314-cp314-win_arm64.whl", hash = "sha256:c03aa08c7f2ee035655848e256d0ef99920e8038550c60a84c6dcd1f857ff1f4"},
-    {file = "freeze_core-0.4.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:c4b43b52c4fc8659b9b3e29772a2b5bcc3ae5e650d30efb95e6a844294d84ce5"},
-    {file = "freeze_core-0.4.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3b965d79b592b5a31fb6f3de71ca058bbc58aad7304ad65390a18cb8cf174487"},
-    {file = "freeze_core-0.4.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:0ae7cce7fcdcd8faa96792dab1af855e566b5ad464509887b8b7a579ac36980e"},
-    {file = "freeze_core-0.4.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5e42a3fc4fae92b872503d0ee44cca9513f6dbe4edffc3a8d7dfaacaecb07e91"},
-    {file = "freeze_core-0.4.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:438f5a1167e22f9a246414fea0aff5f5b18520c365fd30f97bc1900d25d467bb"},
-    {file = "freeze_core-0.4.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:1c756aa1bc954619ab5493830861ddbc71ded6672346f9dacaf7350ffce53fe1"},
-    {file = "freeze_core-0.4.2-cp314-cp314t-win32.whl", hash = "sha256:3915f4bad2f23786ef4f78e4a3069b20e63c42d3ef2a6193f25cf0fe9f1ed82f"},
-    {file = "freeze_core-0.4.2-cp314-cp314t-win_amd64.whl", hash = "sha256:815eefedf318cc569fe127c592c92ec8e176f29210a40abe1bf18595fe04f97e"},
-    {file = "freeze_core-0.4.2-cp314-cp314t-win_arm64.whl", hash = "sha256:429d2f82e899e568d45a9cc942765b6af5426134fcd8a5c27b375d8969cfb836"},
-    {file = "freeze_core-0.4.2.tar.gz", hash = "sha256:3e1942b0908b9399b164f66712f8b222f38512950e61d16a5064d9795f0b0ac7"},
+    {file = "freeze_core-0.5.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:57d430e0a7e5c5b168da8ef249939c5e3110d8cca5db45d6c32bacd73d521c9b"},
+    {file = "freeze_core-0.5.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:e81b9b1c6dd614738eca9135306fc88232b374f1a0d2c9c4667520ff9e0cc17d"},
+    {file = "freeze_core-0.5.0-cp310-cp310-win32.whl", hash = "sha256:bdbce8ca7e52694c27865018786e2c7d37a579a46f1fa7c9335aab7bb20d5908"},
+    {file = "freeze_core-0.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:4862d89be1c34ca08400683b28a0c9fcfec201c2e9bc418a12eeba5465772d13"},
+    {file = "freeze_core-0.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:bdd89a4e6d589a4b4a46e48ab3c5ed6898b7b76bfa349d0e26242f23885efc06"},
+    {file = "freeze_core-0.5.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:93cf6f8408f41348652e106ce94e55a0e7e6bd4c30bab2d42a2e3359b3a934a8"},
+    {file = "freeze_core-0.5.0-cp311-cp311-manylinux_2_28_ppc64le.whl", hash = "sha256:6b4a1c840ccacddef7e5715e97a8c6936341911d3e094347450add6afad00282"},
+    {file = "freeze_core-0.5.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:4acb94f027ea93b2a1517e09bd8aeb00179cad9c568dd2c480f5056c5e4c274d"},
+    {file = "freeze_core-0.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0e45289b403af27cc1aa623a74703f8b65df2eb50e809069bdea296b1f5b867e"},
+    {file = "freeze_core-0.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ef1e58762bce8ad2ab5c7c91511a5b821f50fb880d6daa586b5e70e92c691bb7"},
+    {file = "freeze_core-0.5.0-cp311-cp311-win32.whl", hash = "sha256:6d534acc4e8b54921d04d01a3805eebaef15c792249039747b4186f0d26e81d8"},
+    {file = "freeze_core-0.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:c809e53b982686adc4feac23255882167ba7e86b7f337fcfa21dc43afcca28d9"},
+    {file = "freeze_core-0.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:cd978eb9591e5f46ff6abd458a8bd9461747bf2f72878bb5ab88c23cad5d6753"},
+    {file = "freeze_core-0.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:7dc19fab5850e882b6b86bd4d09fbebf38d43d878957e74a41a31566b86bf0c1"},
+    {file = "freeze_core-0.5.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:892e07cdba5634eac6bbafe05348989a3eb0cc8e685804247c5d6fa39e9113c0"},
+    {file = "freeze_core-0.5.0-cp312-cp312-manylinux_2_28_ppc64le.whl", hash = "sha256:6d92bba4eb525fe57a289498ad8c7bb6b59b3558db85facbe0a3f7ad1266a432"},
+    {file = "freeze_core-0.5.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:a0c43a93256686fa03f4ae41686a94c97eea54c546a166a87ca2b75f6b25c8c4"},
+    {file = "freeze_core-0.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b56e28f94eec90b046f4b2d832a5a17912b3547cefe2e2b1e2fcacad613a1bb2"},
+    {file = "freeze_core-0.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:59dd558e4386ac69be1d0e76274934c19c305b53224613769a278059b036d40e"},
+    {file = "freeze_core-0.5.0-cp312-cp312-win32.whl", hash = "sha256:e8621c7f13e6cf48327e5431c83e703f7f2d6d7f7732ee5b867e2042c66bf660"},
+    {file = "freeze_core-0.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f04e006df7004cc4af13e5e385370fce5bdd0e64e5a46cab3e0f0708c44b071a"},
+    {file = "freeze_core-0.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:147210046cc9ef56ac3d5432ce2d57b6fb23d4da30490659ae5a2935bb5dd7be"},
+    {file = "freeze_core-0.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:75cf1d482452458f3eed33b047b375fbcfa940ae4d20116f767693a64ce3159e"},
+    {file = "freeze_core-0.5.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:af99093ea6695571da23fbb7e7d95a8b0bc3cac2548edd80e4dcb43d2285678c"},
+    {file = "freeze_core-0.5.0-cp313-cp313-manylinux_2_28_ppc64le.whl", hash = "sha256:dc9c01e2a31e87a7ac5e7184335514ac34ae296312c15fac53d9fb2600eb3b6d"},
+    {file = "freeze_core-0.5.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:cb3b158ca1a8e05c6b7aa20c102962e5cbbd96985f80501b09f6c6bdd7ed7c00"},
+    {file = "freeze_core-0.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f0270664a912d9a437bcbd67332354d0aac533c27e59dea873478a45897e1166"},
+    {file = "freeze_core-0.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6982b8eee58bd852f7a32eb87b1a66f69cf49b3fc24ae7f1f34793a1f9c3c5e0"},
+    {file = "freeze_core-0.5.0-cp313-cp313-win32.whl", hash = "sha256:96bf863416adc9a78d8bf869ec227b951452ad901896471f150f672fa7415760"},
+    {file = "freeze_core-0.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:4751bfb30741e25fc2298f85550b7e38d0ba9065d2952660c7bcfda2aaefa049"},
+    {file = "freeze_core-0.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:3663829b51a660bf9c54eb7e586d0833623151512bbbb544a1c0c8580dd8b511"},
+    {file = "freeze_core-0.5.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:1aba0428ba7f530a5afe0b55ba8b97e656e24a43ec050de8eb0ed36c3a68b2ec"},
+    {file = "freeze_core-0.5.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:61e14c3d7e835c49bdd1d69b8060176a791d1c27355bad115f164f0cea353a09"},
+    {file = "freeze_core-0.5.0-cp313-cp313t-manylinux_2_28_ppc64le.whl", hash = "sha256:21c17829a4f65bdc79850a100b3cfb09a03872d6992cb50b80a94e895f961b1b"},
+    {file = "freeze_core-0.5.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:089011e0e33bea9edd0890a9f13a337d9aee4004bb4aa3ee5e79e285d6054589"},
+    {file = "freeze_core-0.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4b44076c3cc7019da89a65ae1f6cfc8a064411a639385675ecccece9202f1aed"},
+    {file = "freeze_core-0.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:44d253f4a6f91ced6fe9be3df21cce1d52b81229d2b35623abd64a5e53ac4f54"},
+    {file = "freeze_core-0.5.0-cp313-cp313t-win32.whl", hash = "sha256:f969761a869382e25822d2ea447f64c5f4d9210f8b1d95e5a9ca8718cd77948a"},
+    {file = "freeze_core-0.5.0-cp313-cp313t-win_amd64.whl", hash = "sha256:9cad62a9b83e6aeefac2e25220b30bf146907a70e6f10a737e679e44bbab7a2b"},
+    {file = "freeze_core-0.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:97a554713e1c85d36ea0fb7dd16a622200dcd5fcac0c90b11005296c4d08198f"},
+    {file = "freeze_core-0.5.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:99b09188be89186e1666c7cf22a46e43c9eebedf2098f17f3b53e8a5c3e93966"},
+    {file = "freeze_core-0.5.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:8122dd9434b62aa8883194c754861117d61321c08af386fc581d17ac74fecbbe"},
+    {file = "freeze_core-0.5.0-cp314-cp314-manylinux_2_28_ppc64le.whl", hash = "sha256:a0969a6a74d15dbcee638f9adea07dc18e0027d917a70f12cd550459a330ade0"},
+    {file = "freeze_core-0.5.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:d70d04d4036d9902dcb2532a3e36ede601bd6b35f71176981d512f315c9a0bb7"},
+    {file = "freeze_core-0.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fed09e4484fcf8744543d2d177a4fa6493b6cddab9204f95eaeb82d41c372b7e"},
+    {file = "freeze_core-0.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c68f2250ec5fca04852d1bf86e28d40261f4ecaaaddc752c7644958895e1909c"},
+    {file = "freeze_core-0.5.0-cp314-cp314-win32.whl", hash = "sha256:1c7ef797fa89e7de097cc04ff50267ab207fc099cc196149bc044439f8c3eb48"},
+    {file = "freeze_core-0.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:9245d64714b8b269e5f8eb583038f6c5f50126a65a298098bec03fa16054a56b"},
+    {file = "freeze_core-0.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:51c3918177241f5046cff9ce832acb931b16b453a2bbfe29e6c2fe979c8ec176"},
+    {file = "freeze_core-0.5.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:377e68b6f20867bd8547ca3a9073941231ec3fd2ee2d1649a744360711925dcf"},
+    {file = "freeze_core-0.5.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:3e913aa1e5c5f9fbdbd9b9bf613e0083d185e587ab23690f8207fc3bb586d2a2"},
+    {file = "freeze_core-0.5.0-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:833b18cabe4f405702607220a2b429a36e3979e52c9be768307dcb7fbc60fc4f"},
+    {file = "freeze_core-0.5.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:38011b6cd234cb419cecfd2934b6907739ddeaaabb570d9ffa36812a366f05fb"},
+    {file = "freeze_core-0.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0a390702f0a5dc48139ce361cf24b8349df2441255ccc4a6263bf9dc2d387d6d"},
+    {file = "freeze_core-0.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d0b9705a6d967c70475bfedf16ea6dca6d1909f31ea6e0c1c0798369c9001ee5"},
+    {file = "freeze_core-0.5.0-cp314-cp314t-win32.whl", hash = "sha256:ea290461ceab8bb4d6954183ab3aa7ee92098e254e3167a7a1e3d88bf603c9ca"},
+    {file = "freeze_core-0.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:17dc8cadac946bb7de8632d7009aa76d9612d2ee9cc056406a02be491be418f3"},
+    {file = "freeze_core-0.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:9e0ddf52dadab75881bca159bfe3876c8cc7e3727ee098da918dfbc4920970b2"},
+    {file = "freeze_core-0.5.0.tar.gz", hash = "sha256:6178c3e40cda56b41187452cfd60347c343db067a4f6a157196e634050a5fe57"},
 ]

 [package.dependencies]
 cabarchive = {version = ">=0.2.4", markers = "sys_platform == \"win32\""}
-filelock = ">=3.15.3"
+filelock = ">=3.20.1"
 striprtf = {version = ">=0.0.26", markers = "sys_platform == \"win32\""}

 [package.extras]
-dev = ["bump-my-version (==1.2.4)", "cibuildwheel (==3.3.0)", "pre-commit (==4.5.0)"]
-tests = ["coverage (==7.12.0)", "pytest (==9.0.1)"]
+dev = ["bump-my-version (==1.2.6)", "cibuildwheel (==3.3.1)", "pre-commit (==4.5.1)"]
+tests = ["coverage (==7.13.1)", "pytest (==9.0.2)"]

 [[package]]
 name = "frozenlist"
@@ -1076,14 +1093,14 @@ files = [

 [[package]]
 name = "hypothesis"
-version = "6.150.0"
+version = "6.150.2"
 description = "The property-based testing library for Python"
 optional = false
 python-versions = ">=3.10"
 groups = ["dev"]
 files = [
-    {file = "hypothesis-6.150.0-py3-none-any.whl", hash = "sha256:caf1f752418c49ac805f11d909c5831aaceb96762aa3895e0c702468dedbe3fe"},
-    {file = "hypothesis-6.150.0.tar.gz", hash = "sha256:ac263bdaf338f4899a9a56e8224304e29b3ad91799e0274783c49abd91ea35ac"},
+    {file = "hypothesis-6.150.2-py3-none-any.whl", hash = "sha256:648d6a2be435889e713ba3d335b0fb5e7a250f569b56e6867887c1e7a0d1f02f"},
+    {file = "hypothesis-6.150.2.tar.gz", hash = "sha256:deb043c41c53eaf0955f4a08739c2a34c3d8040ee3d9a2da0aa5470122979f75"},
 ]

 [package.dependencies]
@@ -1134,6 +1151,29 @@ files = [
    {file = "iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730"},
 ]

+[[package]]
+name = "jaraco-context"
+version = "6.1.0"
+description = "Useful decorators and context managers"
+optional = false
+python-versions = ">=3.9"
+groups = ["main"]
+files = [
+    {file = "jaraco_context-6.1.0-py3-none-any.whl", hash = "sha256:a43b5ed85815223d0d3cfdb6d7ca0d2bc8946f28f30b6f3216bda070f68badda"},
+    {file = "jaraco_context-6.1.0.tar.gz", hash = "sha256:129a341b0a85a7db7879e22acd66902fda67882db771754574338898b2d5d86f"},
+]
+
+[package.dependencies]
+"backports.tarfile" = {version = "*", markers = "python_version < \"3.12\""}
+
+[package.extras]
+check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""]
+cover = ["pytest-cov"]
+doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
+enabler = ["pytest-enabler (>=3.4)"]
+test = ["jaraco.test (>=5.6.0)", "portend", "pytest (>=6,!=8.1.*)"]
+type = ["mypy (<1.19) ; platform_python_implementation == \"PyPy\"", "pytest-mypy (>=1.0.1)"]
+
 [[package]]
 name = "lief"
 version = "0.17.1"
@@ -1958,6 +1998,7 @@ optional = false
 python-versions = ">=3.7"
 groups = ["main"]
 files = [
+    {file = "rns-1.1.2-1-py3-none-any.whl", hash = "sha256:4354e75fcb64a5487fcc9fdadb40c082456a63318b95144f2fa2e802e9e8d633"},
    {file = "rns-1.1.2-py3-none-any.whl", hash = "sha256:8a153d97a02b4b326556b7f5926c37029767b70c9093b5f00c53c72105bc2091"},
    {file = "rns-1.1.2.tar.gz", hash = "sha256:ff2af56490c065adcc5f38aef07081b19bb355101406d10d768ec54f783a30c3"},
 ]
@@ -2265,4 +2306,4 @@ propcache = ">=0.2.1"
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.11"
-content-hash = "cf4375df2e3a86e2a1095e6446971d35421704c286f725ae9a3e22f7ead15241"
+content-hash = "220ebb5504918c35140a618bcf140757353dfc42b037c8145c93cb541b162955"
@@ -1,6 +1,6 @@
 [project]
 name = "reticulum-meshchatx"
-version = "4.0.0"
+version = "4.1.0"
 description = "A simple mesh network communications app powered by the Reticulum Network Stack"
 authors = [
  {name = "Sudo-Ivan"}
@@ -33,6 +33,7 @@ dependencies = [
  "audioop-lts>=0.2.2; python_version >= '3.13'",
  "ply>=3.11,<4.0",
  "lxst>=0.4.6",
+  "jaraco.context>=6.1.0",
 ]

 [project.scripts]
@@ -13,3 +13,4 @@ requests>=2.32.5
 hypothesis>=6.0.0
 ply>=3.11
 audioop-lts>=0.2.2
+jaraco.context>=6.1.0
@@ -44,9 +44,13 @@ function generateManifest(buildDir, manifestPath) {

 try {
    const platform = process.env.PLATFORM || process.platform;
+    const arch = process.env.ARCH || process.arch;
    const isWin = platform === "win32" || platform === "win";
    const targetName = isWin ? "ReticulumMeshChatX.exe" : "ReticulumMeshChatX";
-    const buildDirRelative = isWin ? "build/exe/win32" : "build/exe/linux";
+
+    // Create architecture-specific build directory
+    const platformFolder = isWin ? "win32" : "linux";
+    const buildDirRelative = `build/exe/${platformFolder}-${arch}`;
    const buildDir = path.join(__dirname, "..", buildDirRelative);

    // Allow overriding the python command (e.g., to use wine python for cross-builds)
@@ -1,8 +1,14 @@
 import asyncio
+import os
+import tempfile
 from unittest.mock import patch

 import pytest

+# Set log dir to a temporary directory for tests to avoid permission issues
+# in restricted environments like sandboxes.
+os.environ["MESHCHAT_LOG_DIR"] = tempfile.mkdtemp()
+

@pytest.fixture(autouse=True)
 def global_mocks():
@@ -94,8 +94,8 @@ async def test_app_status_endpoints(mock_rns_minimal, temp_dir):
        app_instance.config.set("tutorial_seen", True)
        assert app_instance.config.get("tutorial_seen") == "true"

-        app_instance.config.set("changelog_seen_version", "4.0.0")
-        assert app_instance.config.get("changelog_seen_version") == "4.0.0"
+        app_instance.config.set("changelog_seen_version", "4.1.0")
+        assert app_instance.config.get("changelog_seen_version") == "4.1.0"

        # Test app_info returns these values
        with ExitStack() as info_stack:
@@ -111,4 +111,4 @@ async def test_app_status_endpoints(mock_rns_minimal, temp_dir):
            assert val == "true"

            val = app_instance.config.get("changelog_seen_version")
-            assert val == "4.0.0"
+            assert val == "4.1.0"
@@ -1,6 +1,8 @@
 from unittest.mock import MagicMock, patch
+
 import pytest
 import RNS
+
 from meshchatx.src.backend.auto_propagation_manager import AutoPropagationManager


@@ -54,7 +56,7 @@ async def test_auto_propagation_logic():
        # Should have selected aaaa1111
        app.set_active_propagation_node.assert_called_with("aaaa1111", context=context)
        config.lxmf_preferred_propagation_node_destination_hash.set.assert_called_with(
-            "aaaa1111"
+            "aaaa1111",
        )

    # 3. Test switching to better node
@@ -3,8 +3,10 @@ import json
 import shutil
 import tempfile
 from unittest.mock import MagicMock, patch
+
 import pytest
 import RNS
+
 from meshchatx.meshchat import ReticulumMeshChat


@@ -78,7 +80,7 @@ async def test_auto_propagation_api(mock_rns_minimal, temp_dir):
    mock_request = MagicMock()
    mock_request.json = MagicMock(return_value=asyncio.Future())
    mock_request.json.return_value.set_result(
-        {"lxmf_preferred_propagation_node_auto_select": True}
+        {"lxmf_preferred_propagation_node_auto_select": True},
    )

    response = await patch_handler(mock_request)
@@ -90,7 +92,7 @@ async def test_auto_propagation_api(mock_rns_minimal, temp_dir):
    mock_request = MagicMock()
    mock_request.json = MagicMock(return_value=asyncio.Future())
    mock_request.json.return_value.set_result(
-        {"lxmf_preferred_propagation_node_auto_select": False}
+        {"lxmf_preferred_propagation_node_auto_select": False},
    )

    response = await patch_handler(mock_request)
@@ -10,20 +10,21 @@ from meshchatx.src.backend.rnstatus_handler import RNStatusHandler
 async def test_community_interfaces_manager_health_check():
    manager = CommunityInterfacesManager()

-    # Mock check_health to always return True for some, False for others
+    # Mock check_health to return True for first, False for second
    with patch.object(
        CommunityInterfacesManager,
        "check_health",
-        side_effect=[True, False, True, False, True, False, True],
+        side_effect=[True, False],
    ):
        interfaces = await manager.get_interfaces()

-        assert len(interfaces) == 7
+        assert len(interfaces) == 2
        # First one should be online because we sort by online status
        assert interfaces[0]["online"] is True
+        assert interfaces[1]["online"] is False
        # Check that we have both online and offline
        online_count = sum(1 for iface in interfaces if iface["online"])
-        assert online_count == 4
+        assert online_count == 1


@pytest.mark.asyncio
@@ -5,6 +5,7 @@ import sqlite3
 import sys
 import tempfile
 import unittest
+from unittest.mock import MagicMock, patch

 from meshchatx.src.backend.recovery.crash_recovery import CrashRecovery

@@ -119,8 +120,207 @@ class TestCrashRecovery(unittest.TestCase):
        self.assertIn("!!! APPLICATION CRASH DETECTED !!!", report)
        self.assertIn("Type:    ValueError", report)
        self.assertIn("Message: Simulated error for testing", report)
+        self.assertIn("Probabilistic Root Cause Analysis:", report)
        self.assertIn("Recovery Suggestions:", report)

+    def test_heuristic_analysis_sqlite(self):
+        exc_type = type("OperationalError", (Exception,), {})
+        exc_type.__name__ = "sqlite3.OperationalError"
+        exc_value = Exception("no such table: config")
+        diagnosis = {"db_type": "memory"}
+
+        causes = self.recovery._analyze_cause(exc_type, exc_value, diagnosis)
+        self.assertTrue(len(causes) > 0)
+        self.assertEqual(causes[0]["description"], "In-Memory Database Sync Failure")
+
+    def test_heuristic_analysis_asyncio(self):
+        exc_type = RuntimeError
+        exc_value = RuntimeError("no current event loop")
+        diagnosis = {}
+
+        causes = self.recovery._analyze_cause(exc_type, exc_value, diagnosis)
+        self.assertTrue(len(causes) > 0)
+        self.assertIn("Asynchronous Initialization", causes[0]["description"])
+
+    def test_heuristic_analysis_oom_priority(self):
+        """Verify that low memory increases OOM probability even with other errors."""
+        exc_type = sqlite3.OperationalError
+        exc_value = sqlite3.OperationalError("database is locked")
+        # Scenario: Low memory + DB error
+        diagnosis = {"low_memory": True, "available_mem_mb": 10}
+
+        causes = self.recovery._analyze_cause(exc_type, exc_value, diagnosis)
+        # OOM should be prioritized or at least highly probable (85% in code)
+        oom_cause = next((c for c in causes if "OOM" in c["description"]), None)
+        self.assertIsNotNone(oom_cause)
+        self.assertEqual(oom_cause["probability"], 85)
+
+    def test_heuristic_analysis_rns_missing(self):
+        """Verify high confidence for missing RNS config."""
+        exc_type = RuntimeError
+        exc_value = RuntimeError("Reticulum could not start")
+        diagnosis = {"config_missing": True}
+
+        causes = self.recovery._analyze_cause(exc_type, exc_value, diagnosis)
+        self.assertEqual(causes[0]["description"], "Missing Reticulum Configuration")
+        self.assertEqual(causes[0]["probability"], 99)
+        self.assertIn(
+            "deterministic manifold constraints",
+            causes[0]["reasoning"].lower(),
+        )
+
+    def test_entropy_calculation_levels(self):
+        """Test how entropy reflects system disorder."""
+        # Baseline stable state
+        stable_diag = {"low_memory": False, "config_missing": False}
+        stable_entropy, _ = self.recovery._calculate_system_entropy(stable_diag)
+
+        # Unstable state (one critical issue)
+        unstable_diag = {"low_memory": True, "config_missing": False}
+        unstable_entropy, _ = self.recovery._calculate_system_entropy(unstable_diag)
+
+        # Very unstable state (multiple critical issues)
+        very_unstable_diag = {"low_memory": True, "config_missing": True}
+        very_unstable_entropy, _ = self.recovery._calculate_system_entropy(
+            very_unstable_diag,
+        )
+
+        # Entropy should increase with more issues
+        self.assertGreater(unstable_entropy, stable_entropy)
+        self.assertGreater(very_unstable_entropy, unstable_entropy)
+
+        # Max entropy for 2 binary states is at p=0.5, but here we sum
+        # p_unstable = 0.1 + 0.4 + 0.4 = 0.9.
+        # p=0.9 has lower entropy than p=0.5, but higher than p=0.1.
+        # p_stable=0.9 (stable) vs p_stable=0.5 (medium) vs p_stable=0.1 (unstable)
+        # H(0.1) = 0.469, H(0.5) = 1.0, H(0.9) = 0.469
+        # The current implementation:
+        # stable: p_unstable=0.1 -> H=0.469
+        # unstable: p_unstable=0.5 -> H=1.0
+        # very unstable: p_unstable=0.9 -> H=0.469 (wait, mathematically yes, but logically?)
+        # Actually for a "disorder" metric, we might want it to peak when things are most uncertain.
+        # But in our context, we are showing entropy of the "State Predictability".
+
+    def test_confidence_grounding_text(self):
+        """Verify that reasoning text reflects grounding logic."""
+        # High confidence scenario
+        exc_type = RuntimeError
+        exc_value = RuntimeError("no current event loop")
+        diagnosis = {}  # probability 88% -> heuristic matching
+        causes_low = self.recovery._analyze_cause(exc_type, exc_value, diagnosis)
+        self.assertIn(
+            "probabilistic heuristic matching",
+            causes_low[0]["reasoning"].lower(),
+        )
+
+        # Near-certainty scenario
+        diagnosis_certain = {"config_missing": True}
+        causes_high = self.recovery._analyze_cause(
+            exc_type,
+            exc_value,
+            diagnosis_certain,
+        )
+        self.assertIn("high-confidence threshold", causes_high[0]["reasoning"].lower())
+
+    def test_heuristic_analysis_lxmf_storage(self):
+        """Test LXMF storage failure detection."""
+        exc_type = RuntimeError
+        exc_value = RuntimeError("LXMF could not open storage directory")
+        diagnosis = {}
+
+        causes = self.recovery._analyze_cause(exc_type, exc_value, diagnosis)
+        self.assertEqual(causes[0]["description"], "LXMF Router Storage Failure")
+        self.assertEqual(causes[0]["probability"], 90)
+
+    def test_heuristic_analysis_rns_identity(self):
+        """Test Reticulum identity failure detection."""
+        exc_type = Exception
+        exc_value = Exception("Reticulum Identity load failed: corrupt private key")
+        diagnosis = {}
+
+        causes = self.recovery._analyze_cause(exc_type, exc_value, diagnosis)
+        self.assertEqual(causes[0]["description"], "Reticulum Identity Load Failure")
+        self.assertEqual(causes[0]["probability"], 95)
+
+    def test_heuristic_analysis_interface_offline(self):
+        """Test interface offline detection."""
+        exc_type = RuntimeError
+        exc_value = RuntimeError("Reticulum startup failed")
+        diagnosis = {"active_interfaces": 0}
+
+        # We need to trigger the rns_in_msg symptom as well
+        exc_value = RuntimeError("Reticulum failed, no path available")
+        causes = self.recovery._analyze_cause(exc_type, exc_value, diagnosis)
+
+        offline_cause = next(
+            (c for c in causes if "Interface" in c["description"]),
+            None,
+        )
+        self.assertIsNotNone(offline_cause)
+        self.assertEqual(offline_cause["probability"], 85)
+
+    def test_advanced_math_output(self):
+        # We don't want to actually sys.exit(1) in tests, so we mock it
+        original_exit = sys.exit
+        sys.exit = MagicMock()
+
+        output = io.StringIO()
+        # Redirect stderr to our buffer
+        original_stderr = sys.stderr
+        sys.stderr = output
+
+        try:
+            try:
+                raise RuntimeError("no current event loop")
+            except RuntimeError:
+                self.recovery.handle_exception(*sys.exc_info())
+        finally:
+            sys.stderr = original_stderr
+            sys.exit = original_exit
+
+        report = output.getvalue()
+        self.assertIn("[System Entropy:", report)
+        self.assertIn("[Deterministic Manifold Constraints:", report)
+        self.assertIn("deterministic manifold constraints", report.lower())
+
+    def test_heuristic_analysis_unsupported_python(self):
+        """Test detection of unsupported Python versions."""
+        # We need to simulate the sys.version_info check
+        with patch("sys.version_info") as mock_version:
+            mock_version.major = 3
+            mock_version.minor = 9
+
+            exc_type = AttributeError
+            exc_value = AttributeError("'NoneType' object has no attribute 'x'")
+            diagnosis = {}
+
+            causes = self.recovery._analyze_cause(exc_type, exc_value, diagnosis)
+            self.assertEqual(causes[0]["description"], "Unsupported Python Environment")
+            self.assertEqual(causes[0]["probability"], 99)
+            self.assertIn(
+                "missing standard library features",
+                causes[0]["reasoning"].lower(),
+            )
+
+    def test_heuristic_analysis_legacy_kernel(self):
+        """Test detection of legacy system/kernel limitations."""
+        with (
+            patch("platform.system", return_value="Linux"),
+            patch("platform.release", return_value="3.10.0-1160.el7.x86_64"),
+        ):
+            exc_type = RuntimeError
+            exc_value = RuntimeError("kernel feature not available")
+            diagnosis = {}
+
+            causes = self.recovery._analyze_cause(exc_type, exc_value, diagnosis)
+            legacy_cause = next(
+                (c for c in causes if "Legacy System" in c["description"]),
+                None,
+            )
+            self.assertIsNotNone(legacy_cause)
+            self.assertGreaterEqual(legacy_cause["probability"], 80)
+            self.assertIn("Kernel detected: 3.10", legacy_cause["reasoning"])
+

 if __name__ == "__main__":
    unittest.main()
@@ -1,4 +1,4 @@
-from unittest.mock import MagicMock, patch, AsyncMock
+from unittest.mock import AsyncMock, MagicMock, patch

 import pytest
 import RNS
@@ -42,7 +42,7 @@ async def test_csp_header_logic(mock_rns_minimal, tmp_path):
        # Mock the config values
        app_instance.config.csp_extra_connect_src.set("https://api.example.com")
        app_instance.config.map_tile_server_url.set(
-            "https://tiles.example.com/{z}/{x}/{y}.png"
+            "https://tiles.example.com/{z}/{x}/{y}.png",
        )

        # Mock a request and handler
@@ -99,12 +99,16 @@ async def test_config_update_csp(mock_rns_minimal, tmp_path):

        # To avoid the JSON serialization error of MagicMock in get_config_dict,
        # we mock get_config_dict to return a serializable dict.
-        with patch.object(
-            app_instance, "get_config_dict", return_value={"status": "ok"}
+        with (
+            patch.object(
+                app_instance,
+                "get_config_dict",
+                return_value={"status": "ok"},
+            ),
+            patch.object(app_instance, "send_config_to_websocket_clients"),
        ):
-            with patch.object(app_instance, "send_config_to_websocket_clients"):
-                response = await config_update_handler(request)
-                assert response.status == 200
+            response = await config_update_handler(request)
+            assert response.status == 200

        assert (
            app_instance.config.csp_extra_connect_src.get()
@@ -1,14 +1,15 @@
 import base64
 from unittest.mock import MagicMock, patch
+
 import LXMF
+import RNS.vendor.umsgpack as msgpack
+
 from meshchatx.src.backend.meshchat_utils import parse_lxmf_display_name
 from meshchatx.src.backend.telemetry_utils import Telemeter
-import RNS.vendor.umsgpack as msgpack


 def test_parse_lxmf_display_name_bug_fix():
-    """
-    Test that parse_lxmf_display_name handles both bytes and strings
+    """Test that parse_lxmf_display_name handles both bytes and strings
    in the msgpack list, fixing the 'str' object has no attribute 'decode' bug.
    """
    # 1. Test with bytes (normal case)
@@ -34,9 +35,7 @@ def test_parse_lxmf_display_name_bug_fix():


 def test_lxmf_telemetry_decoding():
-    """
-    Test decoding of LXMF telemetry fields.
-    """
+    """Test decoding of LXMF telemetry fields."""
    # Create some dummy telemetry data
    ts = 1736264575
    lat, lon = 52.5200, 13.4050
@@ -68,9 +67,7 @@ def test_lxmf_telemetry_decoding():


 def test_lxmf_telemetry_mapping_in_app():
-    """
-    Test how the app handles telemetry fields from an LXMF message.
-    """
+    """Test how the app handles telemetry fields from an LXMF message."""
    # Mock lxmf_message
    lxmf_message = MagicMock(spec=LXMF.LXMessage)
    source_hash = b"\x01" * 32
@@ -79,7 +76,8 @@ def test_lxmf_telemetry_mapping_in_app():

    ts = 1736264575
    packed_telemetry = Telemeter.pack(
-        time_utc=ts, location={"latitude": 1.23, "longitude": 4.56}
+        time_utc=ts,
+        location={"latitude": 1.23, "longitude": 4.56},
    )

    lxmf_message.get_fields.return_value = {LXMF.FIELD_TELEMETRY: packed_telemetry}
@@ -141,9 +141,11 @@ def create_mock_zip(zip_path, file_list):
 )
@given(
    root_folder_name=st.text(min_size=1, max_size=50).filter(
-        lambda x: "/" not in x and x not in [".", ".."],
+        lambda x: "/" not in x and "\x00" not in x and x not in [".", ".."],
+    ),
+    docs_file=st.text(min_size=1, max_size=50).filter(
+        lambda x: "/" not in x and "\x00" not in x,
    ),
-    docs_file=st.text(min_size=1, max_size=50).filter(lambda x: "/" not in x),
 )
 def test_extract_docs_fuzzing(docs_manager, temp_dirs, root_folder_name, docs_file):
    public_dir, docs_dir = temp_dirs
@@ -1,12 +1,14 @@
 import os
 import shutil
 import tempfile
+import threading
 from unittest.mock import MagicMock, patch

 import pytest
 import RNS

 from meshchatx.meshchat import ReticulumMeshChat
+from meshchatx.src.backend.database.provider import DatabaseProvider


@pytest.fixture
@@ -221,3 +223,45 @@ def test_normal_mode_startup_logic(mock_rns, temp_dir):

        # Verify IntegrityManager.save_manifest WAS called
        assert mock_integrity_instance.save_manifest.call_count == 1
+
+
+def test_emergency_mode_memory_concurrency(mock_rns, temp_dir):
+    """Verify that :memory: database connection is shared across threads."""
+    # Reset singleton
+    DatabaseProvider._instance = None
+
+    with (
+        patch(
+            "meshchatx.src.backend.identity_context.IdentityContext.start_background_threads",
+        ),
+        patch("meshchatx.src.backend.identity_context.create_lxmf_router"),
+        patch("meshchatx.meshchat.WebAudioBridge"),
+        patch("meshchatx.meshchat.memory_log_handler"),
+    ):
+        app = ReticulumMeshChat(
+            identity=mock_rns["id_instance"],
+            storage_dir=temp_dir,
+            reticulum_config_dir=temp_dir,
+            emergency=True,
+        )
+
+        ctx = app.current_context
+        provider = ctx.database.provider
+        assert provider.db_path == ":memory:"
+
+        # Set value in main thread
+        test_name = "Emergency Worker"
+        ctx.config.display_name.set(test_name)
+
+        # Simulate another thread by swapping thread-local storage
+        original_local = provider._local
+        provider._local = threading.local()
+
+        try:
+            # Should still return the SAME connection object because of the fix
+            val = ctx.config.display_name.get()
+            assert val == test_name
+        finally:
+            provider._local = original_local
+
+    DatabaseProvider._instance = None
@@ -106,8 +106,9 @@ def test_display_name_parsing_fuzzing(app_data_base64):
@settings(suppress_health_check=[HealthCheck.function_scoped_fixture], deadline=None)
@given(
    fields_data=st.dictionaries(
-        st.integers(min_value=0, max_value=255), st.binary(min_size=0, max_size=1000)
-    )
+        st.integers(min_value=0, max_value=255),
+        st.binary(min_size=0, max_size=1000),
+    ),
 )
 def test_lxmf_fields_parsing_fuzzing(fields_data):
    """Fuzz the parsing of LXMF message fields."""
@@ -1,4 +1,6 @@
-from hypothesis import given, settings, strategies as st
+from hypothesis import given, settings
+from hypothesis import strategies as st
+
 from meshchatx.src.backend.telemetry_utils import Telemeter

 # Strategies for telemetry data
@@ -75,7 +77,7 @@ def test_fuzz_from_packed_random_bytes(data):
            values=st.one_of(st.integers(), st.text(), st.floats(), st.booleans()),
        ),
        max_size=10,
-    )
+    ),
 )
 def test_fuzz_command_parsing(commands):
    # This simulates how commands are handled in meshchat.py
@@ -1,9 +1,10 @@
+import base64
 import os
 import shutil
 import tempfile
-import base64
 import unittest
 from unittest.mock import MagicMock, patch
+
 from meshchatx.src.backend.identity_manager import IdentityManager


@@ -19,7 +20,10 @@ class TestIdentityRestore(unittest.TestCase):
    @patch("meshchatx.src.backend.identity_manager.DatabaseProvider")
    @patch("meshchatx.src.backend.identity_manager.DatabaseSchema")
    def test_restore_identity_from_bytes(
-        self, mock_schema, mock_provider, mock_rns_identity
+        self,
+        mock_schema,
+        mock_provider,
+        mock_rns_identity,
    ):
        # Setup mock identity
        mock_id_instance = MagicMock()
@@ -48,7 +52,10 @@ class TestIdentityRestore(unittest.TestCase):
    @patch("meshchatx.src.backend.identity_manager.DatabaseProvider")
    @patch("meshchatx.src.backend.identity_manager.DatabaseSchema")
    def test_restore_identity_from_base32(
-        self, mock_schema, mock_provider, mock_rns_identity
+        self,
+        mock_schema,
+        mock_provider,
+        mock_rns_identity,
    ):
        # Setup mock identity
        mock_id_instance = MagicMock()
@@ -76,7 +76,9 @@ def mock_rns():
        )
        stack.enter_context(
            patch.object(
-                MockIdentityClass, "from_bytes", return_value=mock_id_instance
+                MockIdentityClass,
+                "from_bytes",
+                return_value=mock_id_instance,
            ),
        )

@@ -0,0 +1,188 @@
+import gc
+import os
+import shutil
+import sqlite3
+import tempfile
+from unittest.mock import MagicMock, patch
+
+import pytest
+import RNS
+from hypothesis import given, settings
+from hypothesis import strategies as st
+
+from meshchatx.src.backend.database.provider import DatabaseProvider
+from meshchatx.src.backend.identity_context import IdentityContext
+from meshchatx.src.backend.web_audio_bridge import WebAudioBridge
+
+
+def test_database_provider_disposal():
+    """Test that DatabaseProvider correctly closes connections."""
+    db_path = os.path.join(tempfile.gettempdir(), "test_disposal.db")
+    if os.path.exists(db_path):
+        os.remove(db_path)
+
+    # Ensure any existing singleton is cleared
+    DatabaseProvider._instance = None
+
+    try:
+        provider = DatabaseProvider.get_instance(db_path)
+        conn = provider.connection
+        assert isinstance(conn, sqlite3.Connection)
+
+        # Test close()
+        provider.close()
+        with pytest.raises(sqlite3.ProgrammingError, match="closed database"):
+            conn.execute("SELECT 1")
+
+        # Re-open
+        conn2 = provider.connection
+        assert conn2 is not conn
+
+        # Test close_all()
+        provider.close_all()
+        with pytest.raises(sqlite3.ProgrammingError, match="closed database"):
+            conn2.execute("SELECT 1")
+
+    finally:
+        if os.path.exists(db_path):
+            try:
+                os.remove(db_path)
+            except Exception:
+                pass
+        DatabaseProvider._instance = None
+
+
+def test_web_audio_bridge_disposal():
+    """Test that WebAudioBridge correctly manages clients and cleanup."""
+    mock_tele_mgr = MagicMock()
+    mock_config_mgr = MagicMock()
+    bridge = WebAudioBridge(mock_tele_mgr, mock_config_mgr)
+
+    mock_client = MagicMock()
+    mock_tele = MagicMock()
+    mock_tele.active_call = True
+    mock_tele_mgr.telephone = mock_tele
+
+    with (
+        patch("meshchatx.src.backend.web_audio_bridge.WebAudioSource"),
+        patch("meshchatx.src.backend.web_audio_bridge.WebAudioSink"),
+        patch("meshchatx.src.backend.web_audio_bridge.Tee"),
+        patch("meshchatx.src.backend.web_audio_bridge.Pipeline"),
+    ):
+        bridge.attach_client(mock_client)
+        assert mock_client in bridge.clients
+
+        bridge.on_call_ended()
+        assert bridge.tx_source is None
+        assert bridge.rx_sink is None
+        assert len(bridge.clients) == 0
+
+
+def test_identity_context_teardown_completeness():
+    """Verify that teardown cleans up all major components."""
+    mock_identity = MagicMock(spec=RNS.Identity)
+    mock_identity.hash = b"test_hash_32_bytes_long_01234567"
+    mock_identity.get_private_key.return_value = b"mock_pk"
+
+    mock_app = MagicMock()
+    mock_app.storage_dir = tempfile.mkdtemp()
+
+    with (
+        patch("meshchatx.src.backend.identity_context.Database"),
+        patch("meshchatx.src.backend.identity_context.ConfigManager"),
+        patch("meshchatx.src.backend.identity_context.create_lxmf_router"),
+        patch("meshchatx.src.backend.identity_context.IntegrityManager"),
+        patch(
+            "meshchatx.src.backend.identity_context.AutoPropagationManager",
+        ),
+    ):
+        context = IdentityContext(mock_identity, mock_app)
+        context.start_background_threads = MagicMock()
+        context.register_announce_handlers = MagicMock()
+
+        context.setup()
+
+        # Capture instances
+        db_instance = context.database
+        auto_prop_instance = context.auto_propagation_manager
+
+        context.teardown()
+
+        # Verify component cleanup
+        db_instance._checkpoint_and_close.assert_called()
+        auto_prop_instance.stop.assert_called()
+        assert context.running is False
+
+
+def test_identity_context_memory_leak():
+    """Verify that IdentityContext can be garbage collected after teardown."""
+    mock_identity = MagicMock(spec=RNS.Identity)
+    mock_identity.hash = b"leak_test_hash_32_bytes_long_012"
+    mock_identity.get_private_key.return_value = b"mock_pk"
+    mock_app = MagicMock()
+    mock_app.storage_dir = tempfile.mkdtemp()
+
+    import weakref
+
+    # We use a list to store the ref so we can access it after the function scope
+    leak_ref = []
+
+    def run_lifecycle():
+        with (
+            patch("meshchatx.src.backend.identity_context.Database"),
+            patch("meshchatx.src.backend.identity_context.ConfigManager"),
+            patch("meshchatx.src.backend.identity_context.create_lxmf_router"),
+            patch("meshchatx.src.backend.identity_context.IntegrityManager"),
+            patch("RNS.Transport"),
+        ):
+            context = IdentityContext(mock_identity, mock_app)
+            context.start_background_threads = MagicMock()
+            context.register_announce_handlers = MagicMock()
+            context.setup()
+            context.teardown()
+
+            leak_ref.append(weakref.ref(context))
+            # End of with block and function scope should clear 'context'
+
+    run_lifecycle()
+
+    # Break any potential cycles in the app mock which might have captured the context
+    mock_app.reset_mock()
+
+    # Multiple collection rounds
+    for _ in range(5):
+        gc.collect()
+
+    # Check if it was collected
+    assert leak_ref[0]() is None, "IdentityContext was not garbage collected"
+
+
+@settings(deadline=None)
+@given(st.integers(min_value=1, max_value=3))
+def test_identity_context_repeated_lifecycle(n):
+    """Fuzz the lifecycle by repeating setup/teardown multiple times with new instances."""
+    mock_identity = MagicMock(spec=RNS.Identity)
+    mock_identity.hash = b"fuzz_hash_32_bytes_long_01234567"
+    mock_identity.get_private_key.return_value = b"mock_pk"
+
+    mock_app = MagicMock()
+    mock_app.storage_dir = tempfile.mkdtemp()
+
+    with (
+        patch("meshchatx.src.backend.identity_context.Database"),
+        patch("meshchatx.src.backend.identity_context.ConfigManager"),
+        patch("meshchatx.src.backend.identity_context.create_lxmf_router"),
+        patch("meshchatx.src.backend.identity_context.IntegrityManager"),
+        patch("RNS.Transport"),
+    ):
+        for _ in range(n):
+            context = IdentityContext(mock_identity, mock_app)
+            context.start_background_threads = MagicMock()
+            context.register_announce_handlers = MagicMock()
+            context.setup()
+            assert context.running is True
+            context.teardown()
+            assert context.running is False
+
+    if os.path.exists(mock_app.storage_dir):
+        shutil.rmtree(mock_app.storage_dir)
@@ -92,7 +92,9 @@ def mock_rns():
        )
        stack.enter_context(
            patch.object(
-                MockIdentityClass, "from_bytes", return_value=mock_id_instance
+                MockIdentityClass,
+                "from_bytes",
+                return_value=mock_id_instance,
            ),
        )

@@ -1,7 +1,8 @@
 import unittest
 from unittest.mock import MagicMock
-from meshchatx.src.backend.database.messages import MessageDAO
+
 from meshchatx.src.backend.database.announces import AnnounceDAO
+from meshchatx.src.backend.database.messages import MessageDAO
 from meshchatx.src.backend.database.misc import MiscDAO


@@ -27,7 +28,8 @@ class TestMaintenance(unittest.TestCase):
        # Test with aspect
        self.announces_dao.delete_all_announces(aspect="test_aspect")
        self.provider.execute.assert_called_with(
-            "DELETE FROM announces WHERE aspect = ?", ("test_aspect",)
+            "DELETE FROM announces WHERE aspect = ?",
+            ("test_aspect",),
        )

    def test_delete_all_favourites(self):
@@ -38,7 +40,8 @@ class TestMaintenance(unittest.TestCase):
        # Test with aspect
        self.announces_dao.delete_all_favourites(aspect="test_aspect")
        self.provider.execute.assert_called_with(
-            "DELETE FROM favourite_destinations WHERE aspect = ?", ("test_aspect",)
+            "DELETE FROM favourite_destinations WHERE aspect = ?",
+            ("test_aspect",),
        )

    def test_delete_archived_pages(self):
@@ -0,0 +1,512 @@
+import html
+import json
+import math
+import os
+import shutil
+
+import pytest
+from hypothesis import HealthCheck, given, settings
+from hypothesis import strategies as st
+
+from meshchatx.src.backend.colour_utils import ColourUtils
+from meshchatx.src.backend.identity_manager import IdentityManager
+from meshchatx.src.backend.interface_config_parser import InterfaceConfigParser
+from meshchatx.src.backend.lxmf_utils import convert_db_lxmf_message_to_dict
+from meshchatx.src.backend.markdown_renderer import MarkdownRenderer
+from meshchatx.src.backend.meshchat_utils import (
+    parse_bool_query_param,
+    parse_lxmf_display_name,
+    parse_lxmf_propagation_node_app_data,
+    parse_lxmf_stamp_cost,
+    parse_nomadnetwork_node_display_name,
+)
+from meshchatx.src.backend.nomadnet_utils import (
+    convert_nomadnet_field_data_to_map,
+    convert_nomadnet_string_data_to_map,
+)
+from meshchatx.src.backend.recovery.crash_recovery import CrashRecovery
+from meshchatx.src.backend.telemetry_utils import Telemeter
+
+# Strategies for telemetry data
+st_latitude = st.floats(
+    min_value=-90,
+    max_value=90,
+    allow_nan=False,
+    allow_infinity=False,
+)
+st_longitude = st.floats(
+    min_value=-180,
+    max_value=180,
+    allow_nan=False,
+    allow_infinity=False,
+)
+st_altitude = st.floats(
+    min_value=-10000,
+    max_value=100000,
+    allow_nan=False,
+    allow_infinity=False,
+)
+st_speed = st.floats(min_value=0, max_value=1000, allow_nan=False, allow_infinity=False)
+st_bearing = st.floats(
+    min_value=-360,
+    max_value=360,
+    allow_nan=False,
+    allow_infinity=False,
+)
+st_accuracy = st.floats(
+    min_value=0,
+    max_value=655.35,
+    allow_nan=False,
+    allow_infinity=False,
+)
+st_timestamp = st.integers(min_value=0, max_value=2**32 - 1)
+
+
+@given(
+    lat=st_latitude,
+    lon=st_longitude,
+    alt=st_altitude,
+    speed=st_speed,
+    bear=st_bearing,
+    acc=st_accuracy,
+    ts=st_timestamp,
+)
+def test_telemeter_location_roundtrip(lat, lon, alt, speed, bear, acc, ts):
+    packed = Telemeter.pack_location(lat, lon, alt, speed, bear, acc, ts)
+    assert packed is not None
+    unpacked = Telemeter.unpack_location(packed)
+    assert unpacked is not None
+
+    # Check with tolerance due to rounding/fixed point conversion in packing
+    assert math.isclose(unpacked["latitude"], lat, abs_tol=1e-6)
+    assert math.isclose(unpacked["longitude"], lon, abs_tol=1e-6)
+    assert math.isclose(unpacked["altitude"], alt, abs_tol=1e-2)
+    assert math.isclose(unpacked["speed"], speed, abs_tol=1e-2)
+    # Bearing can be negative in input but unpacked should match
+    assert math.isclose(unpacked["bearing"], bear, abs_tol=1e-2)
+    assert math.isclose(unpacked["accuracy"], acc, abs_tol=1e-2)
+    assert unpacked["last_update"] == ts
+
+
+@given(
+    time_utc=st_timestamp,
+    lat=st_latitude,
+    lon=st_longitude,
+    charge=st.integers(min_value=0, max_value=100),
+    charging=st.booleans(),
+    rssi=st.integers(min_value=-150, max_value=0),
+    snr=st.integers(min_value=-20, max_value=20),
+    q=st.integers(min_value=0, max_value=100),
+)
+def test_telemeter_full_pack_roundtrip(
+    time_utc,
+    lat,
+    lon,
+    charge,
+    charging,
+    rssi,
+    snr,
+    q,
+):
+    location = {"latitude": lat, "longitude": lon}
+    battery = {"charge_percent": charge, "charging": charging}
+    physical_link = {"rssi": rssi, "snr": snr, "q": q}
+
+    packed = Telemeter.pack(
+        time_utc=time_utc,
+        location=location,
+        battery=battery,
+        physical_link=physical_link,
+    )
+
+    unpacked = Telemeter.from_packed(packed)
+    assert unpacked is not None
+    assert unpacked["time"]["utc"] == time_utc
+    assert math.isclose(unpacked["location"]["latitude"], lat, abs_tol=1e-6)
+    assert math.isclose(unpacked["location"]["longitude"], lon, abs_tol=1e-6)
+    assert unpacked["battery"]["charge_percent"] == charge
+    assert unpacked["battery"]["charging"] == charging
+    assert unpacked["physical_link"]["rssi"] == rssi
+    assert unpacked["physical_link"]["snr"] == snr
+    assert unpacked["physical_link"]["q"] == q
+
+
+@given(hex_val=st.from_regex(r"^#?[0-9a-fA-F]{6}$"))
+def test_colour_utils_hex_to_byte_array(hex_val):
+    result = ColourUtils.hex_colour_to_byte_array(hex_val)
+    assert len(result) == 3
+
+    # Verify manual conversion matches
+    clean_hex = hex_val.lstrip("#")
+    expected = bytes.fromhex(clean_hex)
+    assert result == expected
+
+
+@given(
+    val=st.one_of(
+        st.sampled_from(
+            ["1", "true", "yes", "on", "0", "false", "no", "off", "random"],
+        ),
+        st.none(),
+    ),
+)
+def test_parse_bool_query_param(val):
+    result = parse_bool_query_param(val)
+    if val is None:
+        assert result is False
+    elif val.lower() in {"1", "true", "yes", "on"}:
+        assert result is True
+    else:
+        assert result is False
+
+
+@given(data=st.binary())
+def test_parse_lxmf_display_name_robustness(data):
+    # This should never crash
+    try:
+        parse_lxmf_display_name(data)
+    except Exception as e:
+        pytest.fail(f"parse_lxmf_display_name crashed: {e}")
+
+
+@given(data=st.binary())
+def test_parse_lxmf_propagation_node_app_data_robustness(data):
+    # This should never crash
+    try:
+        parse_lxmf_propagation_node_app_data(data)
+    except Exception as e:
+        pytest.fail(f"parse_lxmf_propagation_node_app_data crashed: {e}")
+
+
+@given(data=st.binary())
+def test_parse_lxmf_stamp_cost_robustness(data):
+    # This should never crash
+    try:
+        parse_lxmf_stamp_cost(data)
+    except Exception as e:
+        pytest.fail(f"parse_lxmf_stamp_cost crashed: {e}")
+
+
+@given(name=st.text())
+def test_parse_nomadnetwork_node_display_name_robustness(name):
+    # This should never crash
+    try:
+        parse_nomadnetwork_node_display_name(name)
+    except Exception as e:
+        pytest.fail(f"parse_nomadnetwork_node_display_name crashed: {e}")
+
+
+@given(packed=st.binary())
+def test_telemeter_from_packed_robustness(packed):
+    # This should never crash
+    try:
+        Telemeter.from_packed(packed)
+    except Exception as e:
+        pytest.fail(f"Telemeter.from_packed crashed: {e}")
+
+
+@given(text=st.text())
+def test_markdown_renderer_no_crash(text):
+    try:
+        MarkdownRenderer.render(text)
+    except Exception as e:
+        pytest.fail(f"MarkdownRenderer.render crashed: {e}")
+
+
+@given(text=st.text())
+def test_interface_config_parser_no_crash(text):
+    try:
+        InterfaceConfigParser.parse(text)
+    except Exception as e:
+        pytest.fail(f"InterfaceConfigParser.parse crashed: {e}")
+
+
+# Strategy for a database message row
+st_db_message = st.dictionaries(
+    keys=st.sampled_from(
+        [
+            "id",
+            "hash",
+            "source_hash",
+            "destination_hash",
+            "is_incoming",
+            "state",
+            "progress",
+            "method",
+            "delivery_attempts",
+            "next_delivery_attempt_at",
+            "title",
+            "content",
+            "fields",
+            "timestamp",
+            "rssi",
+            "snr",
+            "quality",
+            "is_spam",
+            "created_at",
+            "updated_at",
+        ],
+    ),
+    values=st.one_of(
+        st.none(),
+        st.integers(),
+        st.floats(allow_nan=False, allow_infinity=False),
+        st.text(),
+        st.booleans(),
+        st.binary().map(lambda b: b.hex()),
+    ),
+).filter(lambda d: "created_at" in d and "updated_at" in d)
+
+
+@settings(suppress_health_check=[HealthCheck.too_slow])
+@given(db_message=st_db_message)
+def test_convert_db_lxmf_message_to_dict_robustness(db_message):
+    # Fill in missing required keys for the function
+    required_keys = [
+        "id",
+        "hash",
+        "source_hash",
+        "destination_hash",
+        "is_incoming",
+        "state",
+        "progress",
+        "method",
+        "delivery_attempts",
+        "next_delivery_attempt_at",
+        "title",
+        "content",
+        "fields",
+        "timestamp",
+        "rssi",
+        "snr",
+        "quality",
+        "is_spam",
+        "created_at",
+        "updated_at",
+    ]
+    for key in required_keys:
+        if key not in db_message:
+            db_message[key] = None
+
+    # Ensure fields is a valid JSON string if it's not None
+    if db_message["fields"] is not None:
+        try:
+            json.loads(db_message["fields"])
+        except (ValueError, TypeError, json.JSONDecodeError):
+            db_message["fields"] = "{}"
+
+    try:
+        convert_db_lxmf_message_to_dict(db_message)
+    except Exception:
+        # We expect some errors if data is really weird, but it shouldn't crash the whole thing
+        pass
+
+
+@given(data=st.dictionaries(keys=st.text(), values=st.text()))
+def test_convert_nomadnet_field_data_to_map(data):
+    result = convert_nomadnet_field_data_to_map(data)
+    assert len(result) == len(data)
+    for k, v in data.items():
+        assert result[f"field_{k}"] == v
+
+
+@given(
+    data=st.dictionaries(
+        keys=st.text().filter(lambda x: "=" not in x and "|" not in x and x),
+        values=st.text().filter(lambda x: "|" not in x),
+    ),
+)
+def test_convert_nomadnet_string_data_to_map_roundtrip(data):
+    # Construct string like key1=val1|key2=val2
+    input_str = "|".join([f"{k}={v}" for k, v in data.items()])
+    result = convert_nomadnet_string_data_to_map(input_str)
+    assert len(result) == len(data)
+    for k, v in data.items():
+        assert result[f"var_{k}"] == v
+
+
+@given(text=st.text())
+def test_markdown_renderer_xss_protection(text):
+    # Basic check: if we use <script>, it should be escaped
+    input_text = f"<script>alert(1)</script>{text}"
+    result = MarkdownRenderer.render(input_text)
+    assert "<script>" not in result
+    assert "&lt;script&gt;" in result
+
+
+@given(content=st.text().filter(lambda x: x and "\n" not in x and "#" not in x))
+def test_markdown_renderer_headers(content):
+    input_text = f"# {content}"
+    result = MarkdownRenderer.render(input_text)
+    assert "<h1" in result
+    # Check that it's correctly wrapped in h1
+    assert result.startswith("<h1")
+    assert result.endswith("</h1>")
+
+    # If the content doesn't contain markdown special chars, we can expect it to be there escaped
+    # This is a safer assertion for property-based testing
+    if not any(c in content for c in "*_~`[]()"):
+        assert html.escape(content) in result
+
+
+@given(data=st.binary())
+def test_identity_restore_robustness(data):
+    manager = IdentityManager("/tmp/test_identities")
+    try:
+        # Should either return a dict or raise ValueError, but not crash
+        manager.restore_identity_from_bytes(data)
+    except ValueError:
+        pass
+    except Exception as e:
+        pytest.fail(f"restore_identity_from_bytes crashed with: {e}")
+    finally:
+        if os.path.exists("/tmp/test_identities"):
+            shutil.rmtree("/tmp/test_identities")
+
+
+@given(data=st.text())
+def test_identity_restore_base32_robustness(data):
+    manager = IdentityManager("/tmp/test_identities_b32")
+    try:
+        manager.restore_identity_from_base32(data)
+    except ValueError:
+        pass
+    except Exception as e:
+        pytest.fail(f"restore_identity_from_base32 crashed with: {e}")
+    finally:
+        if os.path.exists("/tmp/test_identities_b32"):
+            shutil.rmtree("/tmp/test_identities_b32")
+
+
+@given(
+    st.lists(
+        st.text(min_size=1).filter(
+            lambda x: "\n" not in x and x.strip() and x.isalnum(),
+        ),
+    ),
+)
+def test_markdown_renderer_list_rendering(items):
+    if not items:
+        return
+    markdown = "\n".join([f"* {item}" for item in items])
+    html_output = MarkdownRenderer.render(markdown)
+    assert "<ul" in html_output
+    for item in items:
+        assert item in html_output
+
+
+@given(
+    st.text(min_size=1).filter(lambda x: x.isalnum()),
+    st.text(min_size=1).filter(lambda x: x.isalnum()),
+)
+def test_markdown_renderer_link_rendering(label, url):
+    markdown = f"[{label}]({url})"
+    html_output = MarkdownRenderer.render(markdown)
+    assert "<a href=" in html_output
+    assert label in html_output
+
+
+@given(
+    exc_msg=st.text(),
+    exc_type_name=st.text(min_size=1).filter(lambda x: x.isidentifier()),
+    diagnosis=st.dictionaries(
+        keys=st.sampled_from(
+            [
+                "low_memory",
+                "config_missing",
+                "config_invalid",
+                "db_type",
+                "active_interfaces",
+                "available_mem_mb",
+            ],
+        ),
+        values=st.one_of(
+            st.booleans(),
+            st.text(),
+            st.integers(min_value=0, max_value=100000),
+        ),
+    ),
+)
+def test_crash_recovery_analyze_cause_robustness(exc_msg, exc_type_name, diagnosis):
+    recovery = CrashRecovery()
+    # Mocking exc_type
+    mock_exc_type = type(exc_type_name, (Exception,), {})
+    mock_exc_value = Exception(exc_msg)
+
+    try:
+        causes = recovery._analyze_cause(mock_exc_type, mock_exc_value, diagnosis)
+        assert isinstance(causes, list)
+        for cause in causes:
+            assert "probability" in cause
+            assert "description" in cause
+            assert "reasoning" in cause
+            assert 0 <= cause["probability"] <= 100
+    except Exception as e:
+        pytest.fail(f"CrashRecovery._analyze_cause crashed: {e}")
+
+
+@given(
+    diagnosis=st.dictionaries(
+        keys=st.sampled_from(
+            [
+                "low_memory",
+                "config_missing",
+                "config_invalid",
+                "db_type",
+                "available_mem_mb",
+            ],
+        ),
+        values=st.one_of(
+            st.booleans(),
+            st.text(),
+            st.integers(min_value=0, max_value=100000),
+            st.none(),
+        ),
+    ),
+)
+def test_crash_recovery_entropy_logic(diagnosis):
+    recovery = CrashRecovery()
+    entropy, divergence = recovery._calculate_system_entropy(diagnosis)
+
+    assert isinstance(entropy, float)
+    assert isinstance(divergence, float)
+    # Entropy should be non-negative. Max theoretical for 4 independent binary
+    # variables is 4.0 bits. Our p values are constrained between 0.01 and 0.99.
+    assert 0.0 <= entropy <= 4.1
+    assert divergence >= 0.0
+
+    # Check that more uncertainty increases entropy (within one dimension)
+    diag_stable = {"low_memory": False}
+    diag_unstable = {"low_memory": True}
+    e_stable, _ = recovery._calculate_system_entropy(diag_stable)
+    e_unstable, _ = recovery._calculate_system_entropy(diag_unstable)
+    assert e_unstable > e_stable
+
+
+@given(
+    exc_msg=st.text(),
+    diagnosis=st.dictionaries(
+        keys=st.sampled_from(
+            [
+                "low_memory",
+                "config_missing",
+                "config_invalid",
+                "db_type",
+                "active_interfaces",
+            ],
+        ),
+        values=st.one_of(
+            st.booleans(),
+            st.text(),
+            st.integers(min_value=0, max_value=100),
+        ),
+    ),
+)
+def test_crash_recovery_probability_sorting(exc_msg, diagnosis):
+    recovery = CrashRecovery()
+    # Use a real exception type that often triggers results
+    causes = recovery._analyze_cause(RuntimeError, RuntimeError(exc_msg), diagnosis)
+
+    if len(causes) > 1:
+        probs = [c["probability"] for c in causes]
+        assert probs == sorted(probs, reverse=True)
@@ -0,0 +1,87 @@
+import os
+import shutil
+import tempfile
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from meshchatx.meshchat import ReticulumMeshChat
+
+
+@pytest.fixture
+def temp_dir():
+    dir_path = tempfile.mkdtemp()
+    yield dir_path
+    shutil.rmtree(dir_path)
+
+
+@pytest.fixture
+def mock_rns():
+    with (
+        patch("RNS.Reticulum") as mock_reticulum,
+        patch("RNS.Transport"),
+        patch("RNS.Identity") as mock_identity,
+    ):
+        mock_id_instance = MagicMock()
+        mock_id_instance.hash = b"test_hash_32_bytes_long_01234567"
+        mock_id_instance.get_private_key.return_value = b"test_key"
+        mock_identity.return_value = mock_id_instance
+
+        yield {"Reticulum": mock_reticulum, "id_instance": mock_id_instance}
+
+
+def test_rns_config_auto_creation(mock_rns, temp_dir):
+    """Test that Reticulum config is created if it does not exist."""
+    config_dir = os.path.join(temp_dir, ".reticulum")
+    config_file = os.path.join(config_dir, "config")
+
+    # Ensure it doesn't exist
+    assert not os.path.exists(config_file)
+
+    with (
+        patch("meshchatx.meshchat.IdentityContext"),
+        patch("meshchatx.meshchat.WebAudioBridge"),
+        patch("meshchatx.meshchat.memory_log_handler"),
+    ):
+        ReticulumMeshChat(
+            identity=mock_rns["id_instance"],
+            storage_dir=temp_dir,
+            reticulum_config_dir=config_dir,
+        )
+
+        # Method should have been called during init -> setup_identity
+        assert os.path.exists(config_file)
+
+        with open(config_file) as f:
+            content = f.read()
+            assert "[reticulum]" in content
+            assert "[interfaces]" in content
+            assert "enable_transport = False" in content
+
+
+def test_rns_config_repair_if_invalid(mock_rns, temp_dir):
+    """Test that Reticulum config is recreated if it is invalid/corrupt."""
+    config_dir = os.path.join(temp_dir, ".reticulum")
+    os.makedirs(config_dir, exist_ok=True)
+    config_file = os.path.join(config_dir, "config")
+
+    # Create a "corrupt" config
+    with open(config_file, "w") as f:
+        f.write("this is not a valid rns config")
+
+    with (
+        patch("meshchatx.meshchat.IdentityContext"),
+        patch("meshchatx.meshchat.WebAudioBridge"),
+        patch("meshchatx.meshchat.memory_log_handler"),
+    ):
+        ReticulumMeshChat(
+            identity=mock_rns["id_instance"],
+            storage_dir=temp_dir,
+            reticulum_config_dir=config_dir,
+        )
+
+        with open(config_file) as f:
+            content = f.read()
+            # Should have been repaired
+            assert "[reticulum]" in content
+            assert "[interfaces]" in content
@@ -1,4 +1,5 @@
 import time
+
 from meshchatx.src.backend.telemetry_utils import Telemeter


@@ -1,6 +1,8 @@
-import pytest
 import time
 from unittest.mock import MagicMock
+
+import pytest
+
 from meshchatx.meshchat import ReticulumMeshChat
 from meshchatx.src.backend.telemetry_utils import Telemeter

@@ -49,7 +51,9 @@ async def test_process_incoming_telemetry_single(mock_app):
    mock_lxmf_message.hash = b"msg_hash"

    mock_app.process_incoming_telemetry(
-        source_hash, packed_telemetry, mock_lxmf_message
+        source_hash,
+        packed_telemetry,
+        mock_lxmf_message,
    )

    # Verify database call
@@ -108,14 +112,15 @@ async def test_telemetry_request_parsing(mock_app):

    # Bind on_lxmf_delivery
    mock_app.on_lxmf_delivery = ReticulumMeshChat.on_lxmf_delivery.__get__(
-        mock_app, ReticulumMeshChat
+        mock_app,
+        ReticulumMeshChat,
    )

    # Mocking dependencies
    mock_app.is_destination_blocked.return_value = False
    mock_app.current_context.config.telemetry_enabled.get.return_value = True
    mock_app.database.contacts.get_contact_by_identity_hash.return_value = {
-        "is_telemetry_trusted": True
+        "is_telemetry_trusted": True,
    }
    mock_app.database.messages.get_lxmf_message_by_hash.return_value = {}  # To avoid JSON error

@@ -124,7 +129,7 @@ async def test_telemetry_request_parsing(mock_app):

    # Verify handle_telemetry_request was called
    mock_app.handle_telemetry_request.assert_called_with(
-        "736f757263655f686173685f6279746573"
+        "736f757263655f686173685f6279746573",
    )


@@ -135,4 +140,3 @@ async def test_tracking_toggle_endpoint(mock_app):

    # We can't easily test the web endpoint here without more setup,
    # but we can test the logic it calls if it was refactored into a method.
-    pass
@@ -1,8 +1,14 @@
 import asyncio
+from unittest.mock import MagicMock, patch

 import numpy as np
+import pytest

-from meshchatx.src.backend.web_audio_bridge import WebAudioSink, WebAudioSource
+from meshchatx.src.backend.web_audio_bridge import (
+    WebAudioBridge,
+    WebAudioSink,
+    WebAudioSource,
+)


 class _DummySink:
@@ -37,3 +43,36 @@ def test_web_audio_sink_encodes_and_sends_bytes():
    loop.run_until_complete(asyncio.sleep(0.01))
    loop.close()
    assert sent, "expected audio bytes to be queued for sending"
+
+
+@pytest.mark.asyncio
+async def test_web_audio_bridge_lazy_loop():
+    """Test that WebAudioBridge retrieves the loop lazily to avoid startup crashes."""
+    mock_tele_mgr = MagicMock()
+    mock_config_mgr = MagicMock()
+
+    # Mock get_event_loop to simulate it not being available during init
+    with patch("asyncio.get_event_loop", side_effect=RuntimeError("No running loop")):
+        bridge = WebAudioBridge(mock_tele_mgr, mock_config_mgr)
+        assert bridge._loop is None
+
+        # Simulate a running loop
+        current_loop = asyncio.get_running_loop()
+        assert bridge.loop == current_loop
+        assert bridge._loop == current_loop
+
+
+def test_web_audio_bridge_asyncutils_fallback():
+    """Test that WebAudioBridge falls back to AsyncUtils.main_loop if no loop is running."""
+    from meshchatx.src.backend.async_utils import AsyncUtils
+
+    mock_loop = MagicMock(spec=asyncio.AbstractEventLoop)
+    AsyncUtils.set_main_loop(mock_loop)
+
+    mock_tele_mgr = MagicMock()
+    mock_config_mgr = MagicMock()
+
+    with patch("asyncio.get_running_loop", side_effect=RuntimeError):
+        bridge = WebAudioBridge(mock_tele_mgr, mock_config_mgr)
+        assert bridge.loop == mock_loop
+        assert bridge._loop == mock_loop
@@ -32,37 +32,39 @@ const i18n = createI18n({
    },
 });

-const router = createRouter({
-    history: createWebHashHistory(),
-    routes: [
-        { path: "/", name: "messages", component: { template: "<div>Messages</div>" } },
-        { path: "/nomadnetwork", name: "nomadnetwork", component: { template: "<div>Nomad</div>" } },
-        { path: "/map", name: "map", component: { template: "<div>Map</div>" } },
-        { path: "/archives", name: "archives", component: { template: "<div>Archives</div>" } },
-        { path: "/call", name: "call", component: { template: "<div>Call</div>" } },
-        { path: "/interfaces", name: "interfaces", component: { template: "<div>Interfaces</div>" } },
-        { path: "/network-visualiser", name: "network-visualiser", component: { template: "<div>Network</div>" } },
-        { path: "/tools", name: "tools", component: { template: "<div>Tools</div>" } },
-        { path: "/settings", name: "settings", component: { template: "<div>Settings</div>" } },
-        { path: "/identities", name: "identities", component: { template: "<div>Identities</div>" } },
-        { path: "/about", name: "about", component: { template: "<div>About</div>" } },
-        { path: "/profile/icon", name: "profile.icon", component: { template: "<div>Profile</div>" } },
-        { path: "/changelog", name: "changelog", component: { template: "<div>Changelog</div>" } },
-        { path: "/tutorial", name: "tutorial", component: { template: "<div>Tutorial</div>" } },
-    ],
-});
+const routes = [
+    { path: "/", name: "messages", component: { template: "<div>Messages</div>" } },
+    { path: "/nomadnetwork", name: "nomadnetwork", component: { template: "<div>Nomad</div>" } },
+    { path: "/map", name: "map", component: { template: "<div>Map</div>" } },
+    { path: "/archives", name: "archives", component: { template: "<div>Archives</div>" } },
+    { path: "/call", name: "call", component: { template: "<div>Call</div>" } },
+    { path: "/interfaces", name: "interfaces", component: { template: "<div>Interfaces</div>" } },
+    { path: "/network-visualiser", name: "network-visualiser", component: { template: "<div>Network</div>" } },
+    { path: "/tools", name: "tools", component: { template: "<div>Tools</div>" } },
+    { path: "/settings", name: "settings", component: { template: "<div>Settings</div>" } },
+    { path: "/identities", name: "identities", component: { template: "<div>Identities</div>" } },
+    { path: "/about", name: "about", component: { template: "<div>About</div>" } },
+    { path: "/profile/icon", name: "profile.icon", component: { template: "<div>Profile</div>" } },
+    { path: "/changelog", name: "changelog", component: { template: "<div>Changelog</div>" } },
+    { path: "/tutorial", name: "tutorial", component: { template: "<div>Tutorial</div>" } },
+];

 describe("App.vue Modals", () => {
+    let router;
    beforeEach(() => {
+        router = createRouter({
+            history: createWebHashHistory(),
+            routes,
+        });
        vi.clearAllMocks();
        axiosMock.get.mockImplementation((url) => {
            if (url === "/api/v1/app/info") {
                return Promise.resolve({
                    data: {
                        app_info: {
-                            version: "4.0.0",
+                            version: "4.1.0",
                            tutorial_seen: true,
-                            changelog_seen_version: "4.0.0",
+                            changelog_seen_version: "4.1.0",
                        },
                    },
                });
@@ -92,7 +94,7 @@ describe("App.vue Modals", () => {
                return Promise.resolve({
                    data: {
                        app_info: {
-                            version: "4.0.0",
+                            version: "4.1.0",
                            tutorial_seen: false,
                            changelog_seen_version: "0.0.0",
                        },
@@ -139,6 +141,7 @@ describe("App.vue Modals", () => {
            },
        });

+        await router.isReady();
        await new Promise((resolve) => setTimeout(resolve, 200));

        expect(wrapper.vm.$refs.tutorialModal.visible).toBe(true);
@@ -150,7 +153,7 @@ describe("App.vue Modals", () => {
                return Promise.resolve({
                    data: {
                        app_info: {
-                            version: "4.0.0",
+                            version: "4.1.0",
                            tutorial_seen: true,
                            changelog_seen_version: "3.9.0",
                        },
@@ -158,7 +161,7 @@ describe("App.vue Modals", () => {
                });
            }
            if (url === "/api/v1/app/changelog") {
-                return Promise.resolve({ data: { html: "<h1>New Features</h1>", version: "4.0.0" } });
+                return Promise.resolve({ data: { html: "<h1>New Features</h1>", version: "4.1.0" } });
            }
            if (url === "/api/v1/config") return Promise.resolve({ data: { config: { theme: "dark" } } });
            if (url === "/api/v1/auth/status") return Promise.resolve({ data: { auth_enabled: false } });
@@ -197,6 +200,7 @@ describe("App.vue Modals", () => {
            },
        });

+        await router.isReady();
        await new Promise((resolve) => setTimeout(resolve, 200));

        expect(wrapper.vm.$refs.changelogModal.visible).toBe(true);
@@ -78,7 +78,7 @@ describe("ChangelogModal.vue", () => {
        axiosMock.get.mockResolvedValue({
            data: {
                html: "<h1>Test</h1>",
-                version: "4.0.0",
+                version: "4.1.0",
            },
        });

@@ -95,7 +95,7 @@ describe("ChangelogModal.vue", () => {
        axiosMock.get.mockResolvedValue({
            data: {
                html: "<h1>Test</h1>",
-                version: "4.0.0",
+                version: "4.1.0",
            },
        });

@@ -114,7 +114,7 @@ describe("ChangelogModal.vue", () => {
        axiosMock.get.mockResolvedValue({
            data: {
                html: "<h1>Test</h1>",
-                version: "4.0.0",
+                version: "4.1.0",
            },
        });

@@ -194,6 +194,8 @@ describe("NetworkVisualiser.vue", () => {

    it("fuzzing: handles large and messy network data without crashing", async () => {
        const wrapper = mountVisualiser();
+        // Wait for initial load to finish
+        await new Promise((resolve) => setTimeout(resolve, 200));

        // Generate messy path table
        const nodeCount = 500;
@@ -233,6 +235,8 @@ describe("NetworkVisualiser.vue", () => {

    it("fuzzing: handles missing announce data gracefully", async () => {
        const wrapper = mountVisualiser();
+        // Wait for initial load to finish
+        await new Promise((resolve) => setTimeout(resolve, 200));

        // Set interfaces so eth0 exists
        wrapper.vm.interfaces = [{ name: "eth0", status: true }];
@@ -254,6 +258,9 @@ describe("NetworkVisualiser.vue", () => {

    it("fuzzing: handles circular or malformed links", async () => {
        const wrapper = mountVisualiser();
+        // Wait for initial load to finish
+        await new Promise((resolve) => setTimeout(resolve, 200));
+
        wrapper.vm.interfaces = [{ name: "eth0", status: true }];
        wrapper.vm.announces = {
            node1: {
@@ -280,6 +287,9 @@ describe("NetworkVisualiser.vue", () => {

    it("performance: measures time to process 1000 nodes", async () => {
        const wrapper = mountVisualiser();
+        // Wait for initial load to finish
+        await new Promise((resolve) => setTimeout(resolve, 200));
+
        const nodeCount = 1000;

        const pathTable = Array.from({ length: nodeCount }, (_, i) => ({
@@ -0,0 +1,168 @@
+import { mount } from "@vue/test-utils";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import NetworkVisualiser from "@/components/network-visualiser/NetworkVisualiser.vue";
+
+// Mock vis-network and vis-data
+vi.mock("vis-network", () => ({
+    Network: vi.fn().mockImplementation(() => ({
+        on: vi.fn(),
+        off: vi.fn(),
+        destroy: vi.fn(),
+        setOptions: vi.fn(),
+        setData: vi.fn(),
+        getPositions: vi.fn().mockReturnValue({ me: { x: 0, y: 0 } }),
+    })),
+}));
+
+vi.mock("vis-data", () => {
+    class MockDataSet {
+        constructor() {
+            this._data = new Map();
+        }
+        add(data) {
+            (Array.isArray(data) ? data : [data]).forEach((i) => this._data.set(i.id, i));
+        }
+        update(data) {
+            (Array.isArray(data) ? data : [data]).forEach((i) => this._data.set(i.id, i));
+        }
+        remove(ids) {
+            (Array.isArray(ids) ? ids : [ids]).forEach((id) => this._data.delete(id));
+        }
+        get(id) {
+            return id === undefined ? Array.from(this._data.values()) : this._data.get(id) || null;
+        }
+        getIds() {
+            return Array.from(this._data.keys());
+        }
+        get length() {
+            return this._data.size;
+        }
+    }
+    return { DataSet: MockDataSet };
+});
+
+describe("NetworkVisualiser Optimization and Abort", () => {
+    let axiosMock;
+
+    beforeEach(() => {
+        axiosMock = {
+            get: vi.fn().mockImplementation((url) => {
+                if (url.includes("/api/v1/config")) return Promise.resolve({ data: { config: {} } });
+                if (url.includes("/api/v1/interface-stats"))
+                    return Promise.resolve({ data: { interface_stats: { interfaces: [] } } });
+                if (url.includes("/api/v1/lxmf/conversations")) return Promise.resolve({ data: { conversations: [] } });
+                if (url.includes("/api/v1/path-table"))
+                    return Promise.resolve({ data: { path_table: [], total_count: 0 } });
+                if (url.includes("/api/v1/announces"))
+                    return Promise.resolve({ data: { announces: [], total_count: 0 } });
+                return Promise.resolve({ data: {} });
+            }),
+            isCancel: vi.fn().mockImplementation((e) => e && e.name === "AbortError"),
+        };
+        window.axios = axiosMock;
+    });
+
+    afterEach(() => {
+        delete window.axios;
+        vi.clearAllMocks();
+    });
+
+    const mountVisualiser = () => {
+        return mount(NetworkVisualiser, {
+            global: {
+                mocks: { $t: (msg) => msg },
+                stubs: { Toggle: true },
+            },
+        });
+    };
+
+    it("aborts pending requests on unmount", async () => {
+        // Prevent auto-init
+        vi.spyOn(NetworkVisualiser.methods, "init").mockImplementation(() => {});
+        const wrapper = mountVisualiser();
+
+        const abortSpy = vi.spyOn(wrapper.vm.abortController, "abort");
+
+        let signal;
+        axiosMock.get.mockImplementationOnce((url, config) => {
+            signal = config.signal;
+            return new Promise(() => {});
+        });
+
+        wrapper.vm.getPathTableBatch();
+
+        expect(axiosMock.get).toHaveBeenCalled();
+        expect(signal.aborted).toBe(false);
+
+        wrapper.unmount();
+
+        expect(abortSpy).toHaveBeenCalled();
+        expect(signal.aborted).toBe(true);
+    });
+
+    it("stops processing visualization batches when aborted", async () => {
+        vi.spyOn(NetworkVisualiser.methods, "init").mockImplementation(() => {});
+        const wrapper = mountVisualiser();
+
+        // Prepare large data
+        wrapper.vm.pathTable = Array.from({ length: 1000 }, (_, i) => ({ hash: `h${i}`, interface: "eth0", hops: 1 }));
+        wrapper.vm.announces = wrapper.vm.pathTable.reduce((acc, cur) => {
+            acc[cur.hash] = {
+                destination_hash: cur.hash,
+                aspect: "lxmf.delivery",
+                display_name: "node",
+            };
+            return acc;
+        }, {});
+
+        // Add lxmf_user_icon to trigger await in createIconImage and slow it down
+        const firstHash = wrapper.vm.pathTable[0].hash;
+        wrapper.vm.announces[firstHash].lxmf_user_icon = {
+            icon_name: "test",
+            foreground_colour: "#000",
+            background_colour: "#fff",
+        };
+        wrapper.vm.conversations[firstHash] = { lxmf_user_icon: wrapper.vm.announces[firstHash].lxmf_user_icon };
+
+        // Mock createIconImage to be slow
+        wrapper.vm.createIconImage = vi.fn().mockImplementation(() => new Promise((r) => setTimeout(r, 100)));
+
+        const processPromise = wrapper.vm.processVisualization();
+
+        // Give it some time to start first batch and hit the await
+        await new Promise((r) => setTimeout(r, 50));
+
+        // It should be in batch 1 and stuck on createIconImage
+        expect(wrapper.vm.currentBatch).toBe(1);
+
+        // Abort
+        wrapper.vm.abortController.abort();
+
+        await processPromise;
+
+        // Should have aborted and not reached the end where it resets currentBatch to 0
+        // (Wait, actually if it returns early it stays 1)
+        expect(wrapper.vm.currentBatch).toBe(1);
+    });
+
+    it("parallelizes batch fetching", async () => {
+        vi.spyOn(NetworkVisualiser.methods, "init").mockImplementation(() => {});
+        const wrapper = mountVisualiser();
+
+        // Mock success with total_count > pageSize
+        axiosMock.get.mockImplementation((url, config) => {
+            if (url === "/api/v1/path-table") {
+                return Promise.resolve({ data: { path_table: [], total_count: 5000 } });
+            }
+            return Promise.resolve({ data: {} });
+        });
+
+        wrapper.vm.pageSize = 1000;
+
+        await wrapper.vm.getPathTableBatch();
+
+        // Should have called offset 0, then offsets 1000, 2000, 3000, 4000
+        // Total 5 calls
+        expect(axiosMock.get).toHaveBeenCalledTimes(5);
+    });
+});
Author	SHA1	Message	Date
Sudo-Ivan	4106e28ff1	Update tutorial modal handling during route changes Some checks failed CI / test-backend (push) Successful in 4s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 11s Details CI / test-lang (push) Successful in 1m17s Details CI / build-frontend (push) Successful in 2m2s Details CI / lint (push) Successful in 9m45s Details Tests / test (push) Successful in 13m50s Details Build and Publish Docker Image / build (push) Failing after 14m26s Details Build and Publish Docker Image / build-dev (push) Failing after 16m8s Details Build Test / Build and Test (push) Failing after 27m55s Details	2026-01-14 20:28:35 -06:00
Sudo-Ivan	33d79424e9	Update workflows with new task commands Some checks failed OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 11s Details CI / test-backend (push) Successful in 23s Details CI / lint (push) Successful in 1m24s Details CI / test-lang (push) Successful in 9m40s Details CI / build-frontend (push) Successful in 9m54s Details Tests / test (push) Failing after 9m55s Details Build Test / Build and Test (push) Failing after 10m27s Details Build and Publish Docker Image / build (push) Failing after 13m2s Details Build and Publish Docker Image / build-dev (push) Failing after 14m47s Details	2026-01-14 19:49:06 -06:00
Sudo-Ivan	85f734bd9b	Update build configuration for multi-architecture support - Added new build scripts for Linux and Windows targeting arm64 and x64 architectures. - Updated package.json to include architecture-specific distribution commands. - Modified build-backend.js to create architecture-specific build directories for better organization.	2026-01-14 19:47:08 -06:00
Sudo-Ivan	c5e1d5cfec	Add support for building arm64 applications on Linux and Windows - Introduced new tasks for building Linux arm64 AppImage and Windows arm64 portable EXE. - Updated existing build commands to streamline the process for legacy Electron applications. - Improved command syntax for electron-builder to enhance clarity and maintainability.	2026-01-14 19:46:45 -06:00
Sudo-Ivan	bb4b60ce61	Add Wine environment setup for building Windows applications Some checks failed Tests / test (push) Failing after 4m54s Details CI / test-backend (push) Successful in 4s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 10s Details CI / build-frontend (push) Failing after 23s Details CI / test-lang (push) Failing after 59s Details CI / lint (push) Failing after 4m43s Details Build and Release / Build and Release (push) Failing after 2m36s Details Arch Linux Package / build (push) Failing after 3m32s Details Build Test / Build and Test (push) Failing after 13m56s Details Build and Publish Docker Image / build (push) Failing after 14m16s Details Build and Publish Docker Image / build-dev (push) Failing after 15m52s Details - Introduced a new job step in the build workflow to set up a Wine environment. - Downloaded and installed Windows Python and Git within Wine. - Configured Wine to install necessary build dependencies using pip. - Enhanced the build process for the Electron app targeting Windows platforms.	2026-01-14 19:30:17 -06:00
Sudo-Ivan	837c62ef96	Refactor Taskfile for improved organization and clarity	2026-01-14 19:30:08 -06:00
Sudo-Ivan	ee5a71361a	4.1.0 Some checks failed CI / test-backend (push) Successful in 4s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 20s Details CI / lint (push) Successful in 9m41s Details Arch Linux Package / build (push) Failing after 23s Details CI / build-frontend (push) Successful in 9m45s Details CI / test-lang (push) Successful in 9m34s Details Build Test / Build and Test (push) Successful in 13m27s Details Build and Release / Build and Release (push) Failing after 7m6s Details Tests / test (push) Failing after 20m21s Details Build and Publish Docker Image / build (push) Failing after 14m23s Details Build and Publish Docker Image / build-dev (push) Has been skipped Details	2026-01-14 19:03:00 -06:00
Sudo-Ivan	50806798da	Fix tutorial modal behavior and state management Some checks failed CI / test-backend (push) Successful in 5s Details CI / build-frontend (push) Successful in 1m24s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 30s Details CI / lint (push) Successful in 9m44s Details Build Test / Build and Test (push) Successful in 12m17s Details CI / test-lang (push) Successful in 9m37s Details Build and Publish Docker Image / build-dev (push) Failing after 14m57s Details Build and Publish Docker Image / build (push) Failing after 20m56s Details Tests / test (push) Failing after 24m20s Details	2026-01-14 18:52:55 -06:00
Sudo-Ivan	580812dcd1	Update README Some checks failed CI / test-backend (push) Successful in 4s Details CI / lint (push) Successful in 9m45s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 9s Details CI / build-frontend (push) Successful in 9m43s Details Build Test / Build and Test (push) Successful in 13m15s Details CI / test-lang (push) Successful in 9m40s Details Build and Publish Docker Image / build (push) Failing after 14m47s Details Build and Publish Docker Image / build-dev (push) Failing after 15m1s Details Tests / test (push) Successful in 14m2s Details	2026-01-14 18:42:51 -06:00
Sudo-Ivan	a9f342f112	Update README Some checks failed CI / test-backend (push) Successful in 1m10s Details CI / build-frontend (push) Successful in 1m50s Details CI / test-lang (push) Successful in 1m59s Details CI / lint (push) Successful in 3m14s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 38s Details Build Test / Build and Test (push) Successful in 13m16s Details Tests / test (push) Failing after 21m48s Details Build and Publish Docker Image / build-dev (push) Failing after 28m31s Details Build and Publish Docker Image / build (push) Failing after 30m4s Details	2026-01-14 18:37:47 -06:00
Sudo-Ivan	1eeeb1cb4e	Improve crash recovery diagnostics and analysis Some checks failed OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 12s Details CI / test-backend (push) Successful in 49s Details CI / lint (push) Successful in 2m23s Details CI / test-lang (push) Successful in 9m36s Details CI / build-frontend (push) Successful in 9m54s Details Build Test / Build and Test (push) Successful in 12m23s Details Build and Publish Docker Image / build-dev (push) Failing after 15m8s Details Tests / test (push) Successful in 15m17s Details Build and Publish Docker Image / build (push) Failing after 24m27s Details - Expanded the crash recovery module to include advanced diagnostic metrics such as system entropy, KL-Divergence, and manifold curvature. - Improved root cause analysis by implementing a probabilistic approach with detailed suggestions for various failure scenarios. - Added comprehensive tests to validate heuristic analysis, entropy calculations, and the robustness of the crash recovery logic. - Updated existing tests to ensure accurate diagnosis and reporting of system states during exceptions.	2026-01-14 18:32:58 -06:00
Sudo-Ivan	16d5f2d497	Refactor MarkdownRenderer regex patterns for improved matching Some checks failed CI / test-backend (push) Successful in 4s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 11s Details CI / test-lang (push) Successful in 2m42s Details CI / build-frontend (push) Successful in 2m46s Details CI / lint (push) Failing after 5m0s Details Build and Publish Docker Image / build-dev (push) Failing after 9m31s Details Tests / test (push) Successful in 13m48s Details Build and Publish Docker Image / build (push) Failing after 14m28s Details Build Test / Build and Test (push) Failing after 19m56s Details - Updated regex patterns in the MarkdownRenderer to use non-greedy matching for better accuracy in text rendering. - Enhanced the test for header rendering to ensure correct HTML structure and added assertions for escaping content without markdown special characters.	2026-01-14 18:16:41 -06:00
Sudo-Ivan	c08cdb65b6	Add Hypothesis settings to lifecycle tests for improved fuzzing Some checks failed CI / test-backend (push) Successful in 30s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 28s Details CI / lint (push) Successful in 1m26s Details CI / test-lang (push) Successful in 9m40s Details CI / build-frontend (push) Successful in 9m53s Details Build Test / Build and Test (push) Successful in 12m21s Details Tests / test (push) Successful in 14m1s Details Build and Publish Docker Image / build-dev (push) Failing after 14m51s Details Build and Publish Docker Image / build (push) Failing after 16m45s Details - Introduced settings to disable deadlines in the test_identity_context_repeated_lifecycle function. - Combined import statements for Hypothesis to streamline the code.	2026-01-14 18:03:15 -06:00
Sudo-Ivan	d167d7c32e	Update legacy Electron configuration and build tasks - Add legacy package.json - Update Taskfile	2026-01-14 18:00:02 -06:00
Sudo-Ivan	1788aea0c2	Add tests for crash recovery, emergency mode, and lifecycle management - Introduced new tests for heuristic analysis in crash recovery to validate error diagnosis. - Added tests for emergency mode to ensure memory concurrency handling with the in-memory database. - Created a comprehensive suite for lifecycle management, including database provider disposal and identity context teardown to prevent memory leaks. - Improved existing tests for WebAudioBridge to verify proper event loop handling and resource cleanup.	2026-01-14 17:59:22 -06:00
Sudo-Ivan	a8687a0e09	Cleanup	2026-01-14 17:58:49 -06:00
Sudo-Ivan	93974edf3f	Refactor IdentityContext teardown process to ensure proper cleanup - Added nullification of various manager attributes to prevent reference cycles and memory leaks during teardown. - Improved error handling and ensured that callbacks are cleared for telephone and voicemail managers. - Enhanced the integrity manager's save process to only execute if it exists, ensuring stability during the shutdown sequence.	2026-01-14 17:58:37 -06:00
Sudo-Ivan	5354340d8a	Update README	2026-01-14 17:58:02 -06:00
Sudo-Ivan	aaa450fe28	Add Reticulum config validation and default creation - Implemented a method to ensure a valid Reticulum config file exists, creating a default if missing or invalid. - Better error handling for reading and writing the config file to improve robustness during initialization.	2026-01-14 17:56:29 -06:00
Sudo-Ivan	a022a96f92	Improve crash recovery diagnostics and suggestions	2026-01-14 17:56:15 -06:00
Sudo-Ivan	7e57cc2b24	Add in-memory database connection handling in DatabaseProvider	2026-01-14 17:45:37 -06:00
Sudo-Ivan	6a4ed6a048	Fix WebAudioBridge to manage event loop retrieval - Introduced a property for accessing the event loop, allowing for better handling of both running and fallback scenarios. - Updated the internal loop management to improve compatibility with asynchronous operations.	2026-01-14 17:45:20 -06:00
Sudo-Ivan	ca3ef05f75	Clear clients list on call end in WebAudioBridge to prevent memory leaks	2026-01-14 13:16:55 -06:00
Sudo-Ivan	ca36d082fd	Update Markdown rendering and add robust identity restoration tests Some checks failed CI / lint (push) Successful in 2m40s Details CI / build-frontend (push) Successful in 1m30s Details CI / test-backend (push) Successful in 33s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 13s Details Build Test / Build and Test (push) Successful in 12m34s Details CI / test-lang (push) Successful in 9m36s Details Build and Publish Docker Image / build-dev (push) Failing after 14m31s Details Tests / test (push) Successful in 13m38s Details Build and Publish Docker Image / build (push) Failing after 22m25s Details - Updated the MarkdownRenderer to prevent rendering issues with single asterisks and underscores by ensuring they are not surrounded by whitespace. - Introduced new property-based tests for IdentityManager to validate robustness against various input scenarios. - Added tests for Markdown list and link rendering to ensure correct HTML output from Markdown input.	2026-01-14 13:08:26 -06:00
Sudo-Ivan	756104ff65	Remove unused ElectronUtils import from TutorialModal.vue Some checks failed CI / test-backend (push) Successful in 4s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 11s Details CI / build-frontend (push) Successful in 2m0s Details CI / test-lang (push) Successful in 1m59s Details CI / lint (push) Successful in 9m43s Details Build and Publish Docker Image / build (push) Failing after 14m40s Details Tests / test (push) Successful in 14m45s Details Build and Publish Docker Image / build-dev (push) Failing after 25m46s Details Build Test / Build and Test (push) Successful in 49m30s Details	2026-01-14 13:03:05 -06:00
Sudo-Ivan	2ce29a6488	ruff format and fixes	2026-01-14 13:02:33 -06:00
Sudo-Ivan	0ae45b45c0	Add temporary log directory setup for tests and improve input validation in fuzz tests Some checks failed CI / test-backend (push) Successful in 26s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 27s Details CI / lint (push) Failing after 1m35s Details CI / build-frontend (push) Successful in 9m46s Details CI / test-lang (push) Successful in 9m44s Details Build Test / Build and Test (push) Successful in 12m20s Details Build and Publish Docker Image / build (push) Failing after 13m38s Details Tests / test (push) Successful in 13m45s Details Build and Publish Docker Image / build-dev (push) Failing after 14m44s Details - Configured a temporary directory for log files in tests to prevent permission issues in restricted environments. - Improved input validation in fuzz tests for `root_folder_name` and `docs_file` to exclude null characters, enhancing robustness. - Introduced a new test suite for property-based testing of telemetry and utility functions, ensuring stability and correctness across various scenarios.	2026-01-14 12:40:28 -06:00
Sudo-Ivan	140ee6f341	Refactor telemetry data packing in Telemeter class - Simplified the packing of location data by removing unnecessary rounding operations.	2026-01-14 12:39:51 -06:00
Sudo-Ivan	55ddb0435d	Update Docker (dev image) workflow to trigger on master branch pushes	2026-01-14 11:48:29 -06:00
Sudo-Ivan	ec26a76690	Add packaging directory to ESLint configuration All checks were successful CI / test-backend (push) Successful in 18s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 25s Details CI / lint (push) Successful in 1m9s Details CI / test-lang (push) Successful in 9m35s Details CI / build-frontend (push) Successful in 9m49s Details Build Test / Build and Test (push) Successful in 12m17s Details Tests / test (push) Successful in 13m42s Details - Updated the ESLint configuration to include the 'packaging' directory in the list of ignored paths. - This change ensures that packaging-related files are not linted, streamlining the development process.	2026-01-14 11:02:21 -06:00
Sudo-Ivan	e067902005	Add tests for NetworkVisualiser optimization and abort handling - Introduced a new test suite for NetworkVisualiser focusing on optimization and request cancellation. - Implemented tests to ensure pending requests are aborted on component unmount. - Added validation for stopping visualization processing when requests are aborted. - Included tests for parallelized batch fetching to improve data retrieval efficiency.	2026-01-14 11:02:13 -06:00
Sudo-Ivan	8d5bef2097	Update NetworkVisualiser with abort controller and improved data fetching - Increased page size for path table and announces fetching to 1000 for better performance. - Implemented an AbortController to manage request cancellations, improving responsiveness during data loading. - Refactored data fetching methods to support concurrent requests while respecting the abort signal. - Updated loading status messages to reflect current progress during data retrieval.	2026-01-14 11:02:04 -06:00
Sudo-Ivan	2fb42d27fa	Add pagination support in database queries for announces - Implemented pagination at the database level for improved performance when no search query is provided. - Added a new method `get_filtered_announces_count` in `AnnounceManager` to retrieve the total count of filtered announces for pagination. - Adjusted the `ReticulumMeshChat` class to utilize the new count method and handle pagination more efficiently.	2026-01-14 11:01:50 -06:00
Sudo-Ivan	29b7fb6449	Refactor Dockerfile to use external build script All checks were successful CI / test-backend (push) Successful in 28s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 42s Details CI / lint (push) Successful in 2m54s Details CI / build-frontend (push) Successful in 9m46s Details CI / test-lang (push) Successful in 9m44s Details Build Test / Build and Test (push) Successful in 12m6s Details Tests / test (push) Successful in 16m26s Details	2026-01-14 08:38:28 -06:00
Sudo-Ivan	950e82b26c	Add build script for Arch package to handle permissions and execute makepkg	2026-01-14 08:38:21 -06:00
Sudo-Ivan	3f71ce1777	Update PKGBUILD to version 4.0.0 for reticulum-meshchatx	2026-01-14 08:38:16 -06:00
Sudo-Ivan	9cfbf94ddb	no-cache for Docker builds in CI workflow Some checks failed CI / test-backend (push) Successful in 5s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 11s Details Build Test / Build and Test (push) Has been cancelled Details CI / build-frontend (push) Successful in 2m12s Details CI / test-lang (push) Successful in 2m19s Details CI / lint (push) Successful in 9m42s Details Tests / test (push) Successful in 13m38s Details	2026-01-14 08:30:51 -06:00
Sudo-Ivan	9a9c5cb518	Update Arch package build workflow to use --no-cache option for Docker build All checks were successful CI / test-backend (push) Successful in 5s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 11s Details CI / test-lang (push) Successful in 1m59s Details CI / build-frontend (push) Successful in 2m20s Details CI / lint (push) Successful in 9m42s Details Tests / test (push) Successful in 13m17s Details Build Test / Build and Test (push) Successful in 35m2s Details	2026-01-14 08:18:01 -06:00
Sudo-Ivan	60dc044c88	Update dependencies All checks were successful CI / test-lang (push) Successful in 9m38s Details CI / build-frontend (push) Successful in 9m48s Details CI / test-backend (push) Successful in 17s Details OSV-Scanner Scheduled Scan / scan-scheduled (push) Successful in 18s Details CI / lint (push) Successful in 1m9s Details Build Test / Build and Test (push) Successful in 11m33s Details Tests / test (push) Successful in 13m21s Details	2026-01-14 08:05:25 -06:00
Sudo-Ivan	02c2f1d09a	Update Dockerfile	2026-01-14 08:05:06 -06:00
Sudo-Ivan	2ee31e1e34	Update build workflow	2026-01-14 07:57:57 -06:00
Sudo-Ivan	0b7478f135	Update Arch Dockerfile and CI workflow for Arch package building: create a build script to handle permissions and update volume mount path in CI configuration.	2026-01-14 07:57:48 -06:00
Sudo-Ivan	e7e16707a0	Update health check test	2026-01-14 07:57:28 -06:00