new pending visibility

.gitea/workflows/dev.yml

@@ -0,0 +1,411 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - dev-other
+
+env:
+  JAVA_VERSION: "17"
+  ANDROID_SDK_ROOT: "${{ github.workspace }}/android-sdk"
+  FLUTTER_VERSION: "3.38.5"
+  BUILD_WINDOWS: "false" # Windows build disabled (no runner available)
+  GITEA_BASE_URL: https://git.tgj.services
+  WEB_IMAGE: "git.tgj.services/petegregoryy/mileograph-web"
+  REGISTRY: git.tgj.services
+
+jobs:
+  meta:
+    runs-on:
+      - tgj-arc
+    outputs:
+      base_version: ${{ steps.meta.outputs.base }}
+      release_tag: ${{ steps.meta.outputs.release_tag }}
+      dev_suffix: ${{ steps.meta.outputs.dev_suffix }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Determine version
+        id: meta
+        run: |
+          RAW_VERSION=$(awk '/^version:/{print $2}' pubspec.yaml)
+          BASE_VERSION=${RAW_VERSION%%+*}
+          VERSION="${BASE_VERSION}"
+          TAG="v${VERSION}"
+          DEV_SUFFIX=""
+
+          if [ "${GITHUB_REF}" = "refs/heads/dev" ]; then
+            DEV_ITER="${GITHUB_RUN_NUMBER:-}"
+            if [ -z "$DEV_ITER" ]; then
+              DEV_ITER=$(git rev-list --count HEAD)
+            fi
+
+            DEV_SUFFIX="-dev.${DEV_ITER}"
+            VERSION="${BASE_VERSION}${DEV_SUFFIX}"
+            TAG="v${VERSION}"
+          fi
+
+          echo "base=${BASE_VERSION}" >> "$GITHUB_OUTPUT"
+          echo "release_tag=${TAG}" >> "$GITHUB_OUTPUT"
+          echo "dev_suffix=${DEV_SUFFIX}" >> "$GITHUB_OUTPUT"
+
+      - name: Fail if release already exists
+        env:
+          TAG: ${{ steps.meta.outputs.release_tag }}
+        run: |
+          set -euo pipefail
+
+          if ! command -v curl >/dev/null 2>&1; then
+            if command -v sudo >/dev/null 2>&1; then
+              SUDO="sudo"
+            else
+              SUDO=""
+            fi
+            $SUDO apt-get update
+            $SUDO apt-get install -y curl ca-certificates
+          fi
+
+          URL="${GITEA_BASE_URL}/api/v1/repos/${{ github.repository }}/releases/tags/${TAG}"
+          CODE="$(curl -sS -o /dev/null -w "%{http_code}" -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" "$URL" || true)"
+
+          if [ "$CODE" = "200" ]; then
+            echo "Release already exists for tag ${TAG}; refusing to re-release."
+            exit 1
+          fi
+          if [ "$CODE" != "404" ]; then
+            echo "Unexpected response checking existing release (${CODE}) at ${URL}"
+            exit 1
+          fi
+
+  android-build:
+    runs-on:
+      - tgj-arc
+    needs: meta
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      #
+      #      - name: Install OS deps (Android)
+      #        run: |
+      #          if command -v sudo >/dev/null 2>&1; then
+      #            SUDO="sudo"
+      #          else
+      #            SUDO=""
+      #          fi
+      #          $SUDO apt-get update
+      #          $SUDO apt-get install -y unzip xz-utils zip libstdc++6 liblzma-dev curl jq
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: ${{ env.JAVA_VERSION }}
+
+      - name: Install Android SDK
+        run: |
+          mkdir -p "$ANDROID_SDK_ROOT"/cmdline-tools
+          curl -fsSL https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip -o /tmp/cli-tools.zip
+          unzip -q /tmp/cli-tools.zip -d "$ANDROID_SDK_ROOT"/cmdline-tools
+          mv "$ANDROID_SDK_ROOT"/cmdline-tools/cmdline-tools "$ANDROID_SDK_ROOT"/cmdline-tools/latest
+
+          # Accept licences (ignore SIGPIPE exit 141)
+          yes | "$ANDROID_SDK_ROOT"/cmdline-tools/latest/bin/sdkmanager --sdk_root="$ANDROID_SDK_ROOT" --licenses || true
+
+          # Install required packages (also ignore SIGPIPE)
+          yes | "$ANDROID_SDK_ROOT"/cmdline-tools/latest/bin/sdkmanager --sdk_root="$ANDROID_SDK_ROOT" \
+            "platform-tools" "platforms;android-33" "build-tools;33.0.2" || true
+
+          echo "ANDROID_SDK_ROOT=$ANDROID_SDK_ROOT" >> "$GITHUB_ENV"
+          echo "$ANDROID_SDK_ROOT/platform-tools" >> "$GITHUB_PATH"
+          echo "$ANDROID_SDK_ROOT/build-tools/33.0.2" >> "$GITHUB_PATH"
+
+      #      - name: Install Flutter SDK
+      #        run: |
+      #          set -euo pipefail
+      #          FLUTTER_HOME="$HOME/flutter"
+      #          # Avoid git ownership issues when Flutter checks out deps.
+      #          git config --global --add safe.directory "$FLUTTER_HOME" || true
+      #          if [ ! -x "$FLUTTER_HOME/bin/flutter" ]; then
+      #            rm -rf "$FLUTTER_HOME"
+      #            curl -fsSL -o /tmp/flutter.tar.xz "https://storage.googleapis.com/flutter_infra_release/releases/stable/linux/flutter_linux_${FLUTTER_VERSION}-stable.tar.xz"
+      #            tar -C "$HOME" -xf /tmp/flutter.tar.xz
+      #          fi
+      #          echo "$FLUTTER_HOME/bin" >> "$GITHUB_PATH"
+      #          "$FLUTTER_HOME/bin/flutter" --version
+
+      - name: Allow all git directories (CI)
+        run: git config --global --add safe.directory '*'
+
+      - name: Set pub cache path
+        run: echo "PUB_CACHE=${GITHUB_WORKSPACE}/.pub-cache" >> "$GITHUB_ENV"
+
+      - name: Flutter dependencies
+        run: flutter pub get
+
+      - name: Prepare Android keystore (optional)
+        if: ${{ secrets.ANDROID_KEYSTORE_BASE64 != '' }}
+        run: |
+          echo "${{ secrets.ANDROID_KEYSTORE_BASE64 }}" | base64 -d > android-release-key.jks
+          echo "ANDROID_KEYSTORE_PATH=$PWD/android-release-key.jks" >> "$GITHUB_ENV"
+          echo "ANDROID_KEYSTORE_PASSWORD=${{ secrets.ANDROID_KEYSTORE_PASSWORD }}" >> "$GITHUB_ENV"
+          echo "ANDROID_KEY_ALIAS=${{ secrets.ANDROID_KEY_ALIAS }}" >> "$GITHUB_ENV"
+          echo "ANDROID_KEY_PASSWORD=${{ secrets.ANDROID_KEY_PASSWORD }}" >> "$GITHUB_ENV"
+
+      - name: Build Android App Bundle (release)
+        run: flutter build appbundle --release
+
+      - name: Archive Android App Bundle
+        env:
+          BASE_VERSION: ${{ needs.meta.outputs.base_version }}
+        run: |
+          set -euo pipefail
+          BUNDLE_SRC="build/app/outputs/bundle/release/app-release.aab"
+          if [ ! -f "$BUNDLE_SRC" ]; then
+            echo "Bundle not found at $BUNDLE_SRC"
+            exit 1
+          fi
+          cp "$BUNDLE_SRC" "mileograph-${BASE_VERSION}.aab"
+
+      - name: Download bundletool
+        run: |
+          BUNDLETOOL_VERSION=1.15.6
+          curl -fsSL -o bundletool.jar "https://github.com/google/bundletool/releases/download/${BUNDLETOOL_VERSION}/bundletool-all-${BUNDLETOOL_VERSION}.jar"
+
+      - name: Extract universal APK from bundle
+        env:
+          BASE_VERSION: ${{ needs.meta.outputs.base_version }}
+        run: |
+          set -euo pipefail
+
+          BUNDLE="build/app/outputs/bundle/release/app-release.aab"
+          OUTPUT_APKS="app-release.apks"
+          APK_NAME="mileograph-${BASE_VERSION}.apk"
+
+          if [ ! -f "$BUNDLE" ]; then
+            echo "Bundle not found at $BUNDLE"
+            exit 1
+          fi
+
+          SIGNING_ARGS=()
+          if [ -n "${ANDROID_KEYSTORE_PATH:-}" ] && [ -f "$ANDROID_KEYSTORE_PATH" ]; then
+            SIGNING_ARGS+=(--ks="$ANDROID_KEYSTORE_PATH")
+            SIGNING_ARGS+=(--ks-pass="pass:${ANDROID_KEYSTORE_PASSWORD}")
+            SIGNING_ARGS+=(--ks-key-alias="${ANDROID_KEY_ALIAS}")
+            KEY_PASS="${ANDROID_KEY_PASSWORD:-$ANDROID_KEYSTORE_PASSWORD}"
+            SIGNING_ARGS+=(--key-pass="pass:${KEY_PASS}")
+          else
+            echo "No release keystore provided; bundletool will sign with the debug keystore."
+          fi
+
+          java -jar bundletool.jar build-apks \
+            --bundle="$BUNDLE" \
+            --output="$OUTPUT_APKS" \
+            --mode=universal \
+            "${SIGNING_ARGS[@]}"
+
+          unzip -p "$OUTPUT_APKS" universal.apk > "$APK_NAME"
+          ls -lh "$APK_NAME"
+
+      - name: Upload Android APK artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: android-apk
+          path: mileograph-${{ needs.meta.outputs.base_version }}.apk
+
+      - name: Upload Android AAB artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: android-aab
+          path: mileograph-${{ needs.meta.outputs.base_version }}.aab
+
+  linux-build:
+    runs-on:
+      - tgj-arc
+    needs: meta
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Allow all git directories (CI)
+        run: git config --global --add safe.directory '*'
+
+      - name: Set pub cache path
+        run: echo "PUB_CACHE=${GITHUB_WORKSPACE}/.pub-cache" >> "$GITHUB_ENV"
+
+      - name: Flutter dependencies
+        run: flutter pub get
+
+      - name: Enable Linux desktop
+        run: flutter config --enable-linux-desktop
+
+      - name: Build Linux binary (release)
+        run: |
+          flutter build linux --release
+          tar -C build/linux/x64/release/bundle -czf app-linux-x64.tar.gz .
+
+      - name: Upload Linux artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: linux-bundle
+          path: app-linux-x64.tar.gz
+
+  web-build:
+    runs-on:
+      - tgj-arc
+    needs: meta
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Allow all git directories (CI)
+        run: git config --global --add safe.directory '*'
+
+      - name: Set pub cache path
+        run: echo "PUB_CACHE=${GITHUB_WORKSPACE}/.pub-cache" >> "$GITHUB_ENV"
+
+      - name: Flutter dependencies
+        run: flutter pub get
+
+      - name: Enable Flutter web
+        run: flutter config --enable-web
+
+      - name: Build Flutter web (release)
+        run: |
+          flutter build web --release --base-href=/
+          tar -C build/web -czf app-web.tar.gz .
+
+      - name: Upload Web artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: web-build
+          path: app-web.tar.gz
+
+      - name: Set up docker buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Docker meta
+        id: dmeta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/petegregoryy/railframe-web
+          flavor: latest=false
+          tags: |
+            type=sha,prefix=
+            type=raw,value=${{ needs.meta.outputs.base_version }}${{ needs.meta.outputs.dev_suffix }}
+
+      - name: Login to the docker registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: petegregoryy
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push
+        id: docker_build
+        uses: docker/build-push-action@v6
+        with:
+          file: Dockerfile.web
+          context: .
+          push: true
+          tags: ${{ steps.dmeta.outputs.tags }}
+          labels: ${{ steps.dmeta.outputs.labels }}
+          cache-from: type=registry,ref=${{ env.REGISTRY }}/petegregoryy/railframe-web:buildcache-dev
+          cache-to: type=registry,ref=${{ env.REGISTRY }}/petegregoryy/railframe-web:buildcache-dev,mode=max
+
+  release-dev:
+    runs-on:
+      - tgj-arc
+    needs:
+      - meta
+      - android-build
+      - linux-build
+      - web-build
+    steps:
+      - name: Download Android APK
+        if: ${{ github.ref == 'refs/heads/dev' }}
+        uses: actions/download-artifact@v3
+        with:
+          name: android-apk
+          path: artifacts
+
+      - name: Download Android AAB
+        if: ${{ github.ref == 'refs/heads/dev' }}
+        uses: actions/download-artifact@v3
+        with:
+          name: android-aab
+          path: artifacts
+
+      - name: Prepare APK and tag
+        if: ${{ github.ref == 'refs/heads/dev' }}
+        id: bundle
+        run: |
+          BASE="${{ needs.meta.outputs.base_version }}"
+          TAG="${{ needs.meta.outputs.release_tag }}"
+          DEV_SUFFIX="${{ needs.meta.outputs.dev_suffix }}"
+          if [ -z "$DEV_SUFFIX" ]; then
+            echo "dev_suffix is empty; expected '-dev.<n>'"
+            exit 1
+          fi
+
+          VERSION="${BASE}${DEV_SUFFIX}"
+          APK_NAME="mileograph-${VERSION}.apk"
+          AAB_NAME="mileograph-${VERSION}.aab"
+
+          mv "artifacts/mileograph-${BASE}.apk" "artifacts/${APK_NAME}"
+          mv "artifacts/mileograph-${BASE}.aab" "artifacts/${AAB_NAME}"
+
+          echo "tag=${TAG}" >> "$GITHUB_OUTPUT"
+          echo "apk=artifacts/${APK_NAME}" >> "$GITHUB_OUTPUT"
+          echo "aab=artifacts/${AAB_NAME}" >> "$GITHUB_OUTPUT"
+
+      - name: Create prerelease on Gitea
+        if: ${{ github.ref == 'refs/heads/dev' }}
+        uses: ncipollo/release-action@v1
+        with:
+          tag: ${{ steps.bundle.outputs.tag }}
+          name: ${{ steps.bundle.outputs.tag }}
+          prerelease: true
+          commit: ${{ github.sha }}
+          token: ${{ secrets.GITEA_TOKEN }}
+          # NOTE: no `artifacts:` here
+
+      - name: Attach APK to Gitea release
+        if: ${{ github.ref == 'refs/heads/dev' }}
+        run: |
+          set -euo pipefail
+
+          TAG="${{ steps.bundle.outputs.tag }}"
+          APK="${{ steps.bundle.outputs.apk }}"
+
+          # 1. Find release ID by tag
+          RELEASE_JSON=$(curl -sS \
+            -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
+            "${GITEA_BASE_URL}/api/v1/repos/${{ github.repository }}/releases/tags/${TAG}")
+
+          RELEASE_ID=$(echo "$RELEASE_JSON" | jq -r '.id')
+
+          echo "Release ID: $RELEASE_ID"
+
+          # 2. Upload APK with multipart/form-data
+          NAME=$(basename "$APK")
+          echo "Uploading $NAME"
+
+          curl -sS -X POST \
+            -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
+            -F "attachment=@${APK}" \
+            -F "name=${NAME}" \
+            "${GITEA_BASE_URL}/api/v1/repos/${{ github.repository }}/releases/${RELEASE_ID}/assets" \
+            >/dev/null
+
+          # Attach AAB
+          AAB="${{ steps.bundle.outputs.aab }}"
+          NAME_AAB=$(basename "$AAB")
+          echo "Uploading $NAME_AAB"
+
+          curl -sS -X POST \
+            -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
+            -F "attachment=@${AAB}" \
+            -F "name=${NAME_AAB}" \
+            "${GITEA_BASE_URL}/api/v1/repos/${{ github.repository }}/releases/${RELEASE_ID}/assets" \
+            >/dev/null

.gitea/workflows/release.yml

@@ -13,6 +13,7 @@ env:
   BUILD_WINDOWS: "false" # Windows build disabled (no runner available)
   GITEA_BASE_URL: https://git.tgj.services
   WEB_IMAGE: "git.tgj.services/petegregoryy/mileograph-web"
+  REGISTRY: git.tgj.services
 
 jobs:
   meta:
@@ -43,7 +44,7 @@ jobs:
 
             DEV_SUFFIX="-dev.${DEV_ITER}"
             VERSION="${BASE_VERSION}${DEV_SUFFIX}"
-            TAG="v${VERSION}"
+            TAG="${VERSION}"
           fi
 
           echo "base=${BASE_VERSION}" >> "$GITHUB_OUTPUT"
@@ -80,21 +81,21 @@ jobs:
 
   android-build:
     runs-on:
-      - mileograph
+      - tgj-arc
     needs: meta
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-
+      #
-      - name: Install OS deps (Android)
+      #      - name: Install OS deps (Android)
-        run: |
+      #        run: |
-          if command -v sudo >/dev/null 2>&1; then
+      #          if command -v sudo >/dev/null 2>&1; then
-            SUDO="sudo"
+      #            SUDO="sudo"
-          else
+      #          else
-            SUDO=""
+      #            SUDO=""
-          fi
+      #          fi
-          $SUDO apt-get update
+      #          $SUDO apt-get update
-          $SUDO apt-get install -y unzip xz-utils zip libstdc++6 liblzma-dev curl jq
+      #          $SUDO apt-get install -y unzip xz-utils zip libstdc++6 liblzma-dev curl jq
 
       - name: Setup Java
         uses: actions/setup-java@v4
@@ -120,19 +121,19 @@ jobs:
           echo "$ANDROID_SDK_ROOT/platform-tools" >> "$GITHUB_PATH"
           echo "$ANDROID_SDK_ROOT/build-tools/33.0.2" >> "$GITHUB_PATH"
 
-      - name: Install Flutter SDK
+      #      - name: Install Flutter SDK
-        run: |
+      #        run: |
-          set -euo pipefail
+      #          set -euo pipefail
-          FLUTTER_HOME="$HOME/flutter"
+      #          FLUTTER_HOME="$HOME/flutter"
-          # Avoid git ownership issues when Flutter checks out deps.
+      #          # Avoid git ownership issues when Flutter checks out deps.
-          git config --global --add safe.directory "$FLUTTER_HOME" || true
+      #          git config --global --add safe.directory "$FLUTTER_HOME" || true
-          if [ ! -x "$FLUTTER_HOME/bin/flutter" ]; then
+      #          if [ ! -x "$FLUTTER_HOME/bin/flutter" ]; then
-            rm -rf "$FLUTTER_HOME"
+      #            rm -rf "$FLUTTER_HOME"
-            curl -fsSL -o /tmp/flutter.tar.xz "https://storage.googleapis.com/flutter_infra_release/releases/stable/linux/flutter_linux_${FLUTTER_VERSION}-stable.tar.xz"
+      #            curl -fsSL -o /tmp/flutter.tar.xz "https://storage.googleapis.com/flutter_infra_release/releases/stable/linux/flutter_linux_${FLUTTER_VERSION}-stable.tar.xz"
-            tar -C "$HOME" -xf /tmp/flutter.tar.xz
+      #            tar -C "$HOME" -xf /tmp/flutter.tar.xz
-          fi
+      #          fi
-          echo "$FLUTTER_HOME/bin" >> "$GITHUB_PATH"
+      #          echo "$FLUTTER_HOME/bin" >> "$GITHUB_PATH"
-          "$FLUTTER_HOME/bin/flutter" --version
+      #          "$FLUTTER_HOME/bin/flutter" --version
 
       - name: Allow all git directories (CI)
         run: git config --global --add safe.directory '*'
@@ -221,36 +222,12 @@ jobs:
 
   linux-build:
     runs-on:
-      - mileograph
+      - tgj-arc
     needs: meta
     steps:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Install OS deps (Linux desktop)
-        run: |
-          if command -v sudo >/dev/null 2>&1; then
-            SUDO="sudo"
-          else
-            SUDO=""
-          fi
-          $SUDO apt-get update
-          $SUDO apt-get install -y unzip xz-utils zip libstdc++6 libglu1-mesa clang cmake ninja-build pkg-config libgtk-3-dev libsecret-1-dev liblzma-dev curl jq
-
-      - name: Install Flutter SDK
-        run: |
-          set -euo pipefail
-          FLUTTER_HOME="$HOME/flutter"
-          # Avoid git ownership issues when Flutter checks out deps.
-          git config --global --add safe.directory "$FLUTTER_HOME" || true
-          if [ ! -x "$FLUTTER_HOME/bin/flutter" ]; then
-            rm -rf "$FLUTTER_HOME"
-            curl -fsSL -o /tmp/flutter.tar.xz "https://storage.googleapis.com/flutter_infra_release/releases/stable/linux/flutter_linux_${FLUTTER_VERSION}-stable.tar.xz"
-            tar -C "$HOME" -xf /tmp/flutter.tar.xz
-          fi
-          echo "$FLUTTER_HOME/bin" >> "$GITHUB_PATH"
-          "$FLUTTER_HOME/bin/flutter" --version
-
       - name: Allow all git directories (CI)
         run: git config --global --add safe.directory '*'
 
@@ -276,38 +253,12 @@ jobs:
 
   web-build:
     runs-on:
-      - mileograph
+      - tgj-arc
     needs: meta
     steps:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Install OS deps (Web)
-        run: |
-          if command -v sudo >/dev/null 2>&1; then
-            SUDO="sudo"
-          else
-            SUDO=""
-          fi
-          $SUDO apt-get update
-          $SUDO apt-get install -y unzip xz-utils zip libstdc++6 liblzma-dev curl jq docker.io
-          if ! docker info >/dev/null 2>&1; then
-            $SUDO systemctl start docker 2>/dev/null || $SUDO service docker start 2>/dev/null || true
-          fi
-
-      - name: Install Flutter SDK
-        run: |
-          set -euo pipefail
-          FLUTTER_HOME="$HOME/flutter"
-          git config --global --add safe.directory "$FLUTTER_HOME" || true
-          if [ ! -x "$FLUTTER_HOME/bin/flutter" ]; then
-            rm -rf "$FLUTTER_HOME"
-            curl -fsSL -o /tmp/flutter.tar.xz "https://storage.googleapis.com/flutter_infra_release/releases/stable/linux/flutter_linux_${FLUTTER_VERSION}-stable.tar.xz"
-            tar -C "$HOME" -xf /tmp/flutter.tar.xz
-          fi
-          echo "$FLUTTER_HOME/bin" >> "$GITHUB_PATH"
-          "$FLUTTER_HOME/bin/flutter" --version
-
       - name: Allow all git directories (CI)
         run: git config --global --add safe.directory '*'
 
@@ -331,50 +282,38 @@ jobs:
           name: web-build
           path: app-web.tar.gz
 
-      - name: Compute web image tags
+      - name: Set up docker buildx
-        id: web_meta
+        uses: docker/setup-buildx-action@v3
-        env:
-          BASE_VERSION: ${{ needs.meta.outputs.base_version }}
-          DEV_SUFFIX: ${{ needs.meta.outputs.dev_suffix }}
-        run: |
-          IMAGE="${WEB_IMAGE}"
-          TAG=""
-          ALIAS=""
-          if [ "${GITHUB_REF}" = "refs/heads/dev" ]; then
-            TAG="${BASE_VERSION}${DEV_SUFFIX}"
-            ALIAS="dev"
-          elif [ "${GITHUB_REF}" = "refs/heads/master" ]; then
-            TAG="${BASE_VERSION}"
-            ALIAS="latest"
-          fi
 
-          echo "image=${IMAGE}" >> "$GITHUB_OUTPUT"
+      - name: Docker meta
-          echo "tag=${TAG}" >> "$GITHUB_OUTPUT"
+        id: dmeta
-          echo "alias=${ALIAS}" >> "$GITHUB_OUTPUT"
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/petegregoryy/railframe-web
+          flavor: latest=false
+          tags: |
+            type=sha,prefix=
+            type=raw,value=${{ needs.meta.outputs.base_version }}${{ needs.meta.outputs.dev_suffix }}
+            type=raw,value=dev
 
-      - name: Login to registry
+      - name: Login to the docker registry
-        if: ${{ secrets.DOCKERHUB_TOKEN != '' && steps.web_meta.outputs.tag != '' }}
+        uses: docker/login-action@v3
-        env:
+        with:
-          REGISTRY_TOKEN: ${{ secrets.DOCKERHUB_TOKEN }}
+          registry: ${{ env.REGISTRY }}
-        run: |
+          username: petegregoryy
-          echo "$REGISTRY_TOKEN" | docker login git.tgj.services -u petegregoryy --password-stdin
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
 
-      - name: Build and push web image
+      - name: Build and push
-        if: ${{ secrets.DOCKERHUB_TOKEN != '' && steps.web_meta.outputs.tag != '' }}
+        id: docker_build
-        env:
+        uses: docker/build-push-action@v6
-          IMAGE: ${{ steps.web_meta.outputs.image }}
+        with:
-          TAG: ${{ steps.web_meta.outputs.tag }}
+          file: Dockerfile.web
-          ALIAS: ${{ steps.web_meta.outputs.alias }}
+          context: .
-        run: |
+          push: true
-          docker buildx create --name buildx --driver=docker-container --use || docker buildx use buildx
+          tags: ${{ steps.dmeta.outputs.tags }}
-          TAG_ARGS=(-t "${IMAGE}:${TAG}")
+          labels: ${{ steps.dmeta.outputs.labels }}
-          if [ -n "$ALIAS" ]; then
+          cache-from: type=registry,ref=${{ env.REGISTRY }}/petegregoryy/railframe-web:buildcache
-            TAG_ARGS+=(-t "${IMAGE}:${ALIAS}")
+          cache-to: type=registry,ref=${{ env.REGISTRY }}/petegregoryy/railframe-web:buildcache,mode=max
-          fi
-          docker buildx build --builder buildx --platform linux/amd64 \
-            -f Dockerfile.web \
-            --push \
-            "${TAG_ARGS[@]}" .
 
   release-dev:
     runs-on:

README.md

@@ -2,6 +2,7 @@
 
 Mileograph is a Flutter client for logging and analysing railway journeys. It lets you record legs, group them into trips, track locomotive mileage, and view stats and leaderboards.
 
+
 ## Features
 - Add and edit journey legs with traction, timings, routes, notes, and delays.
 - Group legs into trips and see mileage totals and traction stats.
@@ -40,6 +41,12 @@ Mileograph is a Flutter client for logging and analysing railway journeys. It le
   ```bash
   flutter build apk --release
   ```
+- Web (release + CanvasKit renderer for best performance/icons):  
+  ```bash
+  flutter build web --release --web-renderer canvaskit --tree-shake-icons
+  # or for local profiling:
+  flutter run -d chrome --profile --web-renderer canvaskit
+  ```
 
 ## Testing and linting
 - Static analysis: `flutter analyze`

lib/app.dart

@@ -2,8 +2,10 @@ import 'package:flutter/material.dart';
 import 'package:mileograph_flutter/services/api_service.dart';
 import 'package:mileograph_flutter/services/authservice.dart';
 import 'package:mileograph_flutter/services/data_service.dart';
+import 'package:mileograph_flutter/services/accent_color_service.dart';
 import 'package:mileograph_flutter/services/distance_unit_service.dart';
 import 'package:mileograph_flutter/services/endpoint_service.dart';
+import 'package:mileograph_flutter/services/theme_mode_service.dart';
 import 'package:mileograph_flutter/ui/app_shell.dart';
 import 'package:provider/provider.dart';
 
@@ -17,9 +19,15 @@ class App extends StatelessWidget {
         ChangeNotifierProvider<EndpointService>(
           create: (_) => EndpointService(),
         ),
+        ChangeNotifierProvider<AccentColorService>(
+          create: (_) => AccentColorService(),
+        ),
         ChangeNotifierProvider<DistanceUnitService>(
           create: (_) => DistanceUnitService(),
         ),
+        ChangeNotifierProvider<ThemeModeService>(
+          create: (_) => ThemeModeService(),
+        ),
         ProxyProvider<EndpointService, ApiService>(
           update: (_, endpoint, api) {
             final service = api ?? ApiService(baseUrl: endpoint.baseUrl);
@@ -35,7 +43,11 @@ class App extends StatelessWidget {
           create: (context) => DataService(api: context.read<ApiService>()),
           update: (context, auth, data) {
             data ??= DataService(api: context.read<ApiService>());
-            data.handleAuthChanged(auth.userId);
+            data.handleAuthChanged(
+              auth.userId,
+              entriesVisibility: auth.entriesVisibility,
+              mileageVisibility: auth.mileageVisibility,
+            );
             return data;
           },
         ),

lib/components/calculator/calculator.dart

@@ -55,26 +55,19 @@ class _StationAutocompleteState extends State<StationAutocomplete> {
       },
       fieldViewBuilder:
           (context, textEditingController, focusNode, onFieldSubmitted) {
-            textEditingController.value = _controller.value;
+        textEditingController.value = _controller.value;
 
-            return TextField(
+        return TextField(
-              controller: textEditingController,
+          controller: textEditingController,
-              focusNode: focusNode,
+          focusNode: focusNode,
-              textInputAction: TextInputAction.done,
+          textInputAction: TextInputAction.done,
-              onSubmitted: (_) {
+          onSubmitted: (_) => onFieldSubmitted(),
-                final matches = _findTopMatches(textEditingController.text);
+          decoration: const InputDecoration(
-                final firstMatch = matches.isEmpty ? null : matches.first;
+            labelText: 'Select station',
-                if (firstMatch == null) return;
+            border: OutlineInputBorder(),
-                _controller.text = firstMatch;
+          ),
-                widget.onChanged(firstMatch);
+        );
-                focusNode.unfocus(); // optionally close keyboard
+      },
-              },
-              decoration: const InputDecoration(
-                labelText: 'Select station',
-                border: OutlineInputBorder(),
-              ),
-            );
-          },
     );
   }
 
@@ -140,6 +133,7 @@ class _RouteCalculatorState extends State<RouteCalculator> {
   bool _loadingStations = false;
 
   RouteResult? _routeResult;
+  List<String>? _calculatedStations;
   RouteResult? get result => _routeResult;
   String? _errorMessage;
 
@@ -181,19 +175,30 @@ class _RouteCalculatorState extends State<RouteCalculator> {
   }
 
   Future<void> _calculateRoute(List<String> stations) async {
+    final cleaned = stations.where((s) => s.trim().isNotEmpty).toList();
+    if (cleaned.length < 2) {
+      setState(() {
+        _routeResult = null;
+        _calculatedStations = null;
+        _errorMessage = 'Add at least two stations before calculating.';
+      });
+      return;
+    }
     setState(() {
       _errorMessage = null;
       _routeResult = null;
+      _calculatedStations = null;
     });
     final api = context.read<ApiService>(); // context is valid here
     try {
       final res = await api.post('/route/distance2', {
-        'route': stations.where((s) => s.trim().isNotEmpty).toList(),
+        'route': cleaned,
       });
 
       if (res is Map && res['error'] == false) {
         setState(() {
           _routeResult = RouteResult.fromJson(Map<String, dynamic>.from(res));
+          _calculatedStations = List.from(cleaned);
         });
         final distance = (_routeResult?.distance ?? 0);
         widget.onDistanceComputed?.call(distance);
@@ -204,17 +209,30 @@ class _RouteCalculatorState extends State<RouteCalculator> {
           ).msg;
         });
       } else {
-        setState(() => _errorMessage = 'Failed to calculate route.');
+        setState(() {
+          _errorMessage = 'Failed to calculate route.';
+          _calculatedStations = null;
+        });
       }
     } catch (e) {
-      setState(() => _errorMessage = 'Failed to calculate route: $e');
+      setState(() {
+        _errorMessage = 'Failed to calculate route: $e';
+        _calculatedStations = null;
+      });
     }
   }
 
+  void _markRouteDirty() {
+    _routeResult = null;
+    _calculatedStations = null;
+    _errorMessage = null;
+  }
+
   void _addStation() {
     final data = context.read<DataService>();
     setState(() {
       data.stations.add('');
+      _markRouteDirty();
     });
   }
 
@@ -222,6 +240,7 @@ class _RouteCalculatorState extends State<RouteCalculator> {
     final data = context.read<DataService>();
     setState(() {
       data.stations.removeAt(index);
+      _markRouteDirty();
     });
   }
 
@@ -229,14 +248,109 @@ class _RouteCalculatorState extends State<RouteCalculator> {
     final data = context.read<DataService>();
     setState(() {
       data.stations[index] = value;
+      _markRouteDirty();
     });
   }
 
+  void _clearCalculator() {
+    final data = context.read<DataService>();
+    setState(() {
+      data.stations = [''];
+      _markRouteDirty();
+    });
+  }
+
+  bool _isResultCurrent(List<String> stations) {
+    if (_routeResult == null || _calculatedStations == null) return false;
+    final cleaned = stations.where((s) => s.trim().isNotEmpty).toList();
+    if (cleaned.length != _calculatedStations!.length) return false;
+    for (var i = 0; i < cleaned.length; i++) {
+      if (cleaned[i] != _calculatedStations![i]) return false;
+    }
+    return true;
+  }
+
   @override
   Widget build(BuildContext context) {
     final data = context.watch<DataService>();
+    final isCompact = MediaQuery.of(context).size.width < 600;
+    final showApply =
+        widget.onApplyRoute != null && _isResultCurrent(data.stations);
+    final primaryPadding = EdgeInsets.symmetric(
+      horizontal: isCompact ? 14 : 20,
+      vertical: isCompact ? 10 : 14,
+    );
+    final secondaryPadding = EdgeInsets.symmetric(
+      horizontal: isCompact ? 10 : 16,
+      vertical: isCompact ? 8 : 12,
+    );
+    final primaryStyle = FilledButton.styleFrom(
+      padding: primaryPadding,
+      minimumSize: Size(0, isCompact ? 38 : 46),
+    );
+    final secondaryStyle = OutlinedButton.styleFrom(
+      padding: secondaryPadding,
+      minimumSize: Size(0, isCompact ? 34 : 42),
+    );
+
+    Widget buildSecondaryButton({
+      required IconData icon,
+      required String label,
+      required VoidCallback onPressed,
+    }) {
+      if (isCompact) {
+        return Tooltip(
+          message: label,
+          child: OutlinedButton(
+            onPressed: onPressed,
+            style: secondaryStyle,
+            child: Icon(icon, size: 20),
+          ),
+        );
+      }
+      return OutlinedButton.icon(
+        onPressed: onPressed,
+        icon: Icon(icon, size: 20),
+        label: Text(label),
+        style: secondaryStyle,
+      );
+    }
+
+    Widget buildPrimaryAction({required bool fullWidth}) {
+      final button = showApply
+          ? FilledButton.icon(
+              onPressed: () => widget.onApplyRoute!(_routeResult!),
+              icon: const Icon(Icons.check),
+              label: const Text('Apply to entry'),
+              style: primaryStyle,
+            )
+          : FilledButton.icon(
+              onPressed: () async {
+                await _calculateRoute(data.stations);
+              },
+              icon: const Icon(Icons.route),
+              label: const Text('Calculate Route'),
+              style: primaryStyle,
+            );
+      final key =
+          ValueKey<String>(showApply ? 'apply-primary-action' : 'calc-primary-action');
+      if (!fullWidth) return KeyedSubtree(key: key, child: button);
+      return KeyedSubtree(
+        key: key,
+        child: SizedBox(width: double.infinity, child: button),
+      );
+    }
+
     return Column(
       children: [
+        Align(
+          alignment: Alignment.centerRight,
+          child: IconButton(
+            tooltip: 'Clear calculator',
+            icon: const Icon(Icons.clear_all),
+            onPressed: _clearCalculator,
+          ),
+        ),
         Padding(
           padding: const EdgeInsets.symmetric(horizontal: 16.0, vertical: 8),
           child: Wrap(
@@ -283,6 +397,7 @@ class _RouteCalculatorState extends State<RouteCalculator> {
               setState(() {
                 final moved = data.stations.removeAt(oldIndex);
                 data.stations.insert(newIndex, moved);
+                _markRouteDirty();
               });
             },
             children: List.generate(data.stations.length, (index) {
@@ -346,40 +461,94 @@ class _RouteCalculatorState extends State<RouteCalculator> {
               context.push('/calculator/details', extra: result);
             },
           ),
-          if (widget.onApplyRoute != null)
-            Padding(
-              padding: const EdgeInsets.symmetric(horizontal: 16.0),
-              child: ElevatedButton.icon(
-                onPressed: () => widget.onApplyRoute!(_routeResult!),
-                icon: const Icon(Icons.check),
-                label: const Text('Apply to entry'),
-              ),
-            ),
         ]
         else
           SizedBox.shrink(),
         const SizedBox(height: 10),
         Padding(
           padding: const EdgeInsets.symmetric(horizontal: 16.0),
-          child: Wrap(
+          child: isCompact
-            alignment: WrapAlignment.center,
+              ? Column(
-            spacing: 12,
+                  children: [
-            runSpacing: 8,
+                    Row(
-            children: [
+                      mainAxisAlignment: MainAxisAlignment.center,
-              ElevatedButton.icon(
+                      children: [
-                icon: const Icon(Icons.add),
+                        buildSecondaryButton(
-                label: const Text('Add Station'),
+                          icon: Icons.swap_horiz,
-                onPressed: _addStation,
+                          label: 'Reverse route',
-              ),
+                          onPressed: () async {
-              ElevatedButton.icon(
+                            setState(() {
-                icon: const Icon(Icons.route),
+                              data.stations = data.stations.reversed.toList();
-                label: const Text('Calculate Route'),
+                            });
-                onPressed: () async {
+                            await _calculateRoute(data.stations);
-                  await _calculateRoute(data.stations);
+                          },
-                },
+                        ),
-              ),
+                        const SizedBox(width: 12),
-            ],
+                        buildSecondaryButton(
-          ),
+                          icon: Icons.add,
+                          label: 'Add station',
+                          onPressed: _addStation,
+                        ),
+                      ],
+                    ),
+                    const SizedBox(height: 10),
+                    SizedBox(
+                      width: double.infinity,
+                      child: AnimatedSwitcher(
+                        duration: const Duration(milliseconds: 220),
+                        transitionBuilder: (child, animation) {
+                          final curved = CurvedAnimation(
+                            parent: animation,
+                            curve: Curves.easeOutBack,
+                          );
+                          return ScaleTransition(
+                            scale:
+                                Tween<double>(begin: 0.94, end: 1.0).animate(curved),
+                            child: FadeTransition(opacity: animation, child: child),
+                          );
+                        },
+                      child: buildPrimaryAction(fullWidth: true),
+                    ),
+                  ),
+                ],
+                )
+              : Wrap(
+                  alignment: WrapAlignment.center,
+                  spacing: 12,
+                  runSpacing: 8,
+                  children: [
+                    buildSecondaryButton(
+                      icon: Icons.swap_horiz,
+                      label: 'Reverse route',
+                      onPressed: () async {
+                        setState(() {
+                          data.stations = data.stations.reversed.toList();
+                        });
+                        await _calculateRoute(data.stations);
+                      },
+                    ),
+                    AnimatedSwitcher(
+                      duration: const Duration(milliseconds: 220),
+                      transitionBuilder: (child, animation) {
+                        final curved = CurvedAnimation(
+                          parent: animation,
+                          curve: Curves.easeOutBack,
+                        );
+                        return ScaleTransition(
+                          scale:
+                              Tween<double>(begin: 0.94, end: 1.0).animate(curved),
+                          child: FadeTransition(opacity: animation, child: child),
+                        );
+                      },
+                      child: buildPrimaryAction(fullWidth: false),
+                    ),
+                    buildSecondaryButton(
+                      icon: Icons.add,
+                      label: 'Add station',
+                      onPressed: _addStation,
+                    ),
+                  ],
+                ),
         ),
 
         const SizedBox(height: 16),

lib/components/dashboard/leaderboard_panel.dart

@@ -1,19 +1,33 @@
 import 'package:flutter/material.dart';
+import 'package:go_router/go_router.dart';
+import 'package:mileograph_flutter/services/authservice.dart';
 import 'package:mileograph_flutter/services/data_service.dart';
 import 'package:mileograph_flutter/services/distance_unit_service.dart';
-
 import 'package:provider/provider.dart';
+enum _LeaderboardScope { global, friends }
 
-class LeaderboardPanel extends StatelessWidget {
+class LeaderboardPanel extends StatefulWidget {
   const LeaderboardPanel({super.key});
 
+  @override
+  State<LeaderboardPanel> createState() => _LeaderboardPanelState();
+}
+
+class _LeaderboardPanelState extends State<LeaderboardPanel> {
+  _LeaderboardScope _scope = _LeaderboardScope.global;
+
   @override
   Widget build(BuildContext context) {
     final data = context.watch<DataService>();
     final distanceUnits = context.watch<DistanceUnitService>();
-    final leaderboard = data.homepageStats?.leaderboard ?? [];
+    final leaderboard = _scope == _LeaderboardScope.global
+        ? (data.homepageStats?.leaderboard ?? [])
+        : data.friendsLeaderboard;
+    final loading = _scope == _LeaderboardScope.global
+        ? data.isHomepageLoading
+        : data.isFriendsLeaderboardLoading;
     final textTheme = Theme.of(context).textTheme;
-    if (data.isHomepageLoading && leaderboard.isEmpty) {
+    if (loading && leaderboard.isEmpty) {
       return const Padding(
         padding: EdgeInsets.all(16.0),
         child: Center(child: CircularProgressIndicator()),
@@ -38,7 +52,8 @@ class LeaderboardPanel extends StatelessWidget {
                     ),
                   ),
                 ),
-                if (leaderboard.isNotEmpty)
+                if (leaderboard.isNotEmpty &&
+                    MediaQuery.of(context).size.width > 600)
                   Container(
                     padding:
                         const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
@@ -54,6 +69,40 @@ class LeaderboardPanel extends StatelessWidget {
               ],
             ),
             const SizedBox(height: 8),
+            Center(
+              child: SegmentedButton<_LeaderboardScope>(
+                segments: const [
+                  ButtonSegment(
+                    value: _LeaderboardScope.global,
+                    label: Text('Global'),
+                  ),
+                  ButtonSegment(
+                    value: _LeaderboardScope.friends,
+                    label: Text('Friends'),
+                  ),
+                ],
+                selected: {_scope},
+                onSelectionChanged: (vals) async {
+                  if (vals.isEmpty) return;
+                  final selected = vals.first;
+                  setState(() => _scope = selected);
+                  if (selected == _LeaderboardScope.friends &&
+                      data.friendsLeaderboard.isEmpty &&
+                      !data.isFriendsLeaderboardLoading) {
+                    await data.fetchFriendsLeaderboard();
+                  } else if (selected == _LeaderboardScope.global &&
+                      (data.homepageStats?.leaderboard.isEmpty ?? true) &&
+                      !data.isHomepageLoading) {
+                    await data.fetchHomepageStats();
+                  }
+                },
+                style: SegmentedButton.styleFrom(
+                  visualDensity: VisualDensity.compact,
+                  padding: const EdgeInsets.symmetric(horizontal: 8),
+                ),
+              ),
+            ),
+            const SizedBox(height: 8),
             if (leaderboard.isEmpty)
               const Padding(
                 padding: EdgeInsets.all(8.0),
@@ -83,14 +132,38 @@ class LeaderboardPanel extends StatelessWidget {
                           fontWeight: FontWeight.w700,
                         ),
                       ),
-                      trailing: Text(
+                      trailing: Wrap(
-                        distanceUnits.format(
+                        crossAxisAlignment: WrapCrossAlignment.center,
-                          leaderboard[index].mileage,
+                        spacing: 8,
-                          decimals: 1,
+                        children: [
-                        ),
+                          Text(
-                        style: textTheme.labelLarge?.copyWith(
+                            distanceUnits.format(
-                          fontWeight: FontWeight.w700,
+                              leaderboard[index].mileage,
-                        ),
+                              decimals: 1,
+                            ),
+                            style: textTheme.labelLarge?.copyWith(
+                              fontWeight: FontWeight.w700,
+                            ),
+                          ),
+                          Builder(
+                            builder: (ctx) => IconButton(
+                              tooltip: 'View profile',
+                              icon: const Icon(Icons.open_in_new, size: 20),
+                              onPressed: () {
+                                final auth = ctx.read<AuthService>();
+                                final userId = leaderboard[index].userId;
+                                if (auth.userId == userId) {
+                                  ctx.go('/more/profile');
+                                } else {
+                                  ctx.pushNamed(
+                                    'user-profile',
+                                    queryParameters: {'user_id': userId},
+                                  );
+                                }
+                              },
+                            ),
+                          ),
+                        ],
                       ),
                     ),
                     if (index != leaderboard.length - 1) const Divider(height: 12),

lib/components/legs/leg_card.dart

@@ -28,6 +28,8 @@ class _LegCardState extends State<LegCard> {
   Widget build(BuildContext context) {
     final leg = widget.leg;
     final isShared = leg.legShareId != null && leg.legShareId!.isNotEmpty;
+    final sharedFrom = leg.sharedFrom;
+    final sharedTo = leg.sharedTo;
     final distanceUnits = context.watch<DistanceUnitService>();
     final routeSegments = _parseRouteSegments(leg.route);
     final textTheme = Theme.of(context).textTheme;
@@ -198,16 +200,9 @@ class _LegCardState extends State<LegCard> {
                 ],
               ],
             ),
-            if (isShared) ...[
+            if (isShared || sharedFrom != null || (sharedTo.isNotEmpty)) ...[
               const SizedBox(width: 8),
-              Tooltip(
+              _SharedIcons(sharedFrom: sharedFrom, sharedTo: sharedTo, isShared: isShared),
-                message: 'Shared entry',
-                child: Icon(
-                  Icons.share,
-                  size: 18,
-                  color: Theme.of(context).colorScheme.primary,
-                ),
-              ),
             ],
             if (widget.showEditButton) ...[
               const SizedBox(width: 8),
@@ -239,34 +234,62 @@ class _LegCardState extends State<LegCard> {
               padding: const EdgeInsets.fromLTRB(16, 0, 16, 12),
               child: Column(
                 crossAxisAlignment: CrossAxisAlignment.start,
-                children: [
+              children: [
-                  if (leg.notes.isNotEmpty) ...[
+                if (leg.notes.isNotEmpty) ...[
-                    Text('Notes', style: textTheme.titleSmall),
+                  Text('Notes', style: textTheme.titleSmall),
-                    const SizedBox(height: 4),
+                  const SizedBox(height: 4),
-                    Text(leg.notes),
+                  Text(leg.notes),
-                    const SizedBox(height: 12),
+                  const SizedBox(height: 12),
-                  ],
+                ],
-                  if (leg.locos.isNotEmpty) ...[
+                if (leg.locos.isNotEmpty) ...[
-                    Text('Locos', style: textTheme.titleSmall),
+                  Text('Locos', style: textTheme.titleSmall),
-                    const SizedBox(height: 6),
+                  const SizedBox(height: 6),
-                    Wrap(
+                  Wrap(
-                      spacing: 8,
+                    spacing: 8,
                       runSpacing: 8,
                       children: _buildLocoChips(context, leg),
                     ),
                     const SizedBox(height: 12),
                   ],
-                  if (_hasTrainDetails(leg)) ...[
+                if (_hasTrainDetails(leg)) ...[
-                    Text('Train', style: textTheme.titleSmall),
+                  Text('Train', style: textTheme.titleSmall),
-                    const SizedBox(height: 6),
+                  const SizedBox(height: 6),
-                    ..._buildTrainDetails(leg, textTheme),
+                  ..._buildTrainDetails(leg, textTheme),
-                    const SizedBox(height: 12),
+                  const SizedBox(height: 12),
-                  ],
+                ],
-                  if (routeSegments.isNotEmpty) ...[
+                if (sharedFrom != null)
-                    Text('Route', style: textTheme.titleSmall),
+                  Padding(
-                    const SizedBox(height: 6),
+                    padding: const EdgeInsets.only(bottom: 8.0),
-                    _buildRouteList(routeSegments),
+                    child: Text(
-                  ],
+                      'Shared from ${sharedFrom.sharedFromDisplay.isNotEmpty ? sharedFrom.sharedFromDisplay : 'another user'}.',
+                      style: textTheme.bodyMedium,
+                    ),
+                  ),
+                if (sharedTo.isNotEmpty) ...[
+                  Text(
+                    'Shared to:',
+                    style: textTheme.bodyMedium,
+                  ),
+                  const SizedBox(height: 4),
+                  Wrap(
+                    spacing: 8,
+                    runSpacing: 4,
+                    children: sharedTo
+                        .map((s) => Chip(
+                              label: Text(s.sharedToDisplay.isNotEmpty
+                                  ? s.sharedToDisplay
+                                  : s.sharedToUserId),
+                              visualDensity: VisualDensity.compact,
+                            ))
+                        .toList(),
+                  ),
+                  const SizedBox(height: 12),
+                ],
+                if (routeSegments.isNotEmpty) ...[
+                  Text('Route', style: textTheme.titleSmall),
+                  const SizedBox(height: 6),
+                  _buildRouteList(routeSegments),
+                ],
                 ],
               ),
             ),
@@ -461,3 +484,61 @@ class _LegCardState extends State<LegCard> {
     return route.map((e) => e.toString()).where((e) => e.trim().isNotEmpty).toList();
   }
 }
+
+class _SharedIcons extends StatelessWidget {
+  const _SharedIcons({
+    required this.sharedFrom,
+    required this.sharedTo,
+    required this.isShared,
+  });
+
+  final LegShareMeta? sharedFrom;
+  final List<LegShareMeta> sharedTo;
+  final bool isShared;
+
+  @override
+  Widget build(BuildContext context) {
+    final icons = <Widget>[];
+    if (isShared || sharedFrom != null) {
+      final fromName = sharedFrom?.sharedFromDisplay ?? '';
+      icons.add(
+        Tooltip(
+          message: fromName.isNotEmpty ? 'Shared from $fromName' : 'Shared entry',
+          child: Icon(
+            Icons.share,
+            size: 18,
+            color: Theme.of(context).colorScheme.primary,
+          ),
+        ),
+      );
+    }
+    if (sharedTo.isNotEmpty) {
+      final names = sharedTo
+          .map((s) => s.sharedToDisplay)
+          .where((name) => name.isNotEmpty)
+          .toList();
+      final tooltip = names.isEmpty
+          ? 'Shared to others'
+          : 'Shared to: ${names.join(', ')}';
+      icons.add(
+        Tooltip(
+          message: tooltip,
+          child: Icon(
+            Icons.group,
+            size: 18,
+            color: Theme.of(context).colorScheme.tertiary,
+          ),
+        ),
+      );
+    }
+    return Row(
+      mainAxisSize: MainAxisSize.min,
+      children: [
+        for (int i = 0; i < icons.length; i++) ...[
+          if (i > 0) const SizedBox(width: 6),
+          icons[i],
+        ],
+      ],
+    );
+  }
+}

lib/components/pages/badges.dart

@@ -62,7 +62,7 @@ class _BadgesPageState extends State<BadgesPage> {
             if (navigator.canPop()) {
               navigator.pop();
             } else {
-              context.go('/');
+              context.go('/more');
             }
           },
         ),

lib/components/pages/legs.dart

@@ -17,6 +17,8 @@ class _LegsPageState extends State<LegsPage> {
   DateTime? _startDate;
   DateTime? _endDate;
   bool _initialised = false;
+  bool _unallocatedOnly = false;
+  bool _showMoreFilters = false;
 
   @override
   void didChangeDependencies() {
@@ -33,6 +35,7 @@ class _LegsPageState extends State<LegsPage> {
       sortDirection: _sortDirection,
       dateRangeStart: _formatDate(_startDate),
       dateRangeEnd: _formatDate(_endDate),
+      unallocatedOnly: _unallocatedOnly,
     );
   }
 
@@ -44,6 +47,7 @@ class _LegsPageState extends State<LegsPage> {
       dateRangeEnd: _formatDate(_endDate),
       offset: data.legs.length,
       append: true,
+      unallocatedOnly: _unallocatedOnly,
     );
   }
 
@@ -84,6 +88,8 @@ class _LegsPageState extends State<LegsPage> {
       _startDate = null;
       _endDate = null;
       _sortDirection = 0;
+      _unallocatedOnly = false;
+      _showMoreFilters = false;
     });
     _refreshLegs();
   }
@@ -177,8 +183,46 @@ class _LegsPageState extends State<LegsPage> {
                               : _formatDate(_endDate!)!,
                         ),
                       ),
+                      TextButton.icon(
+                        onPressed: () => setState(
+                          () => _showMoreFilters = !_showMoreFilters,
+                        ),
+                        icon: Icon(
+                          _showMoreFilters
+                              ? Icons.expand_less
+                              : Icons.expand_more,
+                        ),
+                        label: Text(
+                          _showMoreFilters ? 'Hide filters' : 'More filters',
+                        ),
+                      ),
                     ],
                   ),
+                  AnimatedCrossFade(
+                    crossFadeState: _showMoreFilters
+                        ? CrossFadeState.showFirst
+                        : CrossFadeState.showSecond,
+                    duration: const Duration(milliseconds: 200),
+                    firstChild: Padding(
+                      padding: const EdgeInsets.only(top: 12.0),
+                      child: Wrap(
+                        spacing: 12,
+                        runSpacing: 12,
+                        children: [
+                          FilterChip(
+                            avatar: const Icon(Icons.flash_off),
+                            label: const Text('Unallocated only'),
+                            selected: _unallocatedOnly,
+                            onSelected: (selected) async {
+                              setState(() => _unallocatedOnly = selected);
+                              await _refreshLegs();
+                            },
+                          ),
+                        ],
+                      ),
+                    ),
+                    secondChild: const SizedBox.shrink(),
+                  ),
                 ],
               ),
             ),

lib/components/pages/loco_timeline.dart

@@ -5,8 +5,10 @@ import 'package:flutter/foundation.dart';
 import 'package:flutter/services.dart';
 import 'package:intl/intl.dart';
 import 'package:mileograph_flutter/objects/objects.dart';
+import 'package:mileograph_flutter/services/authservice.dart';
 import 'package:mileograph_flutter/services/data_service.dart';
 import 'package:provider/provider.dart';
+import 'package:shared_preferences/shared_preferences.dart';
 
 part 'loco_timeline/timeline_grid.dart';
 part 'loco_timeline/event_editor.dart';
@@ -26,14 +28,23 @@ class LocoTimelinePage extends StatefulWidget {
 }
 
 class _LocoTimelinePageState extends State<LocoTimelinePage> {
+  static const String _prefsKeyShowPending = 'timeline_show_pending';
+
   final List<_EventDraft> _draftEvents = [];
   bool _isSaving = false;
   bool _isDeleting = false;
+  final Set<int> _moderatingEventIds = {};
+  final Set<String> _expandedPendingAttrs = {};
+  bool _showPending = true;
 
   @override
   void initState() {
     super.initState();
-    WidgetsBinding.instance.addPostFrameCallback((_) => _load());
+    WidgetsBinding.instance.addPostFrameCallback((_) async {
+      await _restorePendingVisibility();
+      if (!mounted) return;
+      await _load();
+    });
   }
 
   dynamic _normalizeFieldValue(_FieldEntry field) {
@@ -59,8 +70,37 @@ class _LocoTimelinePageState extends State<LocoTimelinePage> {
 
   Future<void> _load() {
     final data = context.read<DataService>();
+    final auth = context.read<AuthService>();
     data.fetchEventFields();
-    return data.fetchLocoTimeline(widget.locoId);
+    return data.fetchLocoTimeline(
+      widget.locoId,
+      includeAllPending: auth.isElevated && _showPending,
+    );
+  }
+
+  Future<void> _restorePendingVisibility() async {
+    final auth = context.read<AuthService>();
+    if (!auth.isElevated) return;
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      final saved = prefs.getBool(_prefsKeyShowPending);
+      if (saved == null) return;
+      if (!mounted) return;
+      setState(() {
+        _showPending = saved;
+      });
+    } catch (_) {
+      // Ignore preference restore failures.
+    }
+  }
+
+  Future<void> _persistPendingVisibility(bool value) async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      await prefs.setBool(_prefsKeyShowPending, value);
+    } catch (_) {
+      // Ignore persistence failures.
+    }
   }
 
   void _addDraftEvent() {
@@ -151,8 +191,18 @@ class _LocoTimelinePageState extends State<LocoTimelinePage> {
 
   Future<void> _deleteEntry(LocoAttrVersion entry) async {
     if (_isDeleting) return;
+    final isPending = entry.isPending;
     final blockId = entry.versionId;
-    if (blockId == null) {
+    final pendingEventId = entry.sourceEventId;
+    if (isPending && pendingEventId == null) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        const SnackBar(
+          content: Text('Cannot delete: pending timeline block has no event ID.'),
+        ),
+      );
+      return;
+    }
+    if (!isPending && blockId == null) {
       ScaffoldMessenger.of(context).showSnackBar(
         const SnackBar(content: Text('Cannot delete: timeline block has no ID.')),
       );
@@ -193,13 +243,23 @@ class _LocoTimelinePageState extends State<LocoTimelinePage> {
       _isDeleting = true;
     });
     try {
-      await data.deleteTimelineBlock(
+      if (isPending && pendingEventId != null) {
-        blockId: blockId,
+        await data.deletePendingEvent(eventId: pendingEventId);
-      );
+      } else if (blockId != null) {
+        await data.deleteTimelineBlock(
+          blockId: blockId,
+        );
+      }
       await _load();
       if (mounted) {
         messenger.showSnackBar(
-          const SnackBar(content: Text('Timeline block deleted')),
+          SnackBar(
+            content: Text(
+              isPending
+                  ? 'Pending timeline block deleted'
+                  : 'Timeline block deleted',
+            ),
+          ),
         );
       }
     } catch (e) {
@@ -217,6 +277,79 @@ class _LocoTimelinePageState extends State<LocoTimelinePage> {
     }
   }
 
+  Future<void> _moderatePendingEntry(
+    LocoAttrVersion entry,
+    _PendingModerationAction action,
+  ) async {
+    final eventId = entry.sourceEventId;
+    if (eventId == null) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        const SnackBar(
+          content: Text('Cannot moderate: pending timeline block has no event ID.'),
+        ),
+      );
+      return;
+    }
+    if (_moderatingEventIds.contains(eventId)) return;
+    final data = context.read<DataService>();
+    final approve = action == _PendingModerationAction.approve;
+    final messenger = ScaffoldMessenger.of(context);
+    final verb = approve ? 'approve' : 'reject';
+    final ok = await showDialog<bool>(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: Text('${approve ? 'Approve' : 'Reject'} pending event?'),
+        content: Text(
+          'Are you sure you want to $verb this pending timeline block?',
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(false),
+            child: const Text('Cancel'),
+          ),
+          FilledButton(
+            onPressed: () => Navigator.of(context).pop(true),
+            child: Text(approve ? 'Approve' : 'Reject'),
+          ),
+        ],
+      ),
+    );
+    if (ok != true || !mounted) return;
+
+    setState(() {
+      _moderatingEventIds.add(eventId);
+    });
+    try {
+      if (approve) {
+        await data.approvePendingEvent(eventId: eventId);
+      } else {
+        await data.rejectPendingEvent(eventId: eventId);
+      }
+      await _load();
+      if (mounted) {
+        messenger.showSnackBar(
+          SnackBar(
+            content: Text(
+              'Pending timeline block ${approve ? 'approved' : 'rejected'}.',
+            ),
+          ),
+        );
+      }
+    } catch (e) {
+      if (mounted) {
+        messenger.showSnackBar(
+          SnackBar(content: Text('Failed to $verb pending timeline block: $e')),
+        );
+      }
+    } finally {
+      if (mounted) {
+        setState(() {
+          _moderatingEventIds.remove(eventId);
+        });
+      }
+    }
+  }
+
   void _removeDraftAt(int index) {
     if (index < 0 || index >= _draftEvents.length) return;
     final draft = _draftEvents.removeAt(index);
@@ -248,6 +381,9 @@ class _LocoTimelinePageState extends State<LocoTimelinePage> {
       _isSaving = true;
     });
     try {
+      final existingPending =
+          await data.fetchUserPendingEvents(widget.locoId);
+      final clearedEventIds = <int>{};
       final invalid = <String>[];
       for (final draft in _draftEvents) {
         final dateStr = draft.dateController.text.trim();
@@ -274,6 +410,13 @@ class _LocoTimelinePageState extends State<LocoTimelinePage> {
           invalid.add('Add at least one value');
           continue;
         }
+        await _clearDuplicatePending(
+          existingPending,
+          clearedEventIds,
+          values.keys,
+          dateStr,
+          data,
+        );
         await data.createLocoEvent(
           locoId: widget.locoId,
           eventDate: dateStr,
@@ -312,6 +455,42 @@ class _LocoTimelinePageState extends State<LocoTimelinePage> {
     }
   }
 
+  Future<void> _clearDuplicatePending(
+    List<LocoAttrVersion> existingPending,
+    Set<int> clearedEventIds,
+    Iterable<String> attrs,
+    String dateStr,
+    DataService data,
+  ) async {
+    final trimmedDate = dateStr.trim().toLowerCase();
+    final attrSet = attrs.map((e) => e.toLowerCase()).toSet();
+    for (final pending in existingPending) {
+      final attrMatch = attrSet.contains(pending.attrCode.toLowerCase());
+      if (!attrMatch) continue;
+      final matchesDate = _dateMatchesPending(trimmedDate, pending);
+      if (!matchesDate) continue;
+      final eventId = pending.sourceEventId;
+      if (eventId == null || clearedEventIds.contains(eventId)) continue;
+      await data.deletePendingEvent(eventId: eventId);
+      clearedEventIds.add(eventId);
+    }
+  }
+
+  bool _dateMatchesPending(String draftDateLower, LocoAttrVersion pending) {
+    final masked = pending.maskedValidFrom?.trim().toLowerCase();
+    if (masked != null && masked.isNotEmpty && masked == draftDateLower) {
+      return true;
+    }
+    final draftDate = DateTime.tryParse(draftDateLower);
+    final pendingDate = pending.validFrom;
+    if (draftDate != null && pendingDate != null) {
+      return draftDate.year == pendingDate.year &&
+          draftDate.month == pendingDate.month &&
+          draftDate.day == pendingDate.day;
+    }
+    return false;
+  }
+
   bool _isValidDateString(String input) {
     final trimmed = input.trim();
     final regex = RegExp(r'^\d{4}-(\d{2}|xx|XX)-(\d{2}|xx|XX)$');
@@ -354,7 +533,11 @@ class _LocoTimelinePageState extends State<LocoTimelinePage> {
   Widget build(BuildContext context) {
     final data = context.watch<DataService>();
     final timeline = data.timelineForLoco(widget.locoId);
+    final isElevated = context.select<AuthService, bool>((auth) => auth.isElevated);
     final isLoading = data.isLocoTimelineLoading(widget.locoId);
+    final visibleTimeline = (!isElevated || _showPending)
+        ? timeline
+        : timeline.where((entry) => !entry.isPending).toList();
 
     return Scaffold(
       appBar: AppBar(
@@ -371,7 +554,32 @@ class _LocoTimelinePageState extends State<LocoTimelinePage> {
             if (isLoading && timeline.isEmpty) {
               return const Center(child: CircularProgressIndicator());
             }
-            if (timeline.isEmpty) {
+            if (visibleTimeline.isEmpty) {
+              if (timeline.isNotEmpty && isElevated && !_showPending) {
+                return Padding(
+                  padding: const EdgeInsets.all(16.0),
+                  child: Card(
+                    child: Padding(
+                      padding: const EdgeInsets.all(16.0),
+                      child: Column(
+                        crossAxisAlignment: CrossAxisAlignment.start,
+                        children: [
+                          Text(
+                            'Pending entries hidden',
+                            style: Theme.of(context).textTheme.titleMedium?.copyWith(
+                                  fontWeight: FontWeight.w700,
+                                ),
+                          ),
+                          const SizedBox(height: 8),
+                          const Text(
+                            'Enable "Show pending entries" to view pending timeline blocks.',
+                          ),
+                        ],
+                      ),
+                    ),
+                  ),
+                );
+              }
               return Padding(
                 padding: const EdgeInsets.all(16.0),
                 child: Card(
@@ -405,13 +613,49 @@ class _LocoTimelinePageState extends State<LocoTimelinePage> {
             return ListView(
               padding: const EdgeInsets.all(16),
               children: [
+                if (isElevated)
+                  Row(
+                    children: [
+                      Expanded(
+                        child: SwitchListTile.adaptive(
+                          contentPadding: EdgeInsets.zero,
+                          title: const Text('Show pending entries'),
+                          value: _showPending,
+                          onChanged: (value) async {
+                            setState(() {
+                              _showPending = value;
+                            });
+                            await _persistPendingVisibility(value);
+                            if (mounted) {
+                              await _load();
+                            }
+                          },
+                        ),
+                      ),
+                      IconButton(
+                        tooltip: 'Refresh timeline',
+                        onPressed: _load,
+                        icon: const Icon(Icons.refresh),
+                      ),
+                    ],
+                  ),
                 _TimelineGrid(
-                  entries: timeline,
+                  entries: visibleTimeline,
                   onEditEntry: (entry) => _prefillDraftFromEntry(
                     entry,
                     data.eventFields,
                   ),
                   onDeleteEntry: _deleteEntry,
+                  onModeratePending: _moderatePendingEntry,
+                  pendingActionEventIds: _moderatingEventIds,
+                  expandedPendingAttrs: _expandedPendingAttrs,
+                  onTogglePendingAttr: (attrCode) {
+                    setState(() {
+                      if (!_expandedPendingAttrs.add(attrCode)) {
+                        _expandedPendingAttrs.remove(attrCode);
+                      }
+                    });
+                  },
                 ),
                 const SizedBox(height: 16),
                 _EventEditor(

lib/components/pages/loco_timeline/event_editor.dart

@@ -23,6 +23,7 @@ class _EventEditor extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
+    final hasDrafts = drafts.isNotEmpty;
     return Column(
       crossAxisAlignment: CrossAxisAlignment.start,
       children: [
@@ -37,12 +38,14 @@ class _EventEditor extends StatelessWidget {
             ),
             Row(
               children: [
-                OutlinedButton.icon(
+                if (!hasDrafts) ...[
-                  onPressed: onAddEvent,
+                  OutlinedButton.icon(
-                  icon: const Icon(Icons.add),
+                    onPressed: onAddEvent,
-                  label: const Text('New event'),
+                    icon: const Icon(Icons.add),
-                ),
+                    label: const Text('New event'),
-                const SizedBox(width: 8),
+                  ),
+                  const SizedBox(width: 8),
+                ],
                 FilledButton.icon(
                   onPressed: (!canSave || isSaving) ? null : onSave,
                   icon: isSaving
@@ -147,6 +150,14 @@ class _EventEditor extends StatelessWidget {
               );
             },
           ),
+        if (hasDrafts) ...[
+          const SizedBox(height: 8),
+          OutlinedButton.icon(
+            onPressed: onAddEvent,
+            icon: const Icon(Icons.add),
+            label: const Text('New event'),
+          ),
+        ],
       ],
     );
   }

lib/components/pages/loco_timeline/timeline_grid.dart

@@ -2,16 +2,29 @@ part of 'package:mileograph_flutter/components/pages/loco_timeline.dart';
 
 final DateFormat _dateFormat = DateFormat('yyyy-MM-dd');
 
+enum _PendingModerationAction { approve, reject }
+
 class _TimelineGrid extends StatefulWidget {
   const _TimelineGrid({
     required this.entries,
     this.onEditEntry,
     this.onDeleteEntry,
+    this.onModeratePending,
+    this.pendingActionEventIds = const {},
+    this.expandedPendingAttrs = const {},
+    this.onTogglePendingAttr,
   });
 
   final List<LocoAttrVersion> entries;
   final void Function(LocoAttrVersion entry)? onEditEntry;
   final void Function(LocoAttrVersion entry)? onDeleteEntry;
+  final Future<void> Function(
+    LocoAttrVersion entry,
+    _PendingModerationAction action,
+  )? onModeratePending;
+  final Set<int> pendingActionEventIds;
+  final Set<String> expandedPendingAttrs;
+  final void Function(String attrCode)? onTogglePendingAttr;
 
   @override
   State<_TimelineGrid> createState() => _TimelineGridState();
@@ -77,12 +90,15 @@ class _TimelineGridState extends State<_TimelineGrid> {
         'build_day',
       }.contains(code);
     }).toList();
-    final model = _TimelineModel.fromEntries(filteredEntries);
+    final model = _TimelineModel.fromEntries(
+      filteredEntries,
+      expandedAttrCodes: widget.expandedPendingAttrs,
+    );
     final axisSegments = model.axisSegments;
     const labelWidth = 110.0;
     const rowHeight = 52.0;
     const double axisHeight = 48;
-    final rows = model.attrRows.entries.toList();
+    final rows = model.rows;
     final totalRowsHeight = rows.length * rowHeight;
     final axisWidth = math.max(model.axisTotalWidth, 120.0);
     final double viewHeight = totalRowsHeight + axisHeight + 8;
@@ -122,7 +138,12 @@ class _TimelineGridState extends State<_TimelineGrid> {
                           itemExtent: rowHeight,
                           itemCount: rows.length,
                           itemBuilder: (_, index) {
-                            final label = _formatAttrLabel(rows[index].key);
+                            final row = rows[index];
+                            final label = row.isPrimary
+                                ? _formatAttrLabel(row.attrCode)
+                                : (row.pendingUser?.trim().isNotEmpty == true
+                                    ? row.pendingUser!.trim()
+                                    : 'Unknown');
                             return Container(
                               alignment: Alignment.centerLeft,
                               padding: const EdgeInsets.symmetric(
@@ -139,12 +160,49 @@ class _TimelineGridState extends State<_TimelineGrid> {
                                   ),
                                 ),
                               ),
-                              child: Text(
+                              child: Row(
-                                label,
+                                children: [
-                                style: Theme.of(context)
+                                  if (!row.isPrimary) ...[
-                                    .textTheme
+                                    Icon(
-                                    .labelLarge
+                                      Icons.subdirectory_arrow_right,
-                                    ?.copyWith(fontWeight: FontWeight.w700),
+                                      size: 16,
+                                      color: Theme.of(context).hintColor,
+                                    ),
+                                    const SizedBox(width: 6),
+                                  ],
+                                  Expanded(
+                                    child: Text(
+                                      label,
+                                      maxLines: 1,
+                                      overflow: TextOverflow.ellipsis,
+                                      style: Theme.of(context)
+                                          .textTheme
+                                          .labelLarge
+                                          ?.copyWith(
+                                            fontWeight: row.isPrimary
+                                                ? FontWeight.w700
+                                                : FontWeight.w600,
+                                          ),
+                                    ),
+                                  ),
+                                  if (row.showExpandToggle)
+                                    IconButton(
+                                      onPressed: widget.onTogglePendingAttr == null
+                                          ? null
+                                          : () => widget.onTogglePendingAttr?.call(
+                                                row.attrCode,
+                                              ),
+                                      icon: Icon(
+                                        row.isExpanded
+                                            ? Icons.expand_less
+                                            : Icons.expand_more,
+                                      ),
+                                      tooltip: row.isExpanded
+                                          ? 'Collapse pending rows'
+                                          : 'Expand pending rows',
+                                      visualDensity: VisualDensity.compact,
+                                    ),
+                                ],
                               ),
                             );
                           },
@@ -179,7 +237,7 @@ class _TimelineGridState extends State<_TimelineGrid> {
                               itemExtent: rowHeight,
                               itemCount: rows.length,
                               itemBuilder: (_, index) {
-                                final blocks = rows[index].value;
+                                final blocks = rows[index].blocks;
                                 return Padding(
                                   padding:
                                       const EdgeInsets.symmetric(vertical: 2.0),
@@ -191,6 +249,8 @@ class _TimelineGridState extends State<_TimelineGrid> {
                                     viewportWidth: axisWidth,
                                     onEditEntry: widget.onEditEntry,
                                     onDeleteEntry: widget.onDeleteEntry,
+                                    onModeratePending: widget.onModeratePending,
+                                    pendingActionEventIds: widget.pendingActionEventIds,
                                   ),
                                 );
                               },
@@ -276,6 +336,8 @@ class _AttrRow extends StatelessWidget {
     required this.viewportWidth,
     this.onEditEntry,
     this.onDeleteEntry,
+    this.onModeratePending,
+    this.pendingActionEventIds = const {},
   });
 
   final double rowHeight;
@@ -285,6 +347,11 @@ class _AttrRow extends StatelessWidget {
   final double viewportWidth;
   final void Function(LocoAttrVersion entry)? onEditEntry;
   final void Function(LocoAttrVersion entry)? onDeleteEntry;
+  final Future<void> Function(
+    LocoAttrVersion entry,
+    _PendingModerationAction action,
+  )? onModeratePending;
+  final Set<int> pendingActionEventIds;
 
   @override
   Widget build(BuildContext context) {
@@ -310,6 +377,8 @@ class _AttrRow extends StatelessWidget {
                 block: block,
                 onEditEntry: onEditEntry,
                 onDeleteEntry: onDeleteEntry,
+                onModeratePending: onModeratePending,
+                pendingActionEventIds: pendingActionEventIds,
               ),
             ),
           if (activeBlock != null)
@@ -326,6 +395,7 @@ class _AttrRow extends StatelessWidget {
                       width: stickyWidth,
                     ),
                     clipLeftEdge: scrollOffset > activeBlock.left + 0.1,
+                    pendingActionEventIds: pendingActionEventIds,
                   ),
                 ),
               ),
@@ -347,20 +417,27 @@ class _ValueBlockView extends StatelessWidget {
   const _ValueBlockView({
     required this.block,
     this.clipLeftEdge = false,
+    this.pendingActionEventIds = const {},
   });
 
   final _ValueBlock block;
   final bool clipLeftEdge;
+  final Set<int> pendingActionEventIds;
 
   @override
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
-    final color = block.cell.color.withValues(alpha: 0.9);
+    final color = block.cell.color;
     final textColor = ThemeData.estimateBrightnessForColor(color) ==
             Brightness.dark
         ? Colors.white
         : Colors.black87;
 
+    final entry = block.entry;
+    final eventId = entry?.sourceEventId;
+    final isPendingAction =
+        entry?.isPending == true && eventId != null && pendingActionEventIds.contains(eventId);
+
     final radius = BorderRadius.only(
       topLeft: Radius.circular(clipLeftEdge ? 0 : 12),
       bottomLeft: Radius.circular(clipLeftEdge ? 0 : 12),
@@ -386,32 +463,63 @@ class _ValueBlockView extends StatelessWidget {
                 fit: BoxFit.scaleDown,
                 child: ConstrainedBox(
                   constraints: const BoxConstraints(minWidth: 1, minHeight: 1),
-                  child: Column(
+                  child: Row(
                     crossAxisAlignment: CrossAxisAlignment.start,
-                    mainAxisAlignment: MainAxisAlignment.center,
                     children: [
-                      Text(
+                      Column(
-                        block.cell.value,
+                        crossAxisAlignment: CrossAxisAlignment.start,
-                        maxLines: 1,
+                        mainAxisAlignment: MainAxisAlignment.center,
-                        overflow: TextOverflow.ellipsis,
+                        children: [
-                        style: theme.textTheme.bodyMedium?.copyWith(
+                          Row(
-                              fontWeight: FontWeight.w700,
+                            mainAxisSize: MainAxisSize.min,
-                              color: textColor,
+                            children: [
-                            ) ??
+                              if (block.cell.isPending)
-                            TextStyle(
+                                Padding(
-                              fontWeight: FontWeight.w700,
+                                  padding: const EdgeInsets.only(right: 6),
-                              color: textColor,
+                                  child: SizedBox(
-                            ),
+                                    width: 16,
-                      ),
+                                    height: 16,
-                      const SizedBox(height: 4),
+                                    child: isPendingAction
-                      Text(
+                                        ? CircularProgressIndicator(
-                        block.cell.rangeLabel,
+                                            strokeWidth: 2,
-                        maxLines: 1,
+                                            valueColor:
-                        overflow: TextOverflow.ellipsis,
+                                                AlwaysStoppedAnimation(textColor),
-                        style: theme.textTheme.labelSmall?.copyWith(
+                                          )
-                              color: textColor.withValues(alpha: 0.9),
+                                        : Icon(
-                            ) ??
+                                            Icons.pending,
-                            TextStyle(color: textColor.withValues(alpha: 0.9)),
+                                            size: 16,
+                                            color: textColor,
+                                          ),
+                                  ),
+                                ),
+                              Text(
+                                block.cell.value,
+                                maxLines: 1,
+                                overflow: TextOverflow.ellipsis,
+                                style: theme.textTheme.bodyMedium?.copyWith(
+                                      fontWeight: FontWeight.w700,
+                                      color: textColor,
+                                    ) ??
+                                    TextStyle(
+                                      fontWeight: FontWeight.w700,
+                                      color: textColor,
+                                    ),
+                              ),
+                            ],
+                          ),
+                          const SizedBox(height: 4),
+                          Text(
+                            block.cell.rangeLabel,
+                            maxLines: 1,
+                            overflow: TextOverflow.ellipsis,
+                            style: theme.textTheme.labelSmall?.copyWith(
+                                  color: textColor.withValues(alpha: 0.9),
+                                ) ??
+                                TextStyle(
+                                  color: textColor.withValues(alpha: 0.9),
+                                ),
+                          ),
+                        ],
                       ),
                     ],
                   ),
@@ -422,26 +530,48 @@ class _ValueBlockView extends StatelessWidget {
   }
 }
 
-enum _TimelineBlockAction { edit, delete }
+enum _TimelineBlockAction { edit, delete, approve, reject }
 
 class _ValueBlockMenu extends StatelessWidget {
   const _ValueBlockMenu({
     required this.block,
     this.onEditEntry,
     this.onDeleteEntry,
+    this.onModeratePending,
+    this.pendingActionEventIds = const {},
   });
 
   final _ValueBlock block;
   final void Function(LocoAttrVersion entry)? onEditEntry;
   final void Function(LocoAttrVersion entry)? onDeleteEntry;
+  final Future<void> Function(
+    LocoAttrVersion entry,
+    _PendingModerationAction action,
+  )? onModeratePending;
+  final Set<int> pendingActionEventIds;
 
-  bool get _hasActions => onEditEntry != null || onDeleteEntry != null;
+  bool get _hasActions {
+    final canModerate = block.entry?.isPending == true &&
+        block.entry?.canModeratePending == true &&
+        onModeratePending != null;
+    final canEdit = onEditEntry != null && block.entry?.isPending != true;
+    return onDeleteEntry != null || canModerate || canEdit;
+  }
 
   @override
   Widget build(BuildContext context) {
     if (!_hasActions || block.entry == null) {
-      return _ValueBlockView(block: block);
+      return _ValueBlockView(
+        block: block,
+      );
     }
+    final canModerate = block.entry?.isPending == true &&
+        block.entry?.canModeratePending == true &&
+        onModeratePending != null;
+    final canEdit = onEditEntry != null && block.entry?.isPending != true;
+    final eventId = block.entry?.sourceEventId;
+    final isPendingAction =
+        eventId != null && pendingActionEventIds.contains(eventId);
 
     Future<void> showContextMenuAt(Offset globalPosition) async {
       final overlay = Overlay.of(context);
@@ -459,11 +589,23 @@ class _ValueBlockMenu extends StatelessWidget {
         context: context,
         position: position,
         items: [
-          if (onEditEntry != null)
+          if (canEdit)
             const PopupMenuItem(
               value: _TimelineBlockAction.edit,
               child: Text('Edit'),
             ),
+          if (canModerate)
+            PopupMenuItem(
+              value: _TimelineBlockAction.approve,
+              enabled: !isPendingAction,
+              child: const Text('Approve pending'),
+            ),
+          if (canModerate)
+            PopupMenuItem(
+              value: _TimelineBlockAction.reject,
+              enabled: !isPendingAction,
+              child: const Text('Reject pending'),
+            ),
           if (onDeleteEntry != null)
             const PopupMenuItem(
               value: _TimelineBlockAction.delete,
@@ -481,11 +623,17 @@ class _ValueBlockMenu extends StatelessWidget {
         case _TimelineBlockAction.delete:
           onDeleteEntry?.call(entry);
           break;
+        case _TimelineBlockAction.approve:
+          onModeratePending?.call(entry, _PendingModerationAction.approve);
+          break;
+        case _TimelineBlockAction.reject:
+          onModeratePending?.call(entry, _PendingModerationAction.reject);
+          break;
       }
     }
 
     return GestureDetector(
-      behavior: HitTestBehavior.opaque,
+      behavior: HitTestBehavior.deferToChild,
       onLongPressStart: (details) async {
         if (defaultTargetPlatform == TargetPlatform.android) {
           HapticFeedback.lightImpact();
@@ -495,7 +643,10 @@ class _ValueBlockMenu extends StatelessWidget {
       onSecondaryTapDown: (details) async {
         await showContextMenuAt(details.globalPosition);
       },
-      child: _ValueBlockView(block: block),
+      child: _ValueBlockView(
+        block: block,
+        pendingActionEventIds: pendingActionEventIds,
+      ),
     );
   }
 }
@@ -518,7 +669,28 @@ String _formatAttrLabel(String code) {
 
 DateTime? _parseDateString(String? value) {
   if (value == null || value.isEmpty) return null;
-  return DateTime.tryParse(value);
+  final direct = DateTime.tryParse(value);
+  if (direct != null) return direct;
+  final maskedMatch =
+      RegExp(r'^(\\d{4})-(\\d{2}|xx|XX)-(\\d{2}|xx|XX)\$').firstMatch(value);
+  if (maskedMatch != null) {
+    final year = int.tryParse(maskedMatch.group(1) ?? '');
+    if (year == null) return null;
+    String normalize(String part, int fallback) {
+      final lower = part.toLowerCase();
+      if (lower == 'xx') return fallback.toString().padLeft(2, '0');
+      return part;
+    }
+
+    final month = int.tryParse(normalize(maskedMatch.group(2) ?? '01', 1)) ?? 1;
+    final day = int.tryParse(normalize(maskedMatch.group(3) ?? '01', 1)) ?? 1;
+    try {
+      return DateTime(year, month.clamp(1, 12), day.clamp(1, 31));
+    } catch (_) {
+      return null;
+    }
+  }
+  return null;
 }
 
 DateTime? _effectiveStart(LocoAttrVersion entry) {
@@ -534,76 +706,252 @@ DateTime _safeEnd(DateTime start, DateTime? end) {
   return end;
 }
 
+int _startKey(DateTime date) => date.year * 10000 + date.month * 100 + date.day;
+
+bool _isOverlappingStart(LocoAttrVersion entry, Set<int> approvedStartKeys) {
+  final start = _effectiveStart(entry);
+  if (start == null) return false;
+  return approvedStartKeys.contains(_startKey(start));
+}
+
+List<_ValueSegment> _segmentsForEntries(
+  List<LocoAttrVersion> items,
+  DateTime now,
+) {
+  if (items.isEmpty) return const [];
+  final sorted = [...items];
+  sorted.sort(
+    (a, b) => (_effectiveStart(a) ?? now)
+        .compareTo(_effectiveStart(b) ?? now),
+  );
+  final segments = <_ValueSegment>[];
+  for (int i = 0; i < sorted.length; i++) {
+    final entry = sorted[i];
+    final start = _effectiveStart(entry) ?? now;
+    final nextStart = i < sorted.length - 1
+        ? _effectiveStart(sorted[i + 1])
+        : null;
+    final rawEnd = entry.validTo ?? nextStart ?? now;
+    final end = _safeEnd(start, rawEnd);
+    segments.add(
+      _ValueSegment(
+        start: start,
+        end: end,
+        value: _formatValueWithUnits(entry),
+        entry: entry,
+      ),
+    );
+  }
+  return segments;
+}
+
+List<DateTime> _buildBoundaries(
+  List<_ValueSegment> segments,
+  DateTime now,
+) {
+  DateTime? minStart;
+  DateTime? maxEnd;
+  final boundaryDates = <DateTime>{};
+  for (final seg in segments) {
+    boundaryDates.add(seg.start);
+    boundaryDates.add(seg.end);
+    minStart = minStart == null || seg.start.isBefore(minStart!)
+        ? seg.start
+        : minStart;
+    maxEnd = maxEnd == null || seg.end.isAfter(maxEnd!) ? seg.end : maxEnd;
+  }
+  minStart ??= now.subtract(const Duration(days: 1));
+  final effectiveMaxEnd = maxEnd ?? now;
+  boundaryDates.add(effectiveMaxEnd);
+  var boundaries = boundaryDates.toList()..sort();
+  if (boundaries.length < 2) {
+    boundaries = [minStart!, effectiveMaxEnd];
+  }
+  return boundaries;
+}
+
+class _TimelineRowSpec {
+  final String id;
+  final String attrCode;
+  final List<_ValueSegment> segments;
+  final bool isPrimary;
+  final bool showExpandToggle;
+  final bool isExpanded;
+  final String? userLabel;
+
+  const _TimelineRowSpec._({
+    required this.id,
+    required this.attrCode,
+    required this.segments,
+    required this.isPrimary,
+    required this.showExpandToggle,
+    required this.isExpanded,
+    this.userLabel,
+  });
+
+  factory _TimelineRowSpec.primary({
+    required String attrCode,
+    required List<_ValueSegment> segments,
+    required bool showExpandToggle,
+    required bool isExpanded,
+  }) {
+    return _TimelineRowSpec._(
+      id: attrCode,
+      attrCode: attrCode,
+      segments: segments,
+      isPrimary: true,
+      showExpandToggle: showExpandToggle,
+      isExpanded: isExpanded,
+    );
+  }
+
+  factory _TimelineRowSpec.pending({
+    required String attrCode,
+    required String userLabel,
+    required List<_ValueSegment> segments,
+  }) {
+    return _TimelineRowSpec._(
+      id: '$attrCode::$userLabel',
+      attrCode: attrCode,
+      segments: segments,
+      isPrimary: false,
+      showExpandToggle: false,
+      isExpanded: false,
+      userLabel: userLabel,
+    );
+  }
+}
+
+class _TimelineRowData {
+  final String id;
+  final String attrCode;
+  final List<_ValueBlock> blocks;
+  final bool isPrimary;
+  final bool showExpandToggle;
+  final bool isExpanded;
+  final String? pendingUser;
+
+  const _TimelineRowData({
+    required this.id,
+    required this.attrCode,
+    required this.blocks,
+    required this.isPrimary,
+    required this.showExpandToggle,
+    required this.isExpanded,
+    this.pendingUser,
+  });
+}
+
 class _TimelineModel {
   final List<_AxisSegment> axisSegments;
-  final Map<String, List<_ValueBlock>> attrRows;
+  final List<_TimelineRowData> rows;
   final String endLabel;
   final List<DateTime> boundaries;
   final double axisTotalWidth;
 
   _TimelineModel({
     required this.axisSegments,
-    required this.attrRows,
+    required this.rows,
     required this.endLabel,
     required this.boundaries,
     required this.axisTotalWidth,
   });
 
-  factory _TimelineModel.fromEntries(List<LocoAttrVersion> entries) {
+  factory _TimelineModel.fromEntries(
+    List<LocoAttrVersion> entries, {
+    Set<String> expandedAttrCodes = const {},
+  }) {
+    final effectiveEntries = entries
+        .where((e) => _effectiveStart(e) != null)
+        .toList();
     final grouped = <String, List<LocoAttrVersion>>{};
-    for (final entry in entries) {
+    final attrOrder = <String>[];
-      grouped.putIfAbsent(entry.attrCode, () => []).add(entry);
+    for (final entry in effectiveEntries) {
+      final key = entry.attrCode;
+      if (!grouped.containsKey(key)) {
+        attrOrder.add(key);
+      }
+      grouped.putIfAbsent(key, () => []).add(entry);
     }
     final now = DateTime.now();
-    DateTime? minStart;
+    final allSegments = <_ValueSegment>[];
-    DateTime? maxEnd;
+    final rowSpecs = <_TimelineRowSpec>[];
-    final attrSegments = <String, List<_ValueSegment>>{};
+    for (final attr in attrOrder) {
+      final items = grouped[attr] ?? const [];
+      final approved = items.where((e) => !e.isPending).toList();
+      final pending = items.where((e) => e.isPending).toList();
+      final approvedSegments = _segmentsForEntries(approved, now);
 
-    grouped.forEach((attr, items) {
+      final approvedStartKeys = <int>{};
-      items.sort(
+      for (final entry in approved) {
-        (a, b) => (_effectiveStart(a) ?? now)
+        final start = _effectiveStart(entry);
-            .compareTo(_effectiveStart(b) ?? now),
+        if (start == null) continue;
+        approvedStartKeys.add(_startKey(start));
+      }
+
+      final pendingByUser = <String, List<LocoAttrVersion>>{};
+      final overlapByUser = <String, List<LocoAttrVersion>>{};
+      for (final entry in pending) {
+        final user = (entry.suggestedBy ?? '').trim().isEmpty
+            ? 'Unknown'
+            : entry.suggestedBy!.trim();
+        pendingByUser.putIfAbsent(user, () => []).add(entry);
+        final start = _effectiveStart(entry);
+        if (start == null) continue;
+        if (approvedStartKeys.contains(_startKey(start))) {
+          overlapByUser.putIfAbsent(user, () => []).add(entry);
+        }
+      }
+
+      final hasOverlap = overlapByUser.isNotEmpty;
+      final canToggle = pending.length > 1 && !hasOverlap;
+      final isExpanded = expandedAttrCodes.contains(attr);
+
+      final nonOverlapPending =
+          pending.where((e) => !_isOverlappingStart(e, approvedStartKeys)).toList();
+      final baseEntries = isExpanded ? approved : [...approved, ...nonOverlapPending];
+      final baseSegments =
+          isExpanded ? approvedSegments : _segmentsForEntries(baseEntries, now);
+
+      rowSpecs.add(
+        _TimelineRowSpec.primary(
+          attrCode: attr,
+          segments: baseSegments,
+          showExpandToggle: canToggle,
+          isExpanded: isExpanded,
+        ),
       );
-      final segments = <_ValueSegment>[];
+      allSegments.addAll(baseSegments);
-      for (int i = 0; i < items.length; i++) {
-        final entry = items[i];
-        final start = _effectiveStart(entry) ?? now;
-        final nextStart = i < items.length - 1
-            ? _effectiveStart(items[i + 1])
-            : null;
-        final rawEnd = entry.validTo ?? nextStart ?? now;
-        final end = _safeEnd(start, rawEnd);
-        segments.add(
-          _ValueSegment(
-            start: start,
-            end: end,
-            value: _formatValueWithUnits(entry),
-            entry: entry,
-          ),
-        );
-        minStart = minStart == null || start.isBefore(minStart!)
-            ? start
-            : minStart;
-        maxEnd = maxEnd == null || end.isAfter(maxEnd!) ? end : maxEnd;
-      }
-      attrSegments[attr] = segments;
-    });
 
-    minStart ??= now.subtract(const Duration(days: 1));
+      final shouldShowPendingRows = isExpanded || hasOverlap;
-    final effectiveMaxEnd = maxEnd ?? now;
+      if (shouldShowPendingRows) {
-
+        final users = isExpanded
-    final boundaryDates = <DateTime>{};
+            ? pendingByUser.keys.toList()
-    for (final segments in attrSegments.values) {
+            : overlapByUser.keys.toList();
-      for (final seg in segments) {
+        users.sort();
-        boundaryDates.add(seg.start);
+        for (final user in users) {
-        boundaryDates.add(seg.end);
+          final pendingEntries = isExpanded
+              ? (pendingByUser[user] ?? const [])
+              : (overlapByUser[user] ?? const []);
+          if (pendingEntries.isEmpty) continue;
+          final userPendingSegments = _segmentsForEntries(pendingEntries, now);
+          final combinedSegments = [
+            ...approvedSegments,
+            ...userPendingSegments,
+          ];
+          rowSpecs.add(
+            _TimelineRowSpec.pending(
+              attrCode: attr,
+              userLabel: user,
+              segments: combinedSegments,
+            ),
+          );
+          allSegments.addAll(combinedSegments);
+        }
       }
     }
-    boundaryDates.add(effectiveMaxEnd);
+
-    var boundaries = boundaryDates.toList()..sort();
+    final boundaries = _buildBoundaries(allSegments, now);
-    if (boundaries.length < 2) {
-      boundaries = [minStart!, effectiveMaxEnd];
-    }
 
     final axisSegments = <_AxisSegment>[];
     const double yearWidth = 240.0;
@@ -627,10 +975,10 @@ class _TimelineModel {
     final axisTotalWidth =
         axisSegments.fold<double>(0, (sum, seg) => sum + seg.width);
 
-    final attrRows = <String, List<_ValueBlock>>{};
+    final rows = <_TimelineRowData>[];
-    for (final entry in attrSegments.entries) {
+    for (final spec in rowSpecs) {
       final blocks = <_ValueBlock>[];
-      for (final seg in entry.value) {
+      for (final seg in spec.segments) {
         final left = _positionForDate(seg.start, boundaries, axisSegments);
         final right = _positionForDate(seg.end, boundaries, axisSegments);
         final span = right - left;
@@ -644,13 +992,24 @@ class _TimelineModel {
           ),
         );
       }
-      attrRows[entry.key] = blocks;
+      rows.add(
+        _TimelineRowData(
+          id: spec.id,
+          attrCode: spec.attrCode,
+          blocks: blocks,
+          isPrimary: spec.isPrimary,
+          showExpandToggle: spec.showExpandToggle,
+          isExpanded: spec.isExpanded,
+          pendingUser: spec.userLabel,
+        ),
+      );
     }
 
-    final endLabel = _formatDate(effectiveMaxEnd) ?? 'Now';
+    final endLabel =
+        boundaries.isNotEmpty ? _formatDate(boundaries.last) ?? 'Now' : 'Now';
     return _TimelineModel(
       axisSegments: axisSegments,
-      attrRows: attrRows,
+      rows: rows,
       endLabel: endLabel,
       boundaries: boundaries,
       axisTotalWidth: axisTotalWidth,
@@ -774,11 +1133,13 @@ class _RowCell {
   final String value;
   final String rangeLabel;
   final Color color;
+  final bool isPending;
 
   const _RowCell({
     required this.value,
     required this.rangeLabel,
     required this.color,
+    this.isPending = false,
   });
 
   factory _RowCell.fromSegment(_ValueSegment seg) {
@@ -787,6 +1148,7 @@ class _RowCell {
         value: '',
         rangeLabel: '',
         color: Colors.transparent,
+        isPending: false,
       );
     }
     final entry = seg.entry;
@@ -802,6 +1164,7 @@ class _RowCell {
       value: seg.value,
       rangeLabel: displayStart,
       color: _colorForValue(seg.value),
+      isPending: entry?.isPending ?? false,
     );
   }
 }

lib/components/pages/more/admin_page.dart

@@ -1,4 +1,5 @@
 import 'package:flutter/material.dart';
+import 'package:go_router/go_router.dart';
 import 'package:provider/provider.dart';
 import 'package:mileograph_flutter/objects/objects.dart';
 import 'package:mileograph_flutter/services/api_service.dart';
@@ -354,6 +355,18 @@ class _AdminPageState extends State<AdminPage> {
     return Scaffold(
       appBar: AppBar(
         title: const Text('Admin'),
+        leading: IconButton(
+          icon: const Icon(Icons.arrow_back),
+          onPressed: () {
+            final navigator = Navigator.of(context);
+            if (navigator.canPop()) {
+              navigator.maybePop();
+            } else {
+              context.go('/more');
+            }
+          },
+          tooltip: 'Back',
+        ),
       ),
       body: ListView(
         padding: const EdgeInsets.all(16),

lib/components/pages/more/user_profile_page.dart

@@ -0,0 +1,529 @@
+import 'package:flutter/material.dart';
+import 'package:go_router/go_router.dart';
+import 'package:provider/provider.dart';
+import 'package:mileograph_flutter/components/legs/leg_card.dart';
+import 'package:mileograph_flutter/objects/objects.dart';
+import 'package:mileograph_flutter/services/authservice.dart';
+import 'package:mileograph_flutter/services/data_service.dart';
+
+class UserProfilePage extends StatefulWidget {
+  const UserProfilePage({super.key, this.userId, this.initialUser});
+
+  final String? userId;
+  final UserSummary? initialUser;
+
+  @override
+  State<UserProfilePage> createState() => _UserProfilePageState();
+}
+
+class _UserProfilePageState extends State<UserProfilePage> {
+  static const int _pageSize = 22;
+  UserProfileDetail? _profile;
+  List<Leg> _legs = const [];
+  bool _loading = false;
+  bool _loadingMore = false;
+  bool _hasMore = false;
+  bool _lastFetchReturnedData = true;
+  Friendship? _friendship;
+  bool _actionsLoading = false;
+
+  String? get _userId => widget.initialUser?.userId ?? widget.userId;
+
+  @override
+  void initState() {
+    super.initState();
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      _loadProfile();
+    });
+  }
+
+  Future<void> _loadProfile() async {
+    final userId = _userId;
+    if (userId == null || userId.isEmpty) {
+      if (mounted) {
+        ScaffoldMessenger.of(
+          context,
+        ).showSnackBar(const SnackBar(content: Text('No user selected.')));
+        context.pop();
+      }
+      return;
+    }
+    setState(() {
+      _loading = true;
+      _hasMore = false;
+      _legs = const [];
+    });
+    final data = context.read<DataService>();
+    try {
+      final profile = await data.fetchUserProfileDetail(userId);
+      final friendship = await data.fetchFriendshipStatus(userId);
+      if (!mounted) return;
+      if (profile == null) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          const SnackBar(content: Text('Failed to load user profile.')),
+        );
+        return;
+      }
+      final legs = profile.legs;
+      setState(() {
+        _profile = profile;
+        _legs = legs;
+        _lastFetchReturnedData = legs.isNotEmpty;
+        _hasMore = _lastFetchReturnedData && _legs.length >= _pageSize;
+        _friendship = friendship;
+      });
+    } finally {
+      if (mounted) setState(() => _loading = false);
+    }
+  }
+
+  Future<void> _loadMore() async {
+    final userId = _userId;
+    if (userId == null || userId.isEmpty || _loadingMore || !_hasMore) return;
+    setState(() => _loadingMore = true);
+    final data = context.read<DataService>();
+    try {
+      final more = await data.fetchUserLegs(
+        userId: userId,
+        offset: _legs.length,
+        limit: _pageSize,
+      );
+      if (!mounted) return;
+      setState(() {
+        _legs = [..._legs, ...more];
+        _lastFetchReturnedData = more.isNotEmpty;
+        _hasMore = _lastFetchReturnedData && _legs.length >= _pageSize;
+      });
+    } finally {
+      if (mounted) setState(() => _loadingMore = false);
+    }
+  }
+
+  void _handleBack() {
+    final router = GoRouter.of(context);
+    if (router.canPop()) {
+      router.pop();
+    } else {
+      router.go('/more/profile');
+    }
+  }
+
+  Widget _buildProfileHeader(ThemeData theme) {
+    final profile = _profile;
+    final username = profile?.username ?? widget.initialUser?.username ?? '';
+    final fullName = profile?.fullName ?? widget.initialUser?.fullName ?? '';
+    final mileage = profile?.mileage;
+    final privacy = profile?.privacyInfo;
+    final mileageHidden =
+        (mileage == null || mileage == 0) &&
+        privacy != null &&
+        privacy.isNotEmpty;
+    return Card(
+      child: Padding(
+        padding: const EdgeInsets.all(12.0),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Row(
+              children: [
+                const CircleAvatar(child: Icon(Icons.person)),
+                const SizedBox(width: 12),
+                Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Text(
+                      fullName.isNotEmpty ? fullName : username,
+                      style: theme.textTheme.titleMedium,
+                    ),
+                    if (username.isNotEmpty)
+                      Text('@$username', style: theme.textTheme.bodySmall),
+                  ],
+                ),
+              ],
+            ),
+            const SizedBox(height: 12),
+            Text(
+              mileageHidden
+                  ? 'Mileage hidden'
+                  : 'Mileage: ${(mileage ?? 0).toStringAsFixed(1)}',
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildTopLocos() {
+    final profile = _profile;
+    if (profile == null || profile.topLocos.isEmpty) {
+      return const SizedBox.shrink();
+    }
+    final topTen = [...profile.topLocos]
+      ..sort((a, b) => (b.mileage ?? 0).compareTo(a.mileage ?? 0));
+    final displayLocos = topTen.take(10).toList();
+    return Card(
+      child: Padding(
+        padding: const EdgeInsets.all(12.0),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Text(
+              'Top locos by mileage',
+              style: Theme.of(context).textTheme.titleMedium,
+            ),
+            const SizedBox(height: 8),
+            ListView.separated(
+              physics: const NeverScrollableScrollPhysics(),
+              shrinkWrap: true,
+              itemCount: displayLocos.length,
+              separatorBuilder: (context, index) => const Divider(height: 1),
+              itemBuilder: (context, index) {
+                final loco = displayLocos[index];
+                final mileage = loco.mileage ?? 0;
+                return ListTile(
+                  leading: CircleAvatar(
+                    backgroundColor: Theme.of(
+                      context,
+                    ).colorScheme.primary.withValues(alpha: 0.1),
+                    child: Text(
+                      '${index + 1}',
+                      style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                        fontWeight: FontWeight.bold,
+                      ),
+                    ),
+                  ),
+                  title: Text(
+                    loco.number.isNotEmpty ? loco.number : 'Unknown',
+                    style: Theme.of(context).textTheme.bodyLarge,
+                  ),
+                  subtitle: Text(loco.locoClass),
+                  trailing: Text(
+                    '${mileage.toStringAsFixed(1)} mi',
+                    style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                      fontWeight: FontWeight.w700,
+                    ),
+                  ),
+                );
+              },
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  List<Widget> _buildLegsWithDividers(
+    BuildContext context,
+    List<Leg> legs, {
+    required bool showEditButton,
+  }) {
+    final widgets = <Widget>[];
+    String? currentDate;
+    final dayLegs = <Leg>[];
+
+    void flushDay() {
+      final date = currentDate;
+      if (date == null) return;
+      widgets.add(
+        Padding(
+          padding: const EdgeInsets.symmetric(vertical: 8.0),
+          child: Text(
+            date,
+            style: Theme.of(
+              context,
+            ).textTheme.labelMedium?.copyWith(fontWeight: FontWeight.w700),
+          ),
+        ),
+      );
+      widgets.add(const Divider());
+      widgets.addAll(
+        dayLegs.map(
+          (leg) => LegCard(
+            leg: leg,
+            showDate: false,
+            showEditButton: showEditButton,
+          ),
+        ),
+      );
+      dayLegs.clear();
+    }
+
+    for (final leg in legs) {
+      final dateStr = _formatDate(leg.beginTime) ?? '';
+      if (currentDate != null && dateStr != currentDate) {
+        flushDay();
+      }
+      currentDate = dateStr;
+      dayLegs.add(leg);
+    }
+
+    flushDay();
+    return widgets;
+  }
+
+  String? _formatDate(DateTime? date) {
+    if (date == null) return null;
+    return '${date.year.toString().padLeft(4, '0')}-${date.month.toString().padLeft(2, '0')}-${date.day.toString().padLeft(2, '0')}';
+  }
+
+  Widget _buildFriendSection(AuthService auth) {
+    final friendship = _friendship;
+    if (friendship == null) {
+      return const SizedBox.shrink();
+    }
+    return Card(
+      child: Padding(
+        padding: const EdgeInsets.all(12.0),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Row(
+              children: [
+                Text(
+                  'Friendship',
+                  style: Theme.of(context).textTheme.titleMedium,
+                ),
+                const SizedBox(width: 8),
+                _buildStatusChip(friendship, auth),
+              ],
+            ),
+            const SizedBox(height: 8),
+            _buildActions(friendship, auth),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildStatusChip(Friendship status, AuthService auth) {
+    String label = status.status;
+    Color color = Colors.grey;
+    switch (status.status.toLowerCase()) {
+      case 'accepted':
+        label = 'Friends';
+        color = Colors.green;
+        break;
+      case 'pending':
+        final isRequester = status.requesterId == auth.userId;
+        label = isRequester
+            ? 'Pending (you sent)'
+            : 'Pending (needs your reply)';
+        color = Colors.orange;
+        break;
+      case 'blocked':
+        color = Colors.red;
+        label = 'Blocked';
+        break;
+      case 'declined':
+      case 'rejected':
+        label = 'Declined';
+        break;
+      default:
+        label = 'Not friends';
+    }
+    final bg = Color.alphaBlend(
+      color.withValues(alpha: 0.15),
+      Theme.of(context).colorScheme.surface,
+    );
+    return Container(
+      margin: const EdgeInsets.only(left: 6),
+      padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 6),
+      decoration: BoxDecoration(
+        color: bg,
+        borderRadius: BorderRadius.circular(20),
+      ),
+      child: Text(label),
+    );
+  }
+
+  Widget _buildActions(Friendship status, AuthService auth) {
+    final targetUserId = _userId;
+    final isSelf = targetUserId != null && targetUserId == auth.userId;
+    if (isSelf) return const Text('This is you.');
+    final isRequester = status.requesterId == auth.userId;
+    final id = status.id;
+    final buttons = <Widget>[];
+
+    Future<void> run(Future<void> Function() action) async {
+      setState(() => _actionsLoading = true);
+      try {
+        await action();
+      } finally {
+        if (mounted) setState(() => _actionsLoading = false);
+      }
+    }
+
+    final data = context.read<DataService>();
+
+    if (status.isNone || status.isDeclined) {
+      buttons.add(
+        ElevatedButton.icon(
+          onPressed: _actionsLoading
+              ? null
+              : () => run(() async {
+                  final updated = await data.requestFriendship(
+                    status.addresseeId,
+                  );
+                  if (!mounted) return;
+                  setState(() => _friendship = updated);
+                }),
+          icon: const Icon(Icons.person_add),
+          label: const Text('Send friend request'),
+        ),
+      );
+    } else if (status.isPending) {
+      if (isRequester) {
+        buttons.add(
+          OutlinedButton(
+            onPressed: _actionsLoading || id == null || id.isEmpty
+                ? null
+                : () => run(() async {
+                    await data.cancelFriendship(id);
+                    if (!mounted) return;
+                    setState(
+                      () => _friendship = status.copyWith(status: 'none'),
+                    );
+                  }),
+            child: const Text('Cancel request'),
+          ),
+        );
+      } else {
+        buttons.add(
+          ElevatedButton(
+            onPressed: _actionsLoading || id == null || id.isEmpty
+                ? null
+                : () => run(() async {
+                    final updated = await data.acceptFriendship(id);
+                    if (!mounted) return;
+                    setState(() => _friendship = updated);
+                  }),
+            child: const Text('Accept'),
+          ),
+        );
+        buttons.add(
+          OutlinedButton(
+            onPressed: _actionsLoading || id == null || id.isEmpty
+                ? null
+                : () => run(() async {
+                    final updated = await data.rejectFriendship(id);
+                    if (!mounted) return;
+                    setState(() => _friendship = updated);
+                  }),
+            child: const Text('Reject'),
+          ),
+        );
+      }
+    } else if (status.isAccepted) {
+      buttons.add(
+        ElevatedButton.icon(
+          onPressed: _actionsLoading || id == null || id.isEmpty
+              ? null
+              : () => run(() async {
+                  await data.deleteFriendship(id);
+                  if (!mounted) return;
+                  setState(() => _friendship = status.copyWith(status: 'none'));
+                }),
+          icon: const Icon(Icons.person_remove),
+          label: const Text('Unfriend'),
+        ),
+      );
+    }
+
+    if (buttons.isEmpty) return const SizedBox.shrink();
+
+    return Wrap(spacing: 8, runSpacing: 8, children: buttons);
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final auth = context.watch<AuthService>();
+    final theme = Theme.of(context);
+    final canEdit = auth.userId != null && auth.userId == _userId;
+    return Scaffold(
+      appBar: AppBar(
+        title: const Text('User profile'),
+        leading: IconButton(
+          icon: const Icon(Icons.arrow_back),
+          onPressed: _handleBack,
+        ),
+      ),
+      body: RefreshIndicator(
+        onRefresh: _loadProfile,
+        child: ListView(
+          padding: const EdgeInsets.all(16),
+          children: [
+            _buildProfileHeader(theme),
+            const SizedBox(height: 12),
+            _buildFriendSection(auth),
+            const SizedBox(height: 12),
+            _buildTopLocos(),
+            const SizedBox(height: 12),
+            Card(
+              child: Padding(
+                padding: const EdgeInsets.all(12.0),
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Row(
+                      mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                      children: [
+                        Text('Entries', style: theme.textTheme.titleMedium),
+                        if (_loading)
+                          const SizedBox(
+                            width: 16,
+                            height: 16,
+                            child: CircularProgressIndicator(strokeWidth: 2),
+                          ),
+                      ],
+                    ),
+                    const SizedBox(height: 8),
+                    if (_loading && _legs.isEmpty)
+                      const Center(
+                        child: Padding(
+                          padding: EdgeInsets.symmetric(vertical: 16.0),
+                          child: CircularProgressIndicator(),
+                        ),
+                      )
+                    else if (_legs.isEmpty)
+                      Text(
+                        (_profile?.privacyInfo.isNotEmpty ?? false)
+                            ? 'Hidden due to privacy settings.'
+                            : 'No entries found.',
+                      )
+                    else ...[
+                      ..._buildLegsWithDividers(
+                        context,
+                        _legs,
+                        showEditButton: canEdit,
+                      ),
+                      const SizedBox(height: 8),
+                      if ((_hasMore || _loadingMore) && _legs.isNotEmpty)
+                        Align(
+                          alignment: Alignment.center,
+                          child: OutlinedButton.icon(
+                            onPressed: _loadingMore ? null : _loadMore,
+                            icon: _loadingMore
+                                ? const SizedBox(
+                                    height: 14,
+                                    width: 14,
+                                    child: CircularProgressIndicator(
+                                      strokeWidth: 2,
+                                    ),
+                                  )
+                                : const Icon(Icons.expand_more),
+                            label: Text(
+                              _loadingMore ? 'Loading...' : 'Load more',
+                            ),
+                          ),
+                        ),
+                    ],
+                  ],
+                ),
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}

lib/components/pages/new_entry/new_entry_draft_logic.dart

@@ -9,10 +9,19 @@ extension _NewEntryDraftLogic on _NewEntryPageState {
     if (_activeDraftId != null && !_draftChangedFromBaseline()) {
       return true;
     }
+    final currentSnapshot = _currentSubmissionSnapshot();
+    if (_lastSubmittedSnapshot != null &&
+        _snapshotEquality.equals(_lastSubmittedSnapshot, currentSnapshot)) {
+      return true;
+    }
     final choice = await _promptSaveDraft();
     if (choice == _ExitChoice.cancel) return false;
     if (choice == _ExitChoice.save) {
-      await _saveDraftEntry(draftId: _activeDraftId);
+      try {
+        await _saveDraftEntry(draftId: _activeDraftId);
+      } catch (_) {
+        return true;
+      }
     } else if (choice == _ExitChoice.discard) {
       // Delay reset to avoid setState during the dialog/build phase.
       await Future<void>.delayed(Duration.zero);
@@ -54,32 +63,37 @@ extension _NewEntryDraftLogic on _NewEntryPageState {
 
   Future<_ExitChoice> _promptSaveDraft() async {
     if (!mounted) return _ExitChoice.cancel;
-    final result = await showDialog<_ExitChoice>(
+    try {
-      context: context,
+      final result = await showDialog<_ExitChoice>(
-      barrierDismissible: false,
+        context: context,
-      useRootNavigator: false,
+        barrierDismissible: false,
-      builder: (_) => AlertDialog(
+        useRootNavigator: false,
-        title: const Text('Save draft?'),
+        builder: (_) => AlertDialog(
-        content: const Text(
+          title: const Text('Save draft?'),
-          'Do you want to save this entry as a draft before leaving?',
+          content: const Text(
+            'Do you want to save this entry as a draft before leaving?',
+          ),
+          actions: [
+            TextButton(
+              onPressed: () => Navigator.of(context).pop(_ExitChoice.discard),
+              child: const Text('No'),
+            ),
+            TextButton(
+              onPressed: () => Navigator.of(context).pop(_ExitChoice.save),
+              child: const Text('Yes'),
+            ),
+            TextButton(
+              onPressed: () => Navigator.of(context).pop(_ExitChoice.cancel),
+              child: const Text('Cancel'),
+            ),
+          ],
         ),
-        actions: [
+      );
-          TextButton(
+      if (!mounted) return _ExitChoice.cancel;
-            onPressed: () => Navigator.of(context).pop(_ExitChoice.discard),
+      return result ?? _ExitChoice.cancel;
-            child: const Text('No'),
+    } catch (_) {
-          ),
+      return _ExitChoice.cancel;
-          TextButton(
+    }
-            onPressed: () => Navigator.of(context).pop(_ExitChoice.save),
-            child: const Text('Yes'),
-          ),
-          TextButton(
-            onPressed: () => Navigator.of(context).pop(_ExitChoice.cancel),
-            child: const Text('Cancel'),
-          ),
-        ],
-      ),
-    );
-    return result ?? _ExitChoice.cancel;
   }
 
   Future<void> _openDrafts() async {
@@ -174,6 +188,14 @@ extension _NewEntryDraftLogic on _NewEntryPageState {
               "distance": _routeResult!.distance,
             },
       "tractionItems": _serializeTractionItems(),
+      "shareUserIds": _shareUserIds.toList(),
+      "shareUsers": _shareUsers
+          .map((u) => {
+                "user_id": u.userId,
+                "username": u.username,
+                "full_name": u.fullName,
+              })
+          .toList(),
     };
     await prefs.setString(_kDraftPrefsKey, jsonEncode(draft));
   }
@@ -302,6 +324,14 @@ extension _NewEntryDraftLogic on _NewEntryPageState {
               "distance": _routeResult!.distance,
             },
       "tractionItems": _serializeTractionItems(),
+      "shareUserIds": _shareUserIds.toList(),
+      "shareUsers": _shareUsers
+          .map((u) => {
+                "user_id": u.userId,
+                "username": u.username,
+                "full_name": u.fullName,
+              })
+          .toList(),
     };
   }
 
@@ -449,6 +479,19 @@ extension _NewEntryDraftLogic on _NewEntryPageState {
           ..clear()
           ..add(_TractionItem.marker());
       }
+      final shareIdsRaw = data['shareUserIds'];
+      final shareUsersRaw = data['shareUsers'];
+      _shareUserIds = shareIdsRaw is List
+          ? shareIdsRaw.map((e) => e.toString()).toSet()
+          : {};
+      _shareUsers = shareUsersRaw is List
+          ? shareUsersRaw
+              .whereType<Map>()
+              .map((e) => UserSummary.fromJson(
+                    e.map((k, v) => MapEntry(k.toString(), v)),
+                  ))
+              .toList()
+          : [];
       _lastSubmittedSnapshot = null;
       final idRaw = data['id'];
       if (idRaw != null) {

lib/components/pages/new_entry/new_entry_page.dart

@@ -58,6 +58,7 @@ class _NewEntryPageState extends State<NewEntryPage> {
   LegShareData? _activeLegShare;
   String? _sharedFromUser;
   int? _shareNotificationId;
+  bool _routeReversedFlag = false;
 
   bool get _isEditing => widget.editLegId != null;
   bool get _draftPersistenceEnabled =>
@@ -147,6 +148,48 @@ class _NewEntryPageState extends State<NewEntryPage> {
     }
   }
 
+  void _reverseRouteAndEndpoints() {
+    setState(() {
+      // Swap start/end and origin/destination fields
+      final startText = _startController.text;
+      final endText = _endController.text;
+      _startController.text = endText;
+      _endController.text = startText;
+
+      final originText = _originController.text;
+      final destText = _destinationController.text;
+      _originController.text = destText;
+      _destinationController.text = originText;
+
+      // Reverse route result if present
+      if (_routeResult != null) {
+        final reversedInput = _routeResult!.inputRoute.reversed.toList();
+        final reversedCalc = _routeResult!.calculatedRoute.reversed.toList();
+        final reversedCosts = _routeResult!.costs.reversed.toList();
+        _routeResult = RouteResult(
+          inputRoute: reversedInput,
+          calculatedRoute: reversedCalc,
+          costs: reversedCosts,
+          distance: _routeResult!.distance,
+        );
+        final units = _distanceUnits(context);
+        _mileageController.text = _formatDistance(
+          units,
+          _routeResult!.distance,
+          decimals: 2,
+          includeUnit: false,
+        );
+        _useManualMileage = false;
+      } else if (_useManualMileage &&
+          _mileageController.text.trim().isNotEmpty) {
+        // keep manual mileage, just swap endpoints
+      }
+      _routeReversedFlag = !_routeReversedFlag;
+    });
+    _saveDraft();
+    _scheduleMatchUpdate();
+  }
+
   double _milesFromInputWithUnit(DistanceUnit unit) {
     return DistanceFormatter(unit)
             .parseInputMiles(_mileageController.text.trim()) ??
@@ -664,7 +707,7 @@ class _NewEntryPageState extends State<NewEntryPage> {
     final enabled = value ?? false;
     setState(() {
       _matchDestinationToEntry = enabled;
-      if (enabled) _hasDestinationTime = true;
+      if (enabled && _hasEndTime) _hasDestinationTime = true;
     });
     _scheduleMatchUpdate();
     _saveDraft();
@@ -1084,7 +1127,7 @@ class _NewEntryPageState extends State<NewEntryPage> {
         if (_destinationController.text != endVal) {
           _destinationController.text = endVal;
         }
-        if (_hasDestinationTime) {
+        if (_hasDestinationTime && _hasEndTime) {
           final endTime = _legEndDateTime ?? _legDateTime;
           _selectedDestinationDate = DateTime(
             endTime.year,
@@ -1240,9 +1283,9 @@ class _NewEntryPageState extends State<NewEntryPage> {
             const SizedBox(height: 8),
             _buildSharedBanner(),
           ],
-          _buildTripSelector(context),
+              _buildTripSelector(context),
-          const SizedBox(height: 12),
+              const SizedBox(height: 8),
-          if (_activeLegShare == null) _buildShareSection(context),
+              if (_activeLegShare == null) _buildShareSection(context),
           _dateTimeGroup(
                 context,
                 title: 'Departure time',
@@ -1323,6 +1366,7 @@ class _NewEntryPageState extends State<NewEntryPage> {
                   border: OutlineInputBorder(),
                 ),
               ),
+              const Divider(height: 24),
               _trainLocationBlock(
                 label: 'Origin',
                 controller: _originController,
@@ -1341,6 +1385,7 @@ class _NewEntryPageState extends State<NewEntryPage> {
                   singleColumn: true,
                 ),
               ),
+              const Divider(height: 24),
               _trainLocationBlock(
                 label: 'Destination',
                 controller: _destinationController,
@@ -1360,6 +1405,7 @@ class _NewEntryPageState extends State<NewEntryPage> {
                   singleColumn: true,
                 ),
               ),
+              const Divider(height: 24),
               TextFormField(
                 controller: _networkController,
                 textCapitalization: TextCapitalization.characters,
@@ -1391,16 +1437,52 @@ class _NewEntryPageState extends State<NewEntryPage> {
               _buildTractionList(),
             ], minHeight: balancedHeight);
 
+            final routeStart = _routeResult?.calculatedRoute.isNotEmpty == true
+                ? _routeResult!.calculatedRoute.first
+                : (_routeResult?.inputRoute.isNotEmpty == true
+                    ? _routeResult!.inputRoute.first
+                    : _startController.text.trim());
+            final routeEnd = _routeResult?.calculatedRoute.isNotEmpty == true
+                ? _routeResult!.calculatedRoute.last
+                : (_routeResult?.inputRoute.isNotEmpty == true
+                    ? _routeResult!.inputRoute.last
+                    : _endController.text.trim());
+
             final mileagePanel = _section(
-              'Mileage',
+              'Your Journey',
               [
                 if (!_useManualMileage)
+                  Wrap(
+                    spacing: 12,
+                    runSpacing: 8,
+                    children: [
+                      ElevatedButton.icon(
+                        onPressed: _openCalculator,
+                        icon: const Icon(Icons.calculate, size: 18),
+                        label: const Text('Open mileage calculator'),
+                      ),
+                      OutlinedButton.icon(
+                        onPressed: _reverseRouteAndEndpoints,
+                        icon: const Icon(Icons.swap_horiz),
+                        label: const Text('Reverse route'),
+                      ),
+                    ],
+                  )
+                else
                   Align(
                     alignment: Alignment.centerLeft,
-                    child: ElevatedButton.icon(
+                    child: OutlinedButton.icon(
-                      onPressed: _openCalculator,
+                      onPressed: _reverseRouteAndEndpoints,
-                      icon: const Icon(Icons.calculate, size: 18),
+                      icon: const Icon(Icons.swap_horiz),
-                      label: const Text('Open mileage calculator'),
+                      label: const Text('Reverse route'),
+                    ),
+                  ),
+                if (routeStart.isNotEmpty || routeEnd.isNotEmpty)
+                  ListTile(
+                    contentPadding: EdgeInsets.zero,
+                    title: const Text('Route'),
+                    subtitle: Text(
+                      '${routeStart.isEmpty ? 'Start' : routeStart} → ${routeEnd.isEmpty ? 'End' : routeEnd}',
                     ),
                   ),
                 if (_useManualMileage)
@@ -1467,24 +1549,27 @@ class _NewEntryPageState extends State<NewEntryPage> {
                 children: [
                   entryPanel,
                   const SizedBox(height: 16),
-                  trainPanel,
+                  if (twoCol) ...[
-                  const SizedBox(height: 16),
+                    trainPanel,
-                  twoCol
+                    const SizedBox(height: 16),
-                      ? Row(
+                    Row(
-                          crossAxisAlignment: CrossAxisAlignment.start,
+                      crossAxisAlignment: CrossAxisAlignment.start,
-                          children: [
+                      children: [
-                            Expanded(child: tractionPanel),
+                        Expanded(child: tractionPanel),
-                            const SizedBox(width: 16),
+                        const SizedBox(width: 16),
-                            Expanded(child: mileagePanel),
+                        Expanded(child: mileagePanel),
-                          ],
+                      ],
-                        )
+                    ),
-                      : Column(
+                  ] else
-                          children: [
+                    Column(
-                            tractionPanel,
+                      children: [
-                            const SizedBox(height: 16),
+                        mileagePanel,
-                            mileagePanel,
+                        const SizedBox(height: 16),
-                          ],
+                        trainPanel,
-                        ),
+                        const SizedBox(height: 16),
+                        tractionPanel,
+                      ],
+                    ),
                   const SizedBox(height: 12),
                   ElevatedButton.icon(
                     onPressed: _submitting ? null : _submit,

lib/components/pages/new_entry/new_entry_submit_logic.dart

@@ -71,12 +71,14 @@ extension _NewEntrySubmitLogic on _NewEntryPageState {
     final beginDelay = _parseDelayMinutes(_beginDelayController.text);
     final endDelay =
         _hasEndTime ? _parseDelayMinutes(_endDelayController.text) : 0;
-    final snapshot = _buildSubmissionSnapshot(
+    final snapshot = _currentSubmissionSnapshot(
       routeStations: routeStations,
       startVal: startVal,
       endVal: endVal,
       mileageVal: mileageVal,
       tractionPayload: tractionPayload,
+      beginDelay: beginDelay,
+      endDelay: endDelay,
     );
     if (_lastSubmittedSnapshot != null &&
         _snapshotEquality.equals(_lastSubmittedSnapshot, snapshot)) {
@@ -161,16 +163,35 @@ extension _NewEntrySubmitLogic on _NewEntryPageState {
     }
   }
 
-  Map<String, dynamic> _buildSubmissionSnapshot({
+  Map<String, dynamic> _currentSubmissionSnapshot({
-    required List<String> routeStations,
+    List<String>? routeStations,
-    required String startVal,
+    String? startVal,
-    required String endVal,
+    String? endVal,
-    required double mileageVal,
+    double? mileageVal,
-    required List<Map<String, dynamic>> tractionPayload,
+    List<Map<String, dynamic>>? tractionPayload,
+    int? beginDelay,
+    int? endDelay,
   }) {
-    final beginDelay = _parseDelayMinutes(_beginDelayController.text);
+    final stations = routeStations ?? (_routeResult?.calculatedRoute ?? []);
-    final endDelay =
+    final start = startVal ??
-        _hasEndTime ? _parseDelayMinutes(_endDelayController.text) : 0;
+        (_useManualMileage
+            ? _startController.text.trim()
+            : (stations.isNotEmpty ? stations.first : ''));
+    final end = endVal ??
+        (_useManualMileage
+            ? _endController.text.trim()
+            : (stations.isNotEmpty ? stations.last : ''));
+    final mileage = mileageVal ??
+        (_useManualMileage
+            ? (_distanceUnits(context)
+                    .milesFromInput(_mileageController.text.trim()) ??
+                0)
+            : (_routeResult?.distance ?? 0));
+    final traction = tractionPayload ?? _buildTractionPayload();
+    final begin = beginDelay ?? _parseDelayMinutes(_beginDelayController.text);
+    final endDelayVal =
+        endDelay ?? (_hasEndTime ? _parseDelayMinutes(_endDelayController.text) : 0);
+
     return {
       "legId": widget.editLegId,
       "useManualMileage": _useManualMileage,
@@ -182,20 +203,20 @@ extension _NewEntrySubmitLogic on _NewEntryPageState {
       "hasOriginTime": _hasOriginTime,
       "legDestinationTime": _destinationDateTime?.toIso8601String(),
       "hasDestinationTime": _hasDestinationTime,
-      "start": startVal,
+      "start": start,
-      "end": endVal,
+      "end": end,
       "origin": _originController.text.trim(),
       "destination": _destinationController.text.trim(),
-      "routeStations": routeStations,
+      "routeStations": stations,
-      "mileage": mileageVal,
+      "mileage": mileage,
       "network": _networkController.text.trim(),
       "notes": _notesController.text.trim(),
       "headcode": _headcodeController.text.trim(),
-      "beginDelay": beginDelay,
+      "beginDelay": begin,
-      "endDelay": endDelay,
+      "endDelay": endDelayVal,
       "legShareId": _activeLegShare?.id,
       "shareUserIds": _shareUserIds.toList(),
-      "locos": tractionPayload,
+      "locos": traction,
       "routeResult": _routeResult == null
           ? null
           : {
@@ -211,16 +232,16 @@ extension _NewEntrySubmitLogic on _NewEntryPageState {
     if (!mounted) return false;
     final result = await showDialog<bool>(
       context: context,
-      builder: (_) => AlertDialog(
+      builder: (dialogContext) => AlertDialog(
         title: const Text('Duplicate entry?'),
         content: const Text('Entry already added, are you sure?'),
         actions: [
           TextButton(
-            onPressed: () => Navigator.of(context).pop(false),
+            onPressed: () => Navigator.of(dialogContext).pop(false),
             child: const Text('Cancel'),
           ),
           ElevatedButton(
-            onPressed: () => Navigator.of(context).pop(true),
+            onPressed: () => Navigator.of(dialogContext).pop(true),
             child: const Text('Submit anyway'),
           ),
         ],

lib/components/pages/profile.dart

@@ -1,6 +1,8 @@
 import 'package:flutter/material.dart';
+import 'package:go_router/go_router.dart';
 import 'package:provider/provider.dart';
 import 'package:mileograph_flutter/objects/objects.dart';
+import 'package:mileograph_flutter/services/api_service.dart';
 import 'package:mileograph_flutter/services/authservice.dart';
 import 'package:mileograph_flutter/services/data_service.dart';
 
@@ -13,15 +15,29 @@ class ProfilePage extends StatefulWidget {
 
 class _ProfilePageState extends State<ProfilePage> {
   final TextEditingController _searchController = TextEditingController();
+  final TextEditingController _currentPasswordController =
+      TextEditingController();
+  final TextEditingController _newPasswordController = TextEditingController();
+  final TextEditingController _confirmPasswordController =
+      TextEditingController();
+  final _passwordFormKey = GlobalKey<FormState>();
   List<UserSummary> _searchResults = [];
   bool _searching = false;
   String? _searchError;
   bool _fetched = false;
+  bool _privacyLoaded = false;
+  String? _privacyForUserId;
+  bool _privacyDirty = false;
+  bool _showAccountSettings = false;
+  bool _changingPassword = false;
+  static const List<String> _visibilityOptions = ['private', 'friends', 'public'];
 
   UserSummary? _selectedUser;
   Friendship? _status;
   bool _statusLoading = false;
   bool _actionLoading = false;
+  String _entriesVisibility = 'private';
+  String _mileageVisibility = 'private';
 
   @override
   void initState() {
@@ -35,9 +51,23 @@ class _ProfilePageState extends State<ProfilePage> {
     });
   }
 
+  @override
+  void didChangeDependencies() {
+    super.didChangeDependencies();
+    final auth = context.watch<AuthService>();
+    final userId = auth.userId;
+    if (userId != null && userId != _privacyForUserId) {
+      _privacyForUserId = userId;
+      _loadPrivacySettings();
+    }
+  }
+
   @override
   void dispose() {
     _searchController.dispose();
+    _currentPasswordController.dispose();
+    _newPasswordController.dispose();
+    _confirmPasswordController.dispose();
     super.dispose();
   }
 
@@ -97,6 +127,9 @@ class _ProfilePageState extends State<ProfilePage> {
           );
       if (!mounted) return;
       setState(() => _status = status);
+      final data = context.read<DataService>();
+      await data.fetchFriendships();
+      await data.fetchPendingFriendships();
       _showSnack('Friend request sent');
     } catch (e) {
       _showSnack('Failed to send request: $e');
@@ -129,6 +162,7 @@ class _ProfilePageState extends State<ProfilePage> {
       final updated = await context.read<DataService>().acceptFriendship(id);
       if (!mounted) return;
       setState(() => _status = updated);
+      await context.read<DataService>().fetchFriendships();
       _showSnack('Friend request accepted');
     } catch (e) {
       _showSnack('Failed to accept: $e');
@@ -145,6 +179,7 @@ class _ProfilePageState extends State<ProfilePage> {
       final updated = await context.read<DataService>().rejectFriendship(id);
       if (!mounted) return;
       setState(() => _status = updated);
+      await context.read<DataService>().fetchPendingFriendships();
       _showSnack('Friend request rejected');
     } catch (e) {
       _showSnack('Failed to reject: $e');
@@ -188,6 +223,134 @@ class _ProfilePageState extends State<ProfilePage> {
     }
   }
 
+  Future<void> _loadPrivacySettings() async {
+    final data = context.read<DataService>();
+    final auth = context.read<AuthService>();
+    setState(() {
+      _entriesVisibility = auth.entriesVisibility.isNotEmpty
+          ? auth.entriesVisibility
+          : data.userEntriesVisibility;
+      _mileageVisibility = auth.mileageVisibility.isNotEmpty
+          ? auth.mileageVisibility
+          : data.userMileageVisibility;
+      _privacyDirty = false;
+      _privacyLoaded = true;
+    });
+    await data.fetchPrivacySettings();
+    if (!mounted) return;
+    setState(() {
+      _entriesVisibility = data.userEntriesVisibility;
+      _mileageVisibility = data.userMileageVisibility;
+      _privacyDirty = false;
+      _privacyLoaded = true;
+    });
+  }
+
+  int _visibilityRank(String value) {
+    switch (value.toLowerCase()) {
+      case 'public':
+        return 2;
+      case 'friends':
+        return 1;
+      default:
+        return 0;
+    }
+  }
+
+  String _visibilityLabel(String value) {
+    switch (value) {
+      case 'friends':
+        return 'Friends';
+      case 'public':
+        return 'Public';
+      default:
+        return 'Private';
+    }
+  }
+
+  void _setEntriesVisibility(String value) {
+    setState(() {
+      _entriesVisibility = value;
+      if (_visibilityRank(_mileageVisibility) < _visibilityRank(value)) {
+        _mileageVisibility = value;
+      }
+      _privacyDirty = true;
+    });
+  }
+
+  void _setMileageVisibility(String value) {
+    if (_visibilityRank(value) < _visibilityRank(_entriesVisibility)) {
+      value = _entriesVisibility;
+    }
+    setState(() {
+      _mileageVisibility = value;
+      _privacyDirty = true;
+    });
+  }
+
+  Future<void> _savePrivacy() async {
+    final messenger = ScaffoldMessenger.of(context);
+    final data = context.read<DataService>();
+    final entries = _entriesVisibility;
+    final mileage = _mileageVisibility;
+
+    try {
+      await data.updatePrivacySettings(
+        entriesVisibility: entries,
+        mileageVisibility: mileage,
+      );
+      if (!mounted) return;
+      setState(() {
+        _entriesVisibility = data.userEntriesVisibility;
+        _mileageVisibility = data.userMileageVisibility;
+        _privacyDirty = false;
+      });
+      messenger.showSnackBar(
+        const SnackBar(content: Text('Privacy settings updated.')),
+      );
+    } catch (e) {
+      if (!mounted) return;
+      setState(() => _privacyDirty = true);
+      messenger.showSnackBar(
+        SnackBar(content: Text('Failed to update privacy settings: $e')),
+      );
+    }
+  }
+
+  Future<void> _changePassword() async {
+    final messenger = ScaffoldMessenger.of(context);
+    final formState = _passwordFormKey.currentState;
+    if (formState == null || !formState.validate()) return;
+
+    FocusScope.of(context).unfocus();
+    setState(() => _changingPassword = true);
+    try {
+      final api = context.read<ApiService>();
+      await api.post('/user/password/change', {
+        'old_password': _currentPasswordController.text,
+        'new_password': _newPasswordController.text,
+      });
+      if (!mounted) return;
+      messenger.showSnackBar(
+        const SnackBar(content: Text('Password updated successfully.')),
+      );
+      formState.reset();
+      _currentPasswordController.clear();
+      _newPasswordController.clear();
+      _confirmPasswordController.clear();
+    } catch (e) {
+      if (mounted) {
+        messenger.showSnackBar(
+          SnackBar(content: Text('Failed to change password: $e')),
+        );
+      }
+    } finally {
+      if (mounted) {
+        setState(() => _changingPassword = false);
+      }
+    }
+  }
+
   void _showSnack(String message) {
     ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text(message)));
   }
@@ -205,12 +368,25 @@ class _ProfilePageState extends State<ProfilePage> {
 
     return Scaffold(
       appBar: AppBar(
+        leading: IconButton(
+          icon: const Icon(Icons.arrow_back),
+          onPressed: () {
+            final nav = Navigator.of(context);
+            if (nav.canPop()) {
+              nav.maybePop();
+            } else {
+              context.go('/more');
+            }
+          },
+          tooltip: 'Back',
+        ),
         title: const Text('Profile'),
       ),
       body: RefreshIndicator(
         onRefresh: () async {
           await data.fetchFriendships();
           await data.fetchPendingFriendships();
+          await _loadPrivacySettings();
           if (_selectedUser != null) {
             await _loadStatus(_selectedUser!);
           }
@@ -225,6 +401,8 @@ class _ProfilePageState extends State<ProfilePage> {
             _buildSelectedUserSection(auth),
             const SizedBox(height: 16),
             _buildFriendsList(auth),
+            const SizedBox(height: 16),
+            _buildAccountSection(),
           ],
         ),
       ),
@@ -297,18 +475,22 @@ class _ProfilePageState extends State<ProfilePage> {
               ),
             if (_searchResults.isNotEmpty) const SizedBox(height: 12),
             if (_searchResults.isNotEmpty)
-              ..._searchResults.map(
+                ..._searchResults.map(
-                (user) => ListTile(
+                  (user) => ListTile(
-                  leading: const Icon(Icons.person),
+                    leading: const Icon(Icons.person),
-                  title: Text(user.displayName),
+                    title: Text(user.displayName),
-                  subtitle:
+                    subtitle:
-                      user.username.isNotEmpty ? Text('@${user.username}') : null,
+                        user.username.isNotEmpty ? Text('@${user.username}') : null,
                   trailing: TextButton(
-                    onPressed: () => _loadStatus(user),
+                    onPressed: () => context.pushNamed(
+                      'user-profile',
+                      extra: user,
+                      queryParameters: {'user_id': user.userId},
+                    ),
                     child: const Text('View'),
                   ),
+                  ),
                 ),
-              ),
           ],
         ),
       ),
@@ -580,22 +762,267 @@ class _ProfilePageState extends State<ProfilePage> {
                 subtitle: otherUser?.username.isNotEmpty == true
                     ? Text('@${otherUser!.username}')
                     : null,
-                trailing: TextButton(
+                  trailing: TextButton(
-                  onPressed: () {
+                    onPressed: () {
-                    final user = otherUser;
+                      final user = otherUser;
-                    if (user != null) {
+                      if (user != null) {
-                      _loadStatus(user);
+                        final auth = context.read<AuthService>();
-                    }
+                        final isSelf = auth.userId == user.userId;
-                  },
+                        if (isSelf) {
-                  child: const Text('Manage'),
+                          context.go('/more/profile');
-                ),
+                        } else {
-              ),
+                          context.pushNamed(
+                            'user-profile',
+                            extra: user,
+                            queryParameters: {'user_id': user.userId},
+                          );
+                        }
+                      }
+                    },
+                    child: const Text('View'),
+                  ),
+                  ),
             );
           }),
       ],
     );
   }
 
+  Widget _buildAccountSection() {
+    final data = context.watch<DataService>();
+    final theme = Theme.of(context);
+    final privacySaving = data.isPrivacySaving;
+    final showPrivacySpinner = data.isPrivacyLoading && !_privacyLoaded;
+    final privacyInputsDisabled = privacySaving || showPrivacySpinner;
+
+    return Card(
+      child: Padding(
+        padding: const EdgeInsets.all(12.0),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Row(
+              mainAxisAlignment: MainAxisAlignment.spaceBetween,
+              children: [
+                Text(
+                  'Account & privacy',
+                  style: theme.textTheme.titleMedium,
+                ),
+                TextButton.icon(
+                  onPressed: () => setState(
+                    () => _showAccountSettings = !_showAccountSettings,
+                  ),
+                  icon: Icon(
+                    _showAccountSettings ? Icons.expand_less : Icons.expand_more,
+                  ),
+                  label: Text(
+                    _showAccountSettings ? 'Hide settings' : 'More settings',
+                  ),
+                ),
+              ],
+            ),
+            AnimatedCrossFade(
+              crossFadeState: _showAccountSettings
+                  ? CrossFadeState.showFirst
+                  : CrossFadeState.showSecond,
+              duration: const Duration(milliseconds: 200),
+              firstChild: Column(
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  if (showPrivacySpinner)
+                    const Padding(
+                      padding: EdgeInsets.symmetric(vertical: 8.0),
+                      child: Center(
+                        child: CircularProgressIndicator(strokeWidth: 2),
+                      ),
+                    )
+                  else ...[
+                    Text(
+                      'Privacy settings',
+                      style: theme.textTheme.titleMedium
+                          ?.copyWith(fontWeight: FontWeight.w700),
+                    ),
+                    const SizedBox(height: 8),
+                    DropdownButtonFormField<String>(
+                      value: _entriesVisibility,
+                      decoration: const InputDecoration(
+                        labelText: 'Entry privacy',
+                        border: OutlineInputBorder(),
+                      ),
+                      items: _visibilityOptions
+                          .map(
+                            (option) => DropdownMenuItem(
+                              value: option,
+                              child: Text(_visibilityLabel(option)),
+                            ),
+                          )
+                          .toList(),
+                      onChanged: privacyInputsDisabled
+                          ? null
+                          : (value) {
+                              if (value == null) return;
+                              _setEntriesVisibility(value);
+                            },
+                    ),
+                    const SizedBox(height: 12),
+                    DropdownButtonFormField<String>(
+                      value: _mileageVisibility,
+                      decoration: const InputDecoration(
+                        labelText: 'Mileage privacy',
+                        border: OutlineInputBorder(),
+                      ),
+                      items: _visibilityOptions
+                          .map((option) {
+                            final enabled = _visibilityRank(option) >=
+                                _visibilityRank(_entriesVisibility);
+                            final textColor = enabled
+                                ? null
+                                : theme.disabledColor;
+                            return DropdownMenuItem(
+                              value: option,
+                              enabled: enabled,
+                              child: Text(
+                                _visibilityLabel(option),
+                                style: textColor == null
+                                    ? null
+                                    : TextStyle(color: textColor),
+                              ),
+                            );
+                          })
+                          .toList(),
+                      onChanged: privacyInputsDisabled
+                          ? null
+                          : (value) {
+                              if (value == null) return;
+                              _setMileageVisibility(value);
+                            },
+                    ),
+                    const SizedBox(height: 6),
+                    Text(
+                      'Mileage visibility cannot be more restrictive than entry visibility.',
+                      style: theme.textTheme.bodySmall,
+                    ),
+                    const SizedBox(height: 12),
+                    FilledButton.icon(
+                      onPressed: (privacySaving || !_privacyDirty || showPrivacySpinner)
+                          ? null
+                          : _savePrivacy,
+                      icon: privacySaving
+                          ? const SizedBox(
+                              width: 18,
+                              height: 18,
+                              child: CircularProgressIndicator(strokeWidth: 2),
+                            )
+                          : const Icon(Icons.save),
+                      label: Text(
+                        privacySaving ? 'Saving...' : 'Save privacy',
+                      ),
+                    ),
+                  ],
+                  const Divider(height: 28),
+                  Text(
+                    'Change password',
+                    style: theme.textTheme.titleMedium
+                        ?.copyWith(fontWeight: FontWeight.w700),
+                  ),
+                  const SizedBox(height: 8),
+                  Text(
+                    'Change your password for this account.',
+                    style: theme.textTheme.bodySmall,
+                  ),
+                  const SizedBox(height: 12),
+                  Form(
+                    key: _passwordFormKey,
+                    child: Column(
+                      crossAxisAlignment: CrossAxisAlignment.start,
+                      children: [
+                        TextFormField(
+                          controller: _currentPasswordController,
+                          decoration: const InputDecoration(
+                            labelText: 'Current password',
+                            border: OutlineInputBorder(),
+                          ),
+                          obscureText: true,
+                          enableSuggestions: false,
+                          autocorrect: false,
+                          autofillHints: const [AutofillHints.password],
+                          validator: (value) {
+                            if (value == null || value.isEmpty) {
+                              return 'Please enter your current password.';
+                            }
+                            return null;
+                          },
+                        ),
+                        const SizedBox(height: 12),
+                        TextFormField(
+                          controller: _newPasswordController,
+                          decoration: const InputDecoration(
+                            labelText: 'New password',
+                            border: OutlineInputBorder(),
+                          ),
+                          obscureText: true,
+                          enableSuggestions: false,
+                          autocorrect: false,
+                          autofillHints: const [AutofillHints.newPassword],
+                          validator: (value) {
+                            if (value == null || value.isEmpty) {
+                              return 'Please enter a new password.';
+                            }
+                            return null;
+                          },
+                        ),
+                        const SizedBox(height: 12),
+                        TextFormField(
+                          controller: _confirmPasswordController,
+                          decoration: const InputDecoration(
+                            labelText: 'Confirm new password',
+                            border: OutlineInputBorder(),
+                          ),
+                          obscureText: true,
+                          enableSuggestions: false,
+                          autocorrect: false,
+                          autofillHints: const [AutofillHints.newPassword],
+                          validator: (value) {
+                            if (value == null || value.isEmpty) {
+                              return 'Please confirm the new password.';
+                            }
+                            if (value != _newPasswordController.text) {
+                              return 'New passwords do not match.';
+                            }
+                            return null;
+                          },
+                        ),
+                        const SizedBox(height: 16),
+                        FilledButton.icon(
+                          onPressed:
+                              _changingPassword ? null : _changePassword,
+                          icon: _changingPassword
+                              ? const SizedBox(
+                                  width: 18,
+                                  height: 18,
+                                  child:
+                                      CircularProgressIndicator(strokeWidth: 2),
+                                )
+                              : const Icon(Icons.lock_reset),
+                          label: Text(
+                            _changingPassword
+                                ? 'Updating...'
+                                : 'Change password',
+                          ),
+                        ),
+                      ],
+                    ),
+                  ),
+                ],
+              ),
+              secondChild: const SizedBox.shrink(),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
   UserSummary? _otherUser(Friendship friendship, String? currentUserId) {
     final selfId = currentUserId ?? '';
     if (friendship.requester?.userId == selfId) return friendship.addressee;

lib/components/pages/settings.dart

@@ -3,10 +3,10 @@ import 'dart:convert';
 import 'package:flutter/material.dart';
 import 'package:go_router/go_router.dart';
 import 'package:http/http.dart' as http;
-import 'package:mileograph_flutter/services/authservice.dart';
+import 'package:mileograph_flutter/services/accent_color_service.dart';
-import 'package:mileograph_flutter/services/api_service.dart';
 import 'package:mileograph_flutter/services/distance_unit_service.dart';
 import 'package:mileograph_flutter/services/endpoint_service.dart';
+import 'package:mileograph_flutter/services/theme_mode_service.dart';
 import 'package:mileograph_flutter/services/data_service.dart';
 import 'package:provider/provider.dart';
 
@@ -20,27 +20,28 @@ class SettingsPage extends StatefulWidget {
 class _SettingsPageState extends State<SettingsPage> {
   late final TextEditingController _endpointController;
   bool _saving = false;
-  bool _changingPassword = false;
+  static const List<Color> _accentPalette = [
-  final _passwordFormKey = GlobalKey<FormState>();
+    Colors.red,
-  late final TextEditingController _currentPasswordController;
+    Colors.pink,
-  late final TextEditingController _newPasswordController;
+    Colors.orange,
-  late final TextEditingController _confirmPasswordController;
+    Colors.amber,
+    Colors.green,
+    Colors.teal,
+    Colors.blue,
+    Colors.indigo,
+    Colors.purple,
+    Colors.cyan,
+  ];
 
   @override
   void initState() {
     super.initState();
     final endpoint = context.read<EndpointService>().baseUrl;
     _endpointController = TextEditingController(text: endpoint);
-    _currentPasswordController = TextEditingController();
-    _newPasswordController = TextEditingController();
-    _confirmPasswordController = TextEditingController();
   }
 
   @override
   void dispose() {
-    _currentPasswordController.dispose();
-    _newPasswordController.dispose();
-    _confirmPasswordController.dispose();
     _endpointController.dispose();
     super.dispose();
   }
@@ -139,48 +140,16 @@ class _SettingsPageState extends State<SettingsPage> {
     }
   }
 
-  Future<void> _changePassword() async {
-    final messenger = ScaffoldMessenger.of(context);
-    final formState = _passwordFormKey.currentState;
-    if (formState == null || !formState.validate()) return;
-
-    FocusScope.of(context).unfocus();
-    setState(() => _changingPassword = true);
-    try {
-      final api = context.read<ApiService>();
-      await api.post('/user/password/change', {
-        'old_password': _currentPasswordController.text,
-        'new_password': _newPasswordController.text,
-      });
-      if (!mounted) return;
-      messenger.showSnackBar(
-        const SnackBar(content: Text('Password updated successfully.')),
-      );
-      formState.reset();
-      _currentPasswordController.clear();
-      _newPasswordController.clear();
-      _confirmPasswordController.clear();
-    } catch (e) {
-      if (mounted) {
-        messenger.showSnackBar(
-          SnackBar(content: Text('Failed to change password: $e')),
-        );
-      }
-    } finally {
-      if (mounted) {
-        setState(() => _changingPassword = false);
-      }
-    }
-  }
-
   @override
   Widget build(BuildContext context) {
     final endpointService = context.watch<EndpointService>();
     final distanceUnitService = context.watch<DistanceUnitService>();
-    final loggedIn = context.select<AuthService, bool>(
+    final accentService = context.watch<AccentColorService>();
-      (auth) => auth.isLoggedIn,
+    final themeModeService = context.watch<ThemeModeService>();
-    );
+    if (!endpointService.isLoaded ||
-    if (!endpointService.isLoaded || !distanceUnitService.isLoaded) {
+        !distanceUnitService.isLoaded ||
+        !accentService.isLoaded ||
+        !themeModeService.isLoaded) {
       return const Scaffold(
         body: Center(child: CircularProgressIndicator()),
       );
@@ -196,7 +165,7 @@ class _SettingsPageState extends State<SettingsPage> {
             if (navigator.canPop()) {
               navigator.pop();
             } else {
-              context.go('/');
+              context.go('/more');
             }
           },
         ),
@@ -234,6 +203,73 @@ class _SettingsPageState extends State<SettingsPage> {
               },
             ),
             const SizedBox(height: 24),
+            Text(
+              'Accent colour',
+              style: Theme.of(context).textTheme.titleMedium?.copyWith(
+                    fontWeight: FontWeight.w700,
+                  ),
+            ),
+            const SizedBox(height: 8),
+            Text(
+              'Choose your preferred accent colour or use system colours.',
+              style: Theme.of(context).textTheme.bodySmall,
+            ),
+            const SizedBox(height: 12),
+            Wrap(
+              spacing: 12,
+              runSpacing: 8,
+              crossAxisAlignment: WrapCrossAlignment.center,
+              children: [
+                OutlinedButton.icon(
+                  onPressed:
+                      accentService.useSystem ? null : () => accentService.setUseSystem(true),
+                  icon: const Icon(Icons.phone_android),
+                  label: const Text('Use system colours'),
+                ),
+                ..._accentPalette.map(
+                  (color) => _AccentSwatchButton(
+                    color: color,
+                    selected:
+                        !accentService.useSystem &&
+                            accentService.seedColor.toARGB32() == color.toARGB32(),
+                    onTap: () => accentService.setSeedColor(color),
+                  ),
+                ),
+              ],
+            ),
+            const SizedBox(height: 24),
+            Text(
+              'Theme mode',
+              style: Theme.of(context).textTheme.titleMedium?.copyWith(
+                    fontWeight: FontWeight.w700,
+                  ),
+            ),
+            const SizedBox(height: 8),
+            SegmentedButton<ThemeMode>(
+              segments: const [
+                ButtonSegment(
+                  value: ThemeMode.system,
+                  icon: Icon(Icons.settings_suggest),
+                  label: Text('System'),
+                ),
+                ButtonSegment(
+                  value: ThemeMode.light,
+                  icon: Icon(Icons.light_mode),
+                  label: Text('Light'),
+                ),
+                ButtonSegment(
+                  value: ThemeMode.dark,
+                  icon: Icon(Icons.dark_mode),
+                  label: Text('Dark'),
+                ),
+              ],
+              selected: {themeModeService.mode},
+              onSelectionChanged: (selection) {
+                final mode = selection.first;
+                themeModeService.setMode(mode);
+              },
+            ),
+            const SizedBox(height: 24),
             Text(
               'API endpoint',
               style: Theme.of(context).textTheme.titleMedium?.copyWith(
@@ -285,102 +321,60 @@ class _SettingsPageState extends State<SettingsPage> {
               'Current: ${endpointService.baseUrl}',
               style: Theme.of(context).textTheme.labelSmall,
             ),
-            if (loggedIn) ...[
-              const SizedBox(height: 32),
-              Text(
-                'Account',
-                style: Theme.of(context).textTheme.titleMedium?.copyWith(
-                      fontWeight: FontWeight.w700,
-                    ),
-              ),
-              const SizedBox(height: 8),
-              Text(
-                'Change your password for this account.',
-                style: Theme.of(context).textTheme.bodySmall,
-              ),
-              const SizedBox(height: 12),
-              Form(
-                key: _passwordFormKey,
-                child: Column(
-                  crossAxisAlignment: CrossAxisAlignment.start,
-                  children: [
-                    TextFormField(
-                      controller: _currentPasswordController,
-                      decoration: const InputDecoration(
-                        labelText: 'Current password',
-                        border: OutlineInputBorder(),
-                      ),
-                      obscureText: true,
-                      enableSuggestions: false,
-                      autocorrect: false,
-                      autofillHints: const [AutofillHints.password],
-                      validator: (value) {
-                        if (value == null || value.isEmpty) {
-                          return 'Please enter your current password.';
-                        }
-                        return null;
-                      },
-                    ),
-                    const SizedBox(height: 12),
-                    TextFormField(
-                      controller: _newPasswordController,
-                      decoration: const InputDecoration(
-                        labelText: 'New password',
-                        border: OutlineInputBorder(),
-                      ),
-                      obscureText: true,
-                      enableSuggestions: false,
-                      autocorrect: false,
-                      autofillHints: const [AutofillHints.newPassword],
-                      validator: (value) {
-                        if (value == null || value.isEmpty) {
-                          return 'Please enter a new password.';
-                        }
-                        return null;
-                      },
-                    ),
-                    const SizedBox(height: 12),
-                    TextFormField(
-                      controller: _confirmPasswordController,
-                      decoration: const InputDecoration(
-                        labelText: 'Confirm new password',
-                        border: OutlineInputBorder(),
-                      ),
-                      obscureText: true,
-                      enableSuggestions: false,
-                      autocorrect: false,
-                      autofillHints: const [AutofillHints.newPassword],
-                      validator: (value) {
-                        if (value == null || value.isEmpty) {
-                          return 'Please confirm the new password.';
-                        }
-                        if (value != _newPasswordController.text) {
-                          return 'New passwords do not match.';
-                        }
-                        return null;
-                      },
-                    ),
-                    const SizedBox(height: 16),
-                    FilledButton.icon(
-                      onPressed: _changingPassword ? null : _changePassword,
-                      icon: _changingPassword
-                          ? const SizedBox(
-                              width: 18,
-                              height: 18,
-                              child: CircularProgressIndicator(strokeWidth: 2),
-                            )
-                          : const Icon(Icons.lock_reset),
-                      label: Text(
-                        _changingPassword ? 'Updating...' : 'Change password',
-                      ),
-                    ),
-                  ],
-                ),
-              ),
-            ],
           ],
         ),
       ),
     );
   }
 }
+
+class _AccentSwatchButton extends StatelessWidget {
+  const _AccentSwatchButton({
+    required this.color,
+    required this.selected,
+    required this.onTap,
+  });
+
+  final Color color;
+  final bool selected;
+  final VoidCallback onTap;
+
+  @override
+  Widget build(BuildContext context) {
+    final borderColor = selected
+        ? Theme.of(context).colorScheme.onSurface
+        : Colors.black26;
+    return InkWell(
+      onTap: onTap,
+      customBorder: const CircleBorder(),
+      child: Container(
+        width: 40,
+        height: 40,
+        decoration: BoxDecoration(
+          color: color,
+          shape: BoxShape.circle,
+          border: Border.all(
+            color: borderColor,
+            width: selected ? 3 : 1,
+          ),
+          boxShadow: [
+            BoxShadow(
+              color: Colors.black.withValues(alpha: 0.15),
+              blurRadius: 4,
+              offset: const Offset(0, 2),
+            ),
+          ],
+        ),
+        child: selected
+            ? const Center(
+                child: Icon(
+                  Icons.check,
+                  size: 18,
+                  color: Colors.white,
+                ),
+              )
+            : null,
+      ),
+    );
+  }
+}

lib/components/pages/stats.dart

@@ -1,4 +1,5 @@
 import 'package:flutter/material.dart';
+import 'package:go_router/go_router.dart';
 import 'package:intl/intl.dart';
 import 'package:mileograph_flutter/objects/objects.dart';
 import 'package:mileograph_flutter/services/data_service.dart';
@@ -32,7 +33,21 @@ class _StatsPageState extends State<StatsPage> {
     final data = context.watch<DataService>();
     final distanceUnits = context.watch<DistanceUnitService>();
     return Scaffold(
-      appBar: AppBar(title: const Text('Stats')),
+      appBar: AppBar(
+        leading: IconButton(
+          icon: const Icon(Icons.arrow_back),
+          onPressed: () {
+            final nav = Navigator.of(context);
+            if (nav.canPop()) {
+              nav.maybePop();
+            } else {
+              context.go('/more');
+            }
+          },
+          tooltip: 'Back',
+        ),
+        title: const Text('Stats'),
+      ),
       body: RefreshIndicator(
         onRefresh: () => _loadStats(force: true),
         child: _buildContent(data, distanceUnits),

lib/components/pages/traction/traction.dart

@@ -7,6 +7,7 @@ import 'package:mileograph_flutter/components/traction/traction_card.dart';
 import 'package:mileograph_flutter/objects/objects.dart';
 import 'package:mileograph_flutter/services/data_service.dart';
 import 'package:mileograph_flutter/services/distance_unit_service.dart';
+import 'package:mileograph_flutter/services/authservice.dart';
 import 'package:provider/provider.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 

lib/components/pages/traction/traction_page.dart

@@ -1,14 +1,28 @@
 part of 'traction.dart';
 
+enum _TractionMoreAction {
+  classStats,
+  classLeaderboard,
+  adminPending,
+}
+
 class TractionPage extends StatefulWidget {
   const TractionPage({
     super.key,
     this.selectionMode = false,
+    this.selectionSingle = false,
+    this.replacementPendingLocoId,
+    this.transferFromLabel,
+    this.transferFromLocoId,
     this.onSelect,
     this.selectedKeys = const {},
   });
 
   final bool selectionMode;
+  final bool selectionSingle;
+  final int? replacementPendingLocoId;
+  final String? transferFromLabel;
+  final int? transferFromLocoId;
   final ValueChanged<LocoSummary>? onSelect;
   final Set<String> selectedKeys;
 
@@ -23,6 +37,7 @@ class _TractionPageState extends State<TractionPage> {
   final _nameController = TextEditingController();
   bool _mileageFirst = true;
   bool _initialised = false;
+  int? get _transferFromLocoId => widget.transferFromLocoId;
   bool _showAdvancedFilters = false;
   String? _selectedClass;
   late Set<String> _selectedKeys;
@@ -33,6 +48,14 @@ class _TractionPageState extends State<TractionPage> {
   String? _classStatsError;
   String? _classStatsForClass;
   Map<String, dynamic>? _classStats;
+  bool _showClassLeaderboardPanel = false;
+  bool _classLeaderboardLoading = false;
+  String? _classLeaderboardError;
+  String? _classLeaderboardForClass;
+  String? _classFriendsLeaderboardForClass;
+  List<LeaderboardEntry> _classLeaderboard = [];
+  List<LeaderboardEntry> _classFriendsLeaderboard = [];
+  _ClassLeaderboardScope _classLeaderboardScope = _ClassLeaderboardScope.global;
 
   final Map<String, TextEditingController> _dynamicControllers = {};
   final Map<String, String?> _enumSelections = {};
@@ -40,6 +63,8 @@ class _TractionPageState extends State<TractionPage> {
   static const int _pageSize = 100;
   int _lastTractionOffset = 0;
   String? _lastQuerySignature;
+  String? _transferFromLabel;
+  bool _isSearching = false;
 
   @override
   void initState() {
@@ -53,6 +78,7 @@ class _TractionPageState extends State<TractionPage> {
     if (!_initialised) {
       _initialised = true;
       _selectedKeys = {...widget.selectedKeys};
+      _transferFromLabel = widget.transferFromLabel;
       WidgetsBinding.instance.addPostFrameCallback((_) {
         _initialLoad();
       });
@@ -61,12 +87,16 @@ class _TractionPageState extends State<TractionPage> {
 
   Future<void> _initialLoad() async {
     final data = context.read<DataService>();
+    final auth = context.read<AuthService>();
     await _restoreSearchState();
     if (_lastTractionOffset == 0 && data.traction.length > _pageSize) {
       _lastTractionOffset = data.traction.length - _pageSize;
     }
     data.fetchClassList();
     data.fetchEventFields();
+    if (auth.isElevated) {
+      unawaited(data.fetchPendingLocoCount());
+    }
     await _refreshTraction();
   }
 
@@ -132,6 +162,7 @@ class _TractionPageState extends State<TractionPage> {
     bool append = false,
     bool preservePosition = true,
   }) async {
+    _setState(() => _isSearching = true);
     final data = context.read<DataService>();
     final filters = <String, dynamic>{};
     final name = _nameController.text.trim();
@@ -190,6 +221,7 @@ class _TractionPageState extends State<TractionPage> {
     }
 
     await _persistSearchState();
+    _setState(() => _isSearching = false);
   }
 
   void _clearFilters() {
@@ -211,6 +243,13 @@ class _TractionPageState extends State<TractionPage> {
       _classStats = null;
       _classStatsError = null;
       _classStatsForClass = null;
+      _showClassLeaderboardPanel = false;
+      _classLeaderboard = [];
+      _classFriendsLeaderboard = [];
+      _classLeaderboardError = null;
+      _classLeaderboardForClass = null;
+      _classFriendsLeaderboardForClass = null;
+      _classLeaderboardScope = _ClassLeaderboardScope.global;
     });
     _refreshTraction();
   }
@@ -223,6 +262,7 @@ class _TractionPageState extends State<TractionPage> {
       });
     }
     _refreshClassStatsIfOpen();
+    _refreshClassLeaderboardIfOpen();
   }
 
   List<EventField> _activeEventFields(List<EventField> fields) {
@@ -280,6 +320,7 @@ class _TractionPageState extends State<TractionPage> {
     final isMobile = MediaQuery.of(context).size.width < 700;
     _syncControllersForFields(data.eventFields);
     final extraFields = _activeEventFields(data.eventFields);
+    final transferBanner = _buildTransferBanner(data);
 
     final slivers = <Widget>[
       SliverPadding(
@@ -309,6 +350,10 @@ class _TractionPageState extends State<TractionPage> {
                   _buildHeaderActions(context, isMobile),
                 ],
               ),
+              if (transferBanner != null) ...[
+                const SizedBox(height: 8),
+                transferBanner,
+              ],
               const SizedBox(height: 12),
               Card(
                 child: Padding(
@@ -405,6 +450,7 @@ class _TractionPageState extends State<TractionPage> {
                             });
                             _refreshTraction();
                             _refreshClassStatsIfOpen(immediate: true);
+                            _refreshClassLeaderboardIfOpen(immediate: true);
                           },
                         ),
                       ),
@@ -457,8 +503,25 @@ class _TractionPageState extends State<TractionPage> {
                           ),
                           ElevatedButton.icon(
                             onPressed: _refreshTraction,
-                            icon: const Icon(Icons.search),
+                            icon: (_isSearching || data.isTractionLoading)
-                            label: const Text('Search'),
+                                ? SizedBox(
+                                    width: 16,
+                                    height: 16,
+                                    child: CircularProgressIndicator(
+                                      strokeWidth: 2,
+                                      valueColor: AlwaysStoppedAnimation<Color>(
+                                        Theme.of(context)
+                                            .colorScheme
+                                            .onPrimary,
+                                      ),
+                                    ),
+                                  )
+                                : const Icon(Icons.search),
+                            label: Text(
+                              (_isSearching || data.isTractionLoading)
+                                  ? 'Searching...'
+                                  : 'Search',
+                            ),
                           ),
                         ],
                       ),
@@ -518,6 +581,19 @@ class _TractionPageState extends State<TractionPage> {
           ),
         ),
       ),
+      SliverPadding(
+        padding: const EdgeInsets.fromLTRB(16, 0, 16, 8),
+        sliver: SliverToBoxAdapter(
+          child: AnimatedCrossFade(
+            crossFadeState: (_showClassLeaderboardPanel && _hasClassQuery)
+                ? CrossFadeState.showFirst
+                : CrossFadeState.showSecond,
+            duration: const Duration(milliseconds: 200),
+            firstChild: _buildClassLeaderboardCard(context),
+            secondChild: const SizedBox.shrink(),
+          ),
+        ),
+      ),
       SliverPadding(
         padding: const EdgeInsets.fromLTRB(16, 0, 16, 16),
         sliver: _buildTractionSliver(context, data, traction),
@@ -569,23 +645,20 @@ class _TractionPageState extends State<TractionPage> {
   }
 
   Widget _buildHeaderActions(BuildContext context, bool isMobile) {
+    final isElevated = context.read<AuthService>().isElevated;
+    final data = context.watch<DataService>();
+    final pendingCount = data.pendingLocoCount;
+    String? pendingLabel;
+    if (pendingCount > 0) {
+      pendingLabel = pendingCount > 999 ? '999+' : pendingCount.toString();
+    }
     final refreshButton = IconButton(
       tooltip: 'Refresh',
       onPressed: _refreshTraction,
       icon: const Icon(Icons.refresh),
     );
 
-    final classStatsButton = !_hasClassQuery
+    final hasClassActions = _hasClassQuery;
-        ? null
-        : FilledButton.tonalIcon(
-            onPressed: _toggleClassStatsPanel,
-            icon: Icon(
-              _showClassStatsPanel ? Icons.bar_chart : Icons.insights,
-            ),
-            label: Text(
-              _showClassStatsPanel ? 'Hide class stats' : 'Class stats',
-            ),
-          );
 
     final newTractionButton = FilledButton.icon(
       onPressed: () async {
@@ -605,15 +678,123 @@ class _TractionPageState extends State<TractionPage> {
       label: const Text('New Traction'),
     );
 
+    final hasAdminActions = isElevated;
+    final hasMoreMenu = hasClassActions || hasAdminActions;
+
+    final moreButton = !hasMoreMenu
+        ? null
+        : PopupMenuButton<_TractionMoreAction>(
+            tooltip: 'More options',
+            onSelected: (action) async {
+              switch (action) {
+                case _TractionMoreAction.classStats:
+                  _toggleClassStatsPanel();
+                  break;
+                case _TractionMoreAction.classLeaderboard:
+                  _toggleClassLeaderboardPanel();
+                  break;
+                case _TractionMoreAction.adminPending:
+                  final messenger = ScaffoldMessenger.of(context);
+                  try {
+                    await context.push('/traction/pending');
+                    if (!mounted) return;
+                    await data.fetchPendingLocoCount();
+                  } catch (_) {
+                    if (!mounted) return;
+                    messenger.showSnackBar(
+                      const SnackBar(
+                        content: Text('Unable to open pending locos'),
+                      ),
+                    );
+                  }
+                  break;
+              }
+            },
+            itemBuilder: (context) {
+              final items = <PopupMenuEntry<_TractionMoreAction>>[];
+              if (hasClassActions) {
+                items.add(
+                  PopupMenuItem(
+                    value: _TractionMoreAction.classStats,
+                    child: Row(
+                      children: [
+                        Icon(
+                          _showClassStatsPanel ? Icons.check : Icons.check_box_outline_blank,
+                          size: 18,
+                        ),
+                        const SizedBox(width: 8),
+                        const Text('Class stats'),
+                      ],
+                    ),
+                  ),
+                );
+              }
+              if (hasClassActions) {
+                items.add(
+                  PopupMenuItem(
+                    value: _TractionMoreAction.classLeaderboard,
+                    child: Row(
+                      children: [
+                        Icon(
+                          _showClassLeaderboardPanel
+                              ? Icons.check
+                              : Icons.check_box_outline_blank,
+                          size: 18,
+                        ),
+                        const SizedBox(width: 8),
+                        const Text('Class leaderboard'),
+                      ],
+                    ),
+                  ),
+                );
+              }
+              if (items.isNotEmpty && hasAdminActions) {
+                items.add(const PopupMenuDivider());
+              }
+              if (hasAdminActions) {
+                items.add(
+                  PopupMenuItem(
+                    value: _TractionMoreAction.adminPending,
+                    child: Row(
+                      children: [
+                        const Text('Pending locos'),
+                        const Spacer(),
+                        if (pendingLabel != null)
+                          _countChip(context, pendingLabel),
+                      ],
+                    ),
+                  ),
+                );
+              }
+              return items;
+            },
+            child: IgnorePointer(
+              child: FilledButton.tonalIcon(
+                onPressed: () {},
+                icon: const Icon(Icons.more_horiz),
+                label: Row(
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    const Text('More'),
+                    if (pendingLabel != null) ...[
+                      const SizedBox(width: 6),
+                      _countChip(context, pendingLabel),
+                    ],
+                  ],
+                ),
+              ),
+            ),
+          );
+
     final desktopActions = [
       refreshButton,
-      if (classStatsButton != null) classStatsButton,
       newTractionButton,
+      if (moreButton != null) moreButton,
     ];
 
     final mobileActions = [
+      if (moreButton != null) moreButton,
       newTractionButton,
-      if (classStatsButton != null) classStatsButton,
       refreshButton,
     ];
 
@@ -941,6 +1122,42 @@ class _TractionPageState extends State<TractionPage> {
     return total;
   }
 
+  Widget _placementBadge(BuildContext context, int index) {
+    const size = 32.0;
+    const iconSize = 18.0;
+    if (index == 0) {
+      return CircleAvatar(
+        radius: size / 2,
+        backgroundColor: Colors.amber.shade400,
+        child: const Icon(Icons.emoji_events, color: Colors.white, size: iconSize),
+      );
+    }
+    if (index == 1) {
+      return CircleAvatar(
+        radius: size / 2,
+        backgroundColor: Colors.blueGrey.shade200,
+        child: const Icon(Icons.emoji_events, color: Colors.white, size: iconSize),
+      );
+    }
+    if (index == 2) {
+      return CircleAvatar(
+        radius: size / 2,
+        backgroundColor: Colors.brown.shade300,
+        child: const Icon(Icons.emoji_events, color: Colors.white, size: iconSize),
+      );
+    }
+    return CircleAvatar(
+      radius: size / 2,
+      backgroundColor: Theme.of(context).colorScheme.secondaryContainer,
+      child: Text(
+        '${index + 1}',
+        style: Theme.of(context).textTheme.labelLarge?.copyWith(
+              fontWeight: FontWeight.w800,
+            ),
+      ),
+    );
+  }
+
   Color _statusColor(String status, ColorScheme scheme) {
     final key = status.toLowerCase();
     if (key.contains('scrap')) return Colors.red.shade600;
@@ -972,6 +1189,12 @@ class _TractionPageState extends State<TractionPage> {
     if (widget.onSelect != null) {
       widget.onSelect!(loco);
     }
+    if (widget.selectionMode && widget.selectionSingle) {
+      if (mounted) {
+        context.pop(loco);
+      }
+      return;
+    }
     setState(() {
       if (_selectedKeys.contains(keyVal)) {
         _selectedKeys.remove(keyVal);
@@ -981,6 +1204,150 @@ class _TractionPageState extends State<TractionPage> {
     });
   }
 
+  Future<void> _confirmReplacePending(LocoSummary replacement) async {
+    final pendingId = widget.replacementPendingLocoId;
+    if (pendingId == null) return;
+    final navContext = context;
+    final messenger = ScaffoldMessenger.of(navContext);
+    String rejectionReason = '';
+    final confirmed = await showDialog<bool>(
+      context: navContext,
+      builder: (dialogContext) {
+        return StatefulBuilder(
+          builder: (context, setState) {
+            final canSubmit = rejectionReason.trim().isNotEmpty;
+            return AlertDialog(
+              title: const Text('Replace pending loco?'),
+              content: Column(
+                mainAxisSize: MainAxisSize.min,
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  Text(
+                    'Replace pending loco with ${replacement.locoClass} ${replacement.number}?',
+                  ),
+                  const SizedBox(height: 12),
+                  TextField(
+                    autofocus: true,
+                    maxLines: 2,
+                    decoration: const InputDecoration(
+                      labelText: 'Rejection reason',
+                      hintText: 'Reason for replacing this loco',
+                    ),
+                    onChanged: (val) => setState(() {
+                      rejectionReason = val;
+                    }),
+                  ),
+                ],
+              ),
+              actions: [
+                TextButton(
+                  onPressed: () => Navigator.of(dialogContext).pop(false),
+                  child: const Text('Cancel'),
+                ),
+                FilledButton(
+                  onPressed:
+                      canSubmit ? () => Navigator.of(dialogContext).pop(true) : null,
+                  child: const Text('Replace'),
+                ),
+              ],
+            );
+          },
+        );
+      },
+    );
+    if (confirmed != true) return;
+    if (!navContext.mounted) return;
+    try {
+      final data = navContext.read<DataService>();
+      await data.rejectPendingLoco(
+            locoId: pendingId,
+            replacementLocoId: replacement.id,
+            rejectedReason: rejectionReason,
+          );
+      if (navContext.mounted) {
+        messenger.showSnackBar(
+          const SnackBar(content: Text('Pending loco replaced')),
+        );
+        navContext.pop();
+      }
+    } catch (e) {
+      if (navContext.mounted) {
+        messenger.showSnackBar(
+          SnackBar(content: Text('Failed to replace loco: $e')),
+        );
+      }
+    }
+  }
+
+  Future<void> _confirmTransfer(LocoSummary target) async {
+    final fromId = _transferFromLocoId;
+    if (fromId == null) return;
+    final navContext = context;
+    final messenger = ScaffoldMessenger.of(navContext);
+    final data = navContext.read<DataService>();
+    final fromLoco = data.traction.firstWhere(
+      (l) => l.id == fromId,
+      orElse: () => target,
+    );
+    final fromLabel = '${fromLoco.locoClass} ${fromLoco.number}'.trim();
+    final toLabel = '${target.locoClass} ${target.number}'.trim();
+    final confirmed = await showDialog<bool>(
+      context: navContext,
+      builder: (dialogContext) {
+        return AlertDialog(
+          title: const Text('Transfer allocations?'),
+          content: Column(
+            mainAxisSize: MainAxisSize.min,
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              Text(
+                'Transfer all allocations from $fromLabel to $toLabel?',
+              ),
+              const SizedBox(height: 12),
+              Text(
+                'From: $fromLabel',
+                style: Theme.of(dialogContext)
+                    .textTheme
+                    .bodyMedium
+                    ?.copyWith(fontWeight: FontWeight.w700),
+              ),
+              Text('To: $toLabel'),
+            ],
+          ),
+          actions: [
+            TextButton(
+              onPressed: () => Navigator.of(dialogContext).pop(false),
+              child: const Text('Cancel'),
+            ),
+            FilledButton(
+              onPressed: () => Navigator.of(dialogContext).pop(true),
+              child: const Text('Transfer'),
+            ),
+          ],
+        );
+      },
+    );
+    if (confirmed != true) return;
+    if (!navContext.mounted) return;
+    try {
+      final data = navContext.read<DataService>();
+      await data.transferAllocations(fromLocoId: fromId, toLocoId: target.id);
+      if (navContext.mounted) {
+        messenger.showSnackBar(
+          const SnackBar(content: Text('Allocations transferred')),
+        );
+      }
+      await _refreshTraction(preservePosition: true);
+      if (navContext.mounted) navContext.pop();
+    } catch (e) {
+      if (navContext.mounted) {
+        messenger.showSnackBar(
+          SnackBar(content: Text('Failed to transfer allocations: $e')),
+        );
+      }
+    }
+  }
+
   bool _isSelected(LocoSummary loco) {
     final keyVal = '${loco.locoClass}-${loco.number}';
     return _selectedKeys.contains(keyVal);
@@ -1004,6 +1371,69 @@ class _TractionPageState extends State<TractionPage> {
     );
   }
 
+  Widget? _buildTransferBanner(DataService data) {
+    final fromId = _transferFromLocoId;
+    if (fromId == null) return null;
+    if (_transferFromLabel == null || _transferFromLabel!.trim().isEmpty) {
+      final from = data.traction.firstWhere(
+        (loco) => loco.id == fromId,
+        orElse: () => LocoSummary(
+          locoId: fromId,
+          locoType: '',
+          locoNumber: '',
+          locoName: '',
+          locoClass: '',
+          locoOperator: '',
+        ),
+      );
+      final fallbackLabel = '${from.locoClass} ${from.number}'.trim().isEmpty
+          ? 'Loco $fromId'
+          : '${from.locoClass} ${from.number}'.trim();
+      _transferFromLabel = fallbackLabel;
+    }
+    final label = _transferFromLabel ?? 'Loco $fromId';
+    return Container(
+      width: double.infinity,
+      padding: const EdgeInsets.all(12),
+      decoration: BoxDecoration(
+        color: Colors.orange.withValues(alpha: 0.1),
+        borderRadius: BorderRadius.circular(8),
+        border: Border.all(color: Colors.orange.withValues(alpha: 0.4)),
+      ),
+      child: Row(
+        children: [
+          const Icon(Icons.swap_horiz, color: Colors.orange),
+          const SizedBox(width: 8),
+          Expanded(
+            child: Text(
+              'Transferring allocations from $label. Select a loco to transfer to.',
+              style: const TextStyle(fontWeight: FontWeight.w600),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _countChip(BuildContext context, String label) {
+    final scheme = Theme.of(context).colorScheme;
+    return Container(
+      padding: const EdgeInsets.symmetric(horizontal: 6, vertical: 2),
+      decoration: BoxDecoration(
+        color: scheme.primary,
+        borderRadius: BorderRadius.circular(12),
+      ),
+      child: Text(
+        label,
+        style: TextStyle(
+          color: scheme.onPrimary,
+          fontWeight: FontWeight.w700,
+          fontSize: 12,
+        ),
+      ),
+    );
+  }
+
   Widget _buildFilterInput(
     BuildContext context,
     EventField field,
@@ -1113,16 +1543,38 @@ class _TractionPageState extends State<TractionPage> {
         (context, index) {
           if (index < traction.length) {
             final loco = traction[index];
-            return TractionCard(
+              return TractionCard(
-              loco: loco,
+                loco: loco,
-              selectionMode: widget.selectionMode,
+                selectionMode: widget.selectionMode,
-              isSelected: _isSelected(loco),
+                isSelected: _isSelected(loco),
-              onShowInfo: () => showTractionDetails(context, loco),
+                onShowInfo: () => showTractionDetails(
-              onOpenTimeline: () => _openTimeline(loco),
+                  context,
-              onOpenLegs: () => _openLegs(loco),
+                  loco,
-              onToggleSelect:
+                  onActionComplete: () => _refreshTraction(preservePosition: true),
-                  widget.selectionMode ? () => _toggleSelection(loco) : null,
+                ),
-            );
+                onOpenTimeline: () => _openTimeline(loco),
+                onOpenLegs: () => _openLegs(loco),
+                onActionComplete: _refreshTraction,
+                onToggleSelect: widget.selectionMode &&
+                        widget.replacementPendingLocoId == null &&
+                        (widget.transferFromLocoId == null ||
+                            widget.transferFromLocoId != loco.id)
+                    ? () => _toggleSelection(loco)
+                    : null,
+                onReplacePending: widget.selectionMode &&
+                        widget.selectionSingle &&
+                        widget.replacementPendingLocoId != null &&
+                        (widget.transferFromLocoId == null ||
+                            widget.transferFromLocoId != loco.id)
+                    ? () => _confirmReplacePending(loco)
+                    : null,
+                onTransferAllocations: widget.selectionMode &&
+                        widget.selectionSingle &&
+                        widget.transferFromLocoId != null &&
+                        widget.transferFromLocoId != loco.id
+                    ? () => _confirmTransfer(loco)
+                    : null,
+              );
           }
 
           return Padding(
@@ -1147,4 +1599,212 @@ class _TractionPageState extends State<TractionPage> {
       ),
     );
   }
+
+  Future<void> _toggleClassLeaderboardPanel() async {
+    if (!_hasClassQuery) return;
+    final targetState = !_showClassLeaderboardPanel;
+    setState(() {
+      _showClassLeaderboardPanel = targetState;
+    });
+    if (targetState) {
+      await _loadClassLeaderboard(friends: _classLeaderboardScope == _ClassLeaderboardScope.friends);
+    }
+  }
+
+  void _refreshClassLeaderboardIfOpen({bool immediate = false}) {
+    if (!_showClassLeaderboardPanel || !_hasClassQuery) return;
+    final query = (_selectedClass ?? _classController.text).trim();
+    final scope = _classLeaderboardScope;
+    final currentData = scope == _ClassLeaderboardScope.global
+        ? _classLeaderboard
+        : _classFriendsLeaderboard;
+    final currentClass = scope == _ClassLeaderboardScope.global
+        ? _classLeaderboardForClass
+        : _classFriendsLeaderboardForClass;
+    if (!immediate && currentClass == query && currentData.isNotEmpty) {
+      return;
+    }
+    _loadClassLeaderboard(
+      friends: scope == _ClassLeaderboardScope.friends,
+    );
+  }
+
+  Future<void> _loadClassLeaderboard({required bool friends}) async {
+    final query = (_selectedClass ?? _classController.text).trim();
+    if (query.isEmpty) return;
+    final currentClass = friends ? _classFriendsLeaderboardForClass : _classLeaderboardForClass;
+    final currentData = friends ? _classFriendsLeaderboard : _classLeaderboard;
+    if (currentClass == query && currentData.isNotEmpty) return;
+    setState(() {
+      _classLeaderboardLoading = true;
+      _classLeaderboardError = null;
+      if (friends && _classFriendsLeaderboardForClass != query) {
+        _classFriendsLeaderboard = [];
+      } else if (!friends && _classLeaderboardForClass != query) {
+        _classLeaderboard = [];
+      }
+    });
+    try {
+      final data = context.read<DataService>();
+      final leaderboard = await data.fetchClassLeaderboard(
+        query,
+        friends: friends,
+      );
+      if (!mounted) return;
+      setState(() {
+        if (friends) {
+          _classFriendsLeaderboard = leaderboard;
+          _classFriendsLeaderboardForClass = query;
+        } else {
+          _classLeaderboard = leaderboard;
+          _classLeaderboardForClass = query;
+        }
+        _classLeaderboardError = null;
+      });
+    } catch (e) {
+      if (!mounted) return;
+      setState(() {
+        _classLeaderboardError = 'Failed to load class leaderboard: $e';
+      });
+    } finally {
+      if (mounted) {
+        setState(() {
+          _classLeaderboardLoading = false;
+        });
+      }
+    }
+  }
+
+  Widget _buildClassLeaderboardCard(BuildContext context) {
+    final scheme = Theme.of(context).colorScheme;
+    final distanceUnits = context.watch<DistanceUnitService>();
+    final leaderboard = _classLeaderboardScope == _ClassLeaderboardScope.global
+        ? _classLeaderboard
+        : _classFriendsLeaderboard;
+    final loading = _classLeaderboardLoading;
+    final error = _classLeaderboardError;
+    return Card(
+      child: Padding(
+        padding: const EdgeInsets.all(16.0),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Row(
+              children: [
+                Expanded(
+                  child: Text(
+                    (_selectedClass ?? _classController.text).trim().isEmpty
+                        ? 'Class leaderboard'
+                        : '${(_selectedClass ?? _classController.text).trim()} leaderboard',
+                    style: Theme.of(context).textTheme.titleMedium,
+                  ),
+                ),
+                SegmentedButton<_ClassLeaderboardScope>(
+                  segments: const [
+                    ButtonSegment(
+                      value: _ClassLeaderboardScope.global,
+                      label: Text('Global'),
+                    ),
+                    ButtonSegment(
+                      value: _ClassLeaderboardScope.friends,
+                      label: Text('Friends'),
+                    ),
+                  ],
+                  selected: {_classLeaderboardScope},
+                  onSelectionChanged: (vals) async {
+                    if (vals.isEmpty) return;
+                    final selected = vals.first;
+                    setState(() => _classLeaderboardScope = selected);
+                    if (selected == _ClassLeaderboardScope.friends &&
+                        _classFriendsLeaderboard.isEmpty &&
+                        !_classLeaderboardLoading) {
+                      await _loadClassLeaderboard(friends: true);
+                    } else if (selected == _ClassLeaderboardScope.global &&
+                        _classLeaderboard.isEmpty &&
+                        !_classLeaderboardLoading) {
+                      await _loadClassLeaderboard(friends: false);
+                    }
+                  },
+                  style: SegmentedButton.styleFrom(
+                    visualDensity: VisualDensity.compact,
+                    padding: const EdgeInsets.symmetric(horizontal: 8),
+                  ),
+                ),
+                const SizedBox(width: 8),
+                IconButton(
+                  tooltip: 'Refresh leaderboard',
+                  icon: const Icon(Icons.refresh),
+                  onPressed: () => _loadClassLeaderboard(
+                    friends: _classLeaderboardScope == _ClassLeaderboardScope.friends,
+                  ),
+                ),
+              ],
+            ),
+            const SizedBox(height: 12),
+            if (loading)
+              Row(
+                children: const [
+                  SizedBox(
+                    height: 16,
+                    width: 16,
+                    child: CircularProgressIndicator(strokeWidth: 2),
+                  ),
+                  SizedBox(width: 12),
+                  Text('Loading leaderboard...'),
+                ],
+              )
+            else if (error != null)
+              Text(
+                error,
+                style: TextStyle(color: scheme.error),
+              )
+            else if (leaderboard.isEmpty)
+              const Text('No leaderboard data yet.')
+            else
+              Column(
+                children: [
+                  for (int i = 0; i < leaderboard.length; i++) ...[
+                    ListTile(
+                      contentPadding: EdgeInsets.zero,
+                      dense: true,
+                      leading: _placementBadge(context, i),
+                      title: Text(
+                        leaderboard[i].userFullName,
+                        style: Theme.of(context).textTheme.titleSmall?.copyWith(
+                              fontWeight: FontWeight.w700,
+                            ),
+                      ),
+                      trailing: Text(
+                        distanceUnits.format(
+                          leaderboard[i].mileage,
+                          decimals: 1,
+                        ),
+                        style: Theme.of(context).textTheme.labelLarge?.copyWith(
+                              fontWeight: FontWeight.w700,
+                            ),
+                      ),
+                      onTap: () {
+                        final auth = context.read<AuthService>();
+                        final userId = leaderboard[i].userId;
+                        if (auth.userId == userId) {
+                          context.go('/more/profile');
+                        } else {
+                          context.pushNamed(
+                            'user-profile',
+                            queryParameters: {'user_id': userId},
+                          );
+                        }
+                      },
+                    ),
+                    if (i != leaderboard.length - 1) const Divider(height: 12),
+                  ],
+                ],
+              ),
+          ],
+        ),
+      ),
+    );
+  }
 }
+
+enum _ClassLeaderboardScope { global, friends }

lib/components/pages/traction/traction_pending_page.dart

@@ -0,0 +1,140 @@
+import 'package:flutter/material.dart';
+import 'package:go_router/go_router.dart';
+import 'package:mileograph_flutter/components/traction/traction_card.dart';
+import 'package:mileograph_flutter/objects/objects.dart';
+import 'package:mileograph_flutter/services/api_service.dart';
+import 'package:provider/provider.dart';
+
+class TractionPendingPage extends StatefulWidget {
+  const TractionPendingPage({super.key});
+
+  @override
+  State<TractionPendingPage> createState() => _TractionPendingPageState();
+}
+
+class _TractionPendingPageState extends State<TractionPendingPage> {
+  bool _isLoading = false;
+  String? _error;
+  List<LocoSummary> _locos = const [];
+
+  @override
+  void initState() {
+    super.initState();
+    WidgetsBinding.instance.addPostFrameCallback((_) => _load());
+  }
+
+  Future<void> _load() async {
+    setState(() {
+      _isLoading = true;
+      _error = null;
+    });
+    try {
+      final api = context.read<ApiService>();
+      final params = '?limit=200&offset=0';
+      final json = await api.get('/loco/pending$params');
+      if (json is List) {
+        setState(() {
+          _locos = json
+              .whereType<Map>()
+              .map((e) => LocoSummary.fromJson(
+                    e.map((k, v) => MapEntry(k.toString(), v)),
+                  ))
+              .toList();
+        });
+      } else {
+        setState(() {
+          _error = 'Unexpected response';
+          _locos = const [];
+        });
+      }
+    } catch (e) {
+      setState(() {
+        _error = e.toString();
+        _locos = const [];
+      });
+    } finally {
+      if (mounted) {
+        setState(() {
+          _isLoading = false;
+        });
+      }
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        leading: IconButton(
+          icon: const Icon(Icons.arrow_back),
+          onPressed: () => Navigator.of(context).maybePop(),
+        ),
+        title: const Text('Pending traction'),
+      ),
+      body: RefreshIndicator(
+        onRefresh: _load,
+        child: _buildBody(context),
+      ),
+    );
+  }
+
+  Widget _buildBody(BuildContext context) {
+    if (_isLoading && _locos.isEmpty) {
+      return const Center(child: CircularProgressIndicator());
+    }
+    if (_error != null) {
+      return ListView(
+        padding: const EdgeInsets.all(16),
+        children: [
+          Text(
+            'Failed to load pending traction: $_error',
+            style: Theme.of(context)
+                .textTheme
+                .bodyMedium
+                ?.copyWith(color: Theme.of(context).colorScheme.error),
+          ),
+          const SizedBox(height: 12),
+          FilledButton.icon(
+            onPressed: _load,
+            icon: const Icon(Icons.refresh),
+            label: const Text('Retry'),
+          ),
+        ],
+      );
+    }
+    if (_locos.isEmpty) {
+      return ListView(
+        padding: const EdgeInsets.all(16),
+        children: const [
+          Text('No pending traction found.'),
+        ],
+      );
+    }
+    return ListView.builder(
+      padding: const EdgeInsets.all(12),
+      itemCount: _locos.length,
+      itemBuilder: (context, index) {
+        final loco = _locos[index];
+        return Padding(
+          padding: const EdgeInsets.symmetric(vertical: 6.0),
+          child: TractionCard(
+            loco: loco,
+            selectionMode: false,
+            isSelected: false,
+            onShowInfo: () => showTractionDetails(
+              context,
+              loco,
+              onActionComplete: _load,
+            ),
+            onOpenTimeline: () => context.push(
+              '/traction/${loco.id}/timeline',
+              extra: {'label': '${loco.locoClass} ${loco.number}'.trim()},
+            ),
+            onOpenLegs: () => context.push('/traction/${loco.id}/legs'),
+            onActionComplete: _load,
+          ),
+        );
+      },
+    );
+  }
+}

lib/components/traction/traction_card.dart

@@ -1,6 +1,10 @@
 import 'package:flutter/material.dart';
+import 'package:go_router/go_router.dart';
+import 'package:intl/intl.dart';
 import 'package:mileograph_flutter/objects/objects.dart';
 import 'package:mileograph_flutter/services/api_service.dart';
+import 'package:mileograph_flutter/services/authservice.dart';
+import 'package:mileograph_flutter/services/data_service.dart';
 import 'package:mileograph_flutter/services/distance_unit_service.dart';
 import 'package:provider/provider.dart';
 
@@ -14,6 +18,9 @@ class TractionCard extends StatelessWidget {
     required this.onOpenTimeline,
     this.onOpenLegs,
     this.onToggleSelect,
+    this.onReplacePending,
+    this.onActionComplete,
+    this.onTransferAllocations,
   });
 
   final LocoSummary loco;
@@ -23,12 +30,20 @@ class TractionCard extends StatelessWidget {
   final VoidCallback onOpenTimeline;
   final VoidCallback? onOpenLegs;
   final VoidCallback? onToggleSelect;
+  final VoidCallback? onReplacePending;
+  final Future<void> Function()? onActionComplete;
+  final VoidCallback? onTransferAllocations;
 
   @override
   Widget build(BuildContext context) {
     final status = loco.status ?? 'Unknown';
     final operatorName = loco.operator ?? '';
     final domain = loco.domain ?? '';
+    final isVisibilityPending =
+        (loco.visibility ?? '').toLowerCase().trim() == 'pending';
+    final isRejected =
+        (loco.visibility ?? '').toLowerCase().contains('reject');
+    final isElevated = context.read<AuthService>().isElevated;
     final hasMileageOrTrips = _hasMileageOrTrips(loco);
     final statusColors = _statusChipColors(context, status);
     final distanceUnits = context.watch<DistanceUnitService>();
@@ -45,23 +60,14 @@ class TractionCard extends StatelessWidget {
                 Column(
                   crossAxisAlignment: CrossAxisAlignment.start,
                   children: [
-                    Row(
+                    _LocoNumberWithHistory(
-                      children: [
+                      number: loco.number,
-                        Text(
+                      matchedNumber: loco.matchedNumber,
-                          loco.number,
+                      matchedNumberValidTo: loco.matchedNumberValidTo,
-                          style: Theme.of(context).textTheme.headlineSmall
+                      hasMileageOrTrips: hasMileageOrTrips,
-                              ?.copyWith(fontWeight: FontWeight.w800),
+                      largeStyle: Theme.of(context).textTheme.headlineSmall,
-                        ),
+                      showPendingChip: isVisibilityPending,
-                        if (hasMileageOrTrips)
+                      showRejectedChip: isRejected && !isVisibilityPending,
-                          Padding(
-                            padding: const EdgeInsets.only(left: 6.0),
-                            child: Icon(
-                              Icons.check_circle,
-                              size: 18,
-                              color: Colors.green.shade600,
-                            ),
-                          ),
-                      ],
                     ),
                     Text(
                       loco.locoClass,
@@ -78,10 +84,42 @@ class TractionCard extends StatelessWidget {
                       ),
                   ],
                 ),
-                Chip(
+                Row(
-                  label: Text(status),
+                  mainAxisSize: MainAxisSize.min,
-                  backgroundColor: statusColors.$1,
+                  children: [
-                  labelStyle: TextStyle(color: statusColors.$2),
+                    if (isElevated && isVisibilityPending) ...[
+                    PopupMenuButton<_PendingLocoAction>(
+                      tooltip: 'Pending options',
+                      onSelected: (action) => _handlePendingAction(
+                        context,
+                        action,
+                        loco,
+                        onActionComplete: onActionComplete,
+                      ),
+                      itemBuilder: (context) => const [
+                        PopupMenuItem(
+                          value: _PendingLocoAction.accept,
+                          child: Text('Accept loco'),
+                        ),
+                        PopupMenuItem(
+                          value: _PendingLocoAction.reject,
+                          child: Text('Reject loco'),
+                        ),
+                        PopupMenuItem(
+                          value: _PendingLocoAction.replace,
+                          child: Text('Replace...'),
+                        ),
+                      ],
+                      icon: const Icon(Icons.more_vert),
+                    ),
+                      const SizedBox(width: 6),
+                    ],
+                    Chip(
+                      label: Text(status),
+                      backgroundColor: statusColors.$1,
+                      labelStyle: TextStyle(color: statusColors.$2),
+                    ),
+                  ],
                 ),
               ],
             ),
@@ -108,17 +146,31 @@ class TractionCard extends StatelessWidget {
                     ),
                 ];
 
-                final addButton = selectionMode && onToggleSelect != null
+                // Prefer replace action when picking a replacement loco.
+                final addButton = onTransferAllocations != null
                     ? TextButton.icon(
-                        onPressed: onToggleSelect,
+                        onPressed: onTransferAllocations,
-                        icon: Icon(
+                        icon: const Icon(Icons.swap_horiz),
-                          isSelected
+                        label: const Text('Transfer'),
-                              ? Icons.remove_circle_outline
-                              : Icons.add_circle_outline,
-                        ),
-                        label: Text(isSelected ? 'Remove' : 'Add to entry'),
                       )
-                    : null;
+                    : onReplacePending != null
+                        ? TextButton.icon(
+                            onPressed: onReplacePending,
+                            icon: const Icon(Icons.swap_horiz),
+                            label: const Text('Replace'),
+                          )
+                        : (!isRejected && selectionMode && onToggleSelect != null)
+                            ? TextButton.icon(
+                                onPressed: onToggleSelect,
+                                icon: Icon(
+                                  isSelected
+                                      ? Icons.remove_circle_outline
+                                      : Icons.add_circle_outline,
+                                ),
+                                label:
+                                    Text(isSelected ? 'Remove' : 'Add to entry'),
+                              )
+                            : null;
 
                 if (isNarrow) {
                   return Column(
@@ -205,13 +257,327 @@ class TractionCard extends StatelessWidget {
   }
 }
 
+class _LocoNumberWithHistory extends StatelessWidget {
+  const _LocoNumberWithHistory({
+    required this.number,
+    required this.matchedNumber,
+    required this.matchedNumberValidTo,
+    required this.hasMileageOrTrips,
+    this.largeStyle,
+    this.showPendingChip = false,
+    this.showRejectedChip = false,
+  });
+
+  final String number;
+  final String? matchedNumber;
+  final DateTime? matchedNumberValidTo;
+  final bool hasMileageOrTrips;
+  final TextStyle? largeStyle;
+  final bool showPendingChip;
+  final bool showRejectedChip;
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final historicNumber = matchedNumber?.trim() ?? '';
+    final hasHistoricDate = matchedNumberValidTo != null;
+    final showHistoric = historicNumber.isNotEmpty && hasHistoricDate;
+    final historicDate =
+        hasHistoricDate ? DateFormat('yyyy-MM-dd').format(matchedNumberValidTo!) : null;
+
+    return Row(
+      children: [
+        Text(
+          number,
+          style: (largeStyle ?? theme.textTheme.titleLarge)?.copyWith(
+            fontWeight: FontWeight.w800,
+          ),
+        ),
+        if (hasMileageOrTrips)
+          Padding(
+            padding: const EdgeInsets.only(left: 6.0),
+            child: Icon(
+              Icons.check_circle,
+              size: 18,
+              color: Colors.green.shade600,
+            ),
+          ),
+        if (showPendingChip) ...[
+          const SizedBox(width: 8),
+          Container(
+            padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
+            decoration: BoxDecoration(
+              color: theme.colorScheme.surfaceContainerHighest,
+              borderRadius: BorderRadius.circular(8),
+            ),
+            child: Row(
+              mainAxisSize: MainAxisSize.min,
+              children: [
+                const Icon(Icons.pending, size: 14),
+                const SizedBox(width: 4),
+                Text(
+                  'Pending',
+                  style: theme.textTheme.labelSmall
+                      ?.copyWith(fontWeight: FontWeight.w700),
+                ),
+              ],
+            ),
+          ),
+        ],
+        if (showRejectedChip) ...[
+          const SizedBox(width: 8),
+          Container(
+            padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
+            decoration: BoxDecoration(
+              color: Colors.red.shade700,
+              borderRadius: BorderRadius.circular(8),
+            ),
+            child: Row(
+              mainAxisSize: MainAxisSize.min,
+              children: [
+                const Icon(Icons.close, size: 14, color: Colors.white),
+                const SizedBox(width: 4),
+                Text(
+                  'Rejected',
+                  style: theme.textTheme.labelSmall?.copyWith(
+                    fontWeight: FontWeight.w700,
+                    color: Colors.white,
+                  ),
+                ),
+              ],
+            ),
+          ),
+        ],
+        if (showHistoric) ...[
+          const SizedBox(width: 8),
+          Text(
+            historicNumber,
+            style: theme.textTheme.labelMedium?.copyWith(
+              fontWeight: FontWeight.w800,
+              color: theme.colorScheme.onSurfaceVariant,
+            ),
+          ),
+          if (historicDate != null) ...[
+            const SizedBox(width: 6),
+            Text(
+              'until $historicDate',
+              style: theme.textTheme.labelSmall?.copyWith(
+                color: theme.colorScheme.onSurfaceVariant,
+              ),
+            ),
+          ],
+        ],
+      ],
+    );
+  }
+}
+
+enum _PendingLocoAction { accept, reject, replace }
+
+Future<void> _handlePendingAction(
+  BuildContext context,
+  _PendingLocoAction action,
+  LocoSummary loco, {
+  Future<void> Function()? onActionComplete,
+}) async {
+  final navContext = context;
+  final messenger = ScaffoldMessenger.of(navContext);
+  final data = navContext.read<DataService>();
+  if (action == _PendingLocoAction.replace) {
+    final path = Uri(
+      path: '/traction',
+      queryParameters: {
+        'selection': 'single',
+        'replacementPendingLocoId': loco.id.toString(),
+      },
+    ).toString();
+    final selected = await navContext.push<LocoSummary>(
+      path,
+      extra: {
+        'selection': 'single',
+        'replacementPendingLocoId': loco.id,
+      },
+    );
+    if (!navContext.mounted) return;
+    if (selected == null) return;
+    String rejectionReason = '';
+    final confirmed = await showDialog<bool>(
+      context: navContext,
+      builder: (dialogContext) {
+        return StatefulBuilder(
+          builder: (context, setState) {
+            final canSubmit = rejectionReason.trim().isNotEmpty;
+            return AlertDialog(
+              title: const Text('Replace pending loco?'),
+              content: Column(
+                mainAxisSize: MainAxisSize.min,
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  Text(
+                    'Replace ${loco.locoClass} ${loco.number} with ${selected.locoClass} ${selected.number}?',
+                  ),
+                  const SizedBox(height: 12),
+                  TextField(
+                    autofocus: true,
+                    maxLines: 2,
+                    decoration: const InputDecoration(
+                      labelText: 'Rejection reason',
+                      hintText: 'Reason for replacing this loco',
+                    ),
+                    onChanged: (val) => setState(() {
+                      rejectionReason = val;
+                    }),
+                  ),
+                ],
+              ),
+              actions: [
+                TextButton(
+                  onPressed: () => Navigator.of(dialogContext).pop(false),
+                  child: const Text('Cancel'),
+                ),
+                FilledButton(
+                  onPressed: canSubmit
+                      ? () => Navigator.of(dialogContext).pop(true)
+                      : null,
+                  child: const Text('Replace'),
+                ),
+              ],
+            );
+          },
+        );
+      },
+    );
+    if (!navContext.mounted) return;
+    if (confirmed != true) return;
+    try {
+      await data.rejectPendingLoco(
+        locoId: loco.id,
+        replacementLocoId: selected.id,
+        rejectedReason: rejectionReason,
+      );
+      await data.fetchClassList(force: true);
+      if (navContext.mounted) {
+        messenger.showSnackBar(
+          const SnackBar(content: Text('Pending loco replaced')),
+        );
+      }
+      await onActionComplete?.call();
+    } catch (e) {
+      messenger.showSnackBar(
+        SnackBar(content: Text('Failed to replace loco: $e')),
+      );
+    }
+    return;
+  }
+  if (action == _PendingLocoAction.reject) {
+    String rejectionReason = '';
+    final confirmed = await showDialog<bool>(
+      context: context,
+      builder: (dialogContext) {
+        return StatefulBuilder(
+          builder: (context, setState) {
+            final canSubmit = rejectionReason.trim().isNotEmpty;
+            return AlertDialog(
+              title: const Text('Reject loco?'),
+              content: Column(
+                mainAxisSize: MainAxisSize.min,
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  TextField(
+                    autofocus: true,
+                    maxLines: 2,
+                    decoration: const InputDecoration(
+                      labelText: 'Rejection reason',
+                      hintText: 'Why is this loco being rejected?',
+                    ),
+                    onChanged: (val) => setState(() {
+                      rejectionReason = val;
+                    }),
+                  ),
+                ],
+              ),
+              actions: [
+                TextButton(
+                  onPressed: () => Navigator.of(context).pop(false),
+                  child: const Text('Cancel'),
+                ),
+                FilledButton(
+                  onPressed: canSubmit
+                      ? () => Navigator.of(context).pop(true)
+                      : null,
+                  child: const Text('Reject'),
+                ),
+              ],
+            );
+          },
+        );
+      },
+    );
+    if (confirmed != true) return;
+
+    if (!navContext.mounted) return;
+    try {
+      await data.rejectPendingLoco(
+        locoId: loco.id,
+        rejectedReason: rejectionReason,
+      );
+      await data.fetchClassList(force: true);
+      if (navContext.mounted) {
+        messenger.showSnackBar(
+          const SnackBar(content: Text('Pending loco rejected')),
+        );
+      }
+      await onActionComplete?.call();
+    } catch (e) {
+      if (navContext.mounted) {
+        messenger.showSnackBar(
+          SnackBar(content: Text('Failed to reject loco: $e')),
+        );
+      }
+    }
+    return;
+  }
+
+  try {
+    await data.acceptPendingLoco(locoId: loco.id);
+    if (navContext.mounted) {
+      messenger.showSnackBar(
+        const SnackBar(content: Text('Pending loco accepted')),
+      );
+    }
+    await onActionComplete?.call();
+  } catch (e) {
+    if (navContext.mounted) {
+      messenger.showSnackBar(
+        SnackBar(content: Text('Failed to accept loco: $e')),
+      );
+    }
+  }
+}
+
 Future<void> showTractionDetails(
   BuildContext context,
-  LocoSummary loco,
+  LocoSummary loco, {
-) async {
+  Future<void> Function()? onActionComplete,
+}) async {
+  final navContext = context;
   final hasMileageOrTrips = _hasMileageOrTrips(loco);
+  final isVisibilityPending =
+      (loco.visibility ?? '').toLowerCase().trim() == 'pending';
+  final isRejected =
+      (loco.visibility ?? '').toLowerCase().contains('reject');
+  final rejectedReason =
+      loco.extra['rejected_reason']?.toString().trim() ?? '';
   final distanceUnits = context.read<DistanceUnitService>();
   final api = context.read<ApiService>();
+  final data = context.read<DataService>();
+  final auth = context.read<AuthService>();
+  final messenger = ScaffoldMessenger.of(context);
+  final userId = auth.userId;
+  final createdBy = loco.extra['created_by']?.toString();
+  final isOwnedByUser =
+      userId != null && createdBy != null && createdBy == userId;
+  final canDeleteAsOwner = isOwnedByUser && (isVisibilityPending || isRejected);
   final leaderboardId = _leaderboardId(loco);
   final leaderboardFuture = leaderboardId == null
       ? Future.value(const <LeaderboardEntry>[])
@@ -227,11 +593,11 @@ Future<void> showTractionDetails(
         builder: (_, controller) {
           return Padding(
             padding: const EdgeInsets.all(16.0),
-            child: Column(
+          child: Column(
-              crossAxisAlignment: CrossAxisAlignment.start,
+            crossAxisAlignment: CrossAxisAlignment.start,
-              children: [
+            children: [
-                Row(
+              Row(
-                  children: [
+                children: [
                     IconButton(
                       icon: const Icon(Icons.close),
                       onPressed: () => Navigator.of(ctx).pop(),
@@ -240,23 +606,13 @@ Future<void> showTractionDetails(
                     Column(
                       crossAxisAlignment: CrossAxisAlignment.start,
                       children: [
-                        Row(
+                        _LocoNumberWithHistory(
-                          children: [
+                          number: loco.number,
-                            Text(
+                          matchedNumber: loco.matchedNumber,
-                              loco.number,
+                          matchedNumberValidTo: loco.matchedNumberValidTo,
-                              style: Theme.of(context).textTheme.titleLarge
+                          hasMileageOrTrips: hasMileageOrTrips,
-                                  ?.copyWith(fontWeight: FontWeight.w800),
+                          showPendingChip: isVisibilityPending,
-                            ),
+                          showRejectedChip: isRejected && !isVisibilityPending,
-                            if (hasMileageOrTrips)
-                              Padding(
-                                padding: const EdgeInsets.only(left: 6.0),
-                                child: Icon(
-                                  Icons.check_circle,
-                                  size: 18,
-                                  color: Colors.green.shade600,
-                                ),
-                              ),
-                          ],
                         ),
                         Text(
                           loco.locoClass,
@@ -274,11 +630,20 @@ Future<void> showTractionDetails(
                       style: Theme.of(context).textTheme.bodyMedium,
                     ),
                   ),
-                const SizedBox(height: 4),
+              const SizedBox(height: 4),
-                Expanded(
+              Expanded(
-                  child: ListView(
+                child: ListView(
-                    controller: controller,
+                  controller: controller,
-                    children: [
+                  children: [
+                    if (isRejected && rejectedReason.isNotEmpty)
+                      ...[
+                        _detailRow(
+                          context,
+                          'Rejection reason',
+                            rejectedReason,
+                          ),
+                          const Divider(),
+                        ],
                       _detailRow(context, 'Status', loco.status ?? 'Unknown'),
                       _detailRow(context, 'Operator', loco.operator ?? ''),
                       _detailRow(context, 'Domain', loco.domain ?? ''),
@@ -355,12 +720,103 @@ Future<void> showTractionDetails(
                                 distanceUnits,
                               );
                             }).toList(),
-                          );
+                      );
-                        },
+                    },
-                      ),
-                    ],
                   ),
-                ),
+                  const SizedBox(height: 16),
+                  FilledButton.icon(
+                    onPressed: () {
+                      Navigator.of(ctx).pop();
+                      final transferLabel = '${loco.locoClass} ${loco.number}'.trim();
+                      navContext.push(
+                        Uri(
+                          path: '/traction',
+                          queryParameters: {
+                            'selection': 'single',
+                            'transferFromLocoId': loco.id.toString(),
+                            'transferFromLabel': transferLabel,
+                          },
+                        ).toString(),
+                        extra: {
+                          'selection': 'single',
+                          'transferFromLocoId': loco.id,
+                          'transferFromLabel': transferLabel,
+                        },
+                      );
+                    },
+                    icon: const Icon(Icons.swap_horiz),
+                    label: const Text('Transfer allocations'),
+                  ),
+                  if (auth.isElevated || canDeleteAsOwner) ...[
+                    const SizedBox(height: 8),
+                    ExpansionTile(
+                      tilePadding: EdgeInsets.zero,
+                      childrenPadding: EdgeInsets.zero,
+                      title: Text(
+                        'More',
+                        style: Theme.of(context).textTheme.titleSmall,
+                      ),
+                      children: [
+                        FilledButton.tonal(
+                          style: FilledButton.styleFrom(
+                            backgroundColor:
+                                Theme.of(context).colorScheme.errorContainer,
+                            foregroundColor:
+                                Theme.of(context).colorScheme.onErrorContainer,
+                          ),
+                          onPressed: () async {
+                            final confirmed = await showDialog<bool>(
+                              context: context,
+                              builder: (context) {
+                                return AlertDialog(
+                                  title: const Text('Delete loco?'),
+                                  content: const Text(
+                                    'This will permanently delete this loco. Are you sure?',
+                                  ),
+                                  actions: [
+                                    TextButton(
+                                      onPressed: () =>
+                                          Navigator.of(context).pop(false),
+                                      child: const Text('Cancel'),
+                                    ),
+                                    FilledButton(
+                                      onPressed: () =>
+                                          Navigator.of(context).pop(true),
+                                      style: FilledButton.styleFrom(
+                                        backgroundColor:
+                                            Theme.of(context).colorScheme.error,
+                                      ),
+                                      child: const Text('Delete'),
+                                    ),
+                                  ],
+                                );
+                              },
+                            );
+                            if (confirmed != true) return;
+                            try {
+                              await data.adminDeleteLoco(locoId: loco.id);
+                              messenger.showSnackBar(
+                                const SnackBar(content: Text('Loco deleted')),
+                              );
+                              await onActionComplete?.call();
+                              if (!context.mounted) return;
+                              Navigator.of(ctx).pop();
+                            } catch (e) {
+                              messenger.showSnackBar(
+                                SnackBar(
+                                    content: Text('Failed to delete loco: $e')),
+                              );
+                            }
+                          },
+                          child: const Text('Delete loco'),
+                        ),
+                        const SizedBox(height: 8),
+                      ],
+                    ),
+                  ],
+                ],
+              ),
+            ),
               ],
             ),
           );

lib/components/widgets/leg_share_edit_notification_card.dart

@@ -0,0 +1,641 @@
+import 'dart:convert';
+
+import 'package:flutter/material.dart';
+import 'package:mileograph_flutter/objects/objects.dart';
+import 'package:mileograph_flutter/services/data_service.dart';
+import 'package:provider/provider.dart';
+
+class LegShareEditNotificationCard extends StatefulWidget {
+  const LegShareEditNotificationCard({super.key, required this.notification});
+
+  final UserNotification notification;
+
+  @override
+  State<LegShareEditNotificationCard> createState() => _LegShareEditNotificationCardState();
+}
+
+class _LegShareEditNotificationCardState extends State<LegShareEditNotificationCard> {
+  Map<String, dynamic>? _changes;
+  int? _legId;
+  int? _shareId;
+  Leg? _currentLeg;
+  LegShareData? _share;
+  Future<LegShareData?>? _shareFuture;
+  bool _loading = false;
+
+  static const int _summaryLimit = 3;
+
+  @override
+  void initState() {
+    super.initState();
+    _parseNotification();
+  }
+
+  @override
+  void didUpdateWidget(covariant LegShareEditNotificationCard oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    if (oldWidget.notification != widget.notification) {
+      _parseNotification(notify: true);
+    }
+  }
+
+  void _parseNotification({bool notify = false}) {
+    final rawBody = widget.notification.body.trim();
+
+    // Reset
+    _shareId = null;
+    _legId = null;
+    _currentLeg = null;
+    _changes = null;
+    _share = null;
+    _shareFuture = null;
+
+    final parsed = _decodeBody(rawBody);
+    if (parsed != null) {
+      _shareId = _parseInt(parsed['share_id']);
+      _legId = _parseInt(parsed['leg_id']);
+      _currentLeg = _findCurrentLeg(_legId);
+      final accepted = _asStringKeyedMap(parsed['accepted_changes']);
+      if (accepted != null) {
+        _changes = accepted;
+      }
+    }
+
+    // Fallback: extract share_id from raw string if still missing.
+    _shareId ??= _extractShareId(rawBody);
+    _prepareShareFuture();
+    if (notify) {
+      setState(() {});
+    }
+  }
+
+  int? _parseInt(dynamic value) {
+    if (value is int) return value;
+    if (value is num) return value.toInt();
+    if (value is String) return int.tryParse(value.trim());
+    return null;
+  }
+
+  Map<String, dynamic>? _decodeBody(String rawBody) {
+    final attempts = <String>[
+      rawBody,
+      _stripWrappingQuotes(rawBody),
+      _replaceSingleQuotes(rawBody),
+    ].where((s) => s.trim().isNotEmpty).toSet();
+
+    for (final attempt in attempts) {
+      final parsed = _decodeJsonToMap(attempt);
+      if (parsed != null) return parsed;
+    }
+    return null;
+  }
+
+  Map<String, dynamic>? _decodeJsonToMap(String source) {
+    dynamic parsed = source;
+    for (int i = 0; i < 3 && parsed is String; i++) {
+      try {
+        parsed = jsonDecode(parsed);
+      } catch (e) {
+        parsed = null;
+        break;
+      }
+    }
+    if (parsed is Map) {
+      final map = parsed.map((k, v) => MapEntry(k.toString(), v));
+      return map;
+    }
+    return null;
+  }
+
+  String _stripWrappingQuotes(String input) {
+    final trimmed = input.trim();
+    if (trimmed.length >= 2 &&
+        ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+            (trimmed.startsWith("'") && trimmed.endsWith("'")))) {
+      return trimmed.substring(1, trimmed.length - 1);
+    }
+    return input;
+  }
+
+  String _replaceSingleQuotes(String input) {
+    if (!input.contains("'")) return input;
+    return input.replaceAll(RegExp(r"(?<!\\)'"), '"');
+  }
+
+  Map<String, dynamic>? _asStringKeyedMap(dynamic value) {
+    if (value is Map) {
+      return value.map((k, v) => MapEntry(k.toString(), v));
+    }
+    if (value is String && value.trim().isNotEmpty) {
+      for (final attempt in [value, _replaceSingleQuotes(value)]) {
+        try {
+          final decoded = jsonDecode(attempt);
+          if (decoded is Map) {
+            return decoded.map((k, v) => MapEntry(k.toString(), v));
+          }
+        } catch (_) {
+          // Ignore; handled by caller.
+        }
+      }
+    }
+    return null;
+  }
+
+  int? _extractShareId(String raw) {
+    final patterns = [
+      RegExp(r'"share_id"\s*:\s*(\d+)'),
+      RegExp(r"'share_id'\s*:\s*(\d+)"),
+      RegExp(r'share_id\s*:\s*(\d+)'),
+      RegExp(r'"share_id"\s*:\s*"(\d+)"'),
+    ];
+    for (final pattern in patterns) {
+      final match = pattern.firstMatch(raw);
+      if (match != null) {
+        final parsed = int.tryParse(match.group(1)!);
+        return parsed;
+      }
+    }
+    return null;
+  }
+
+  Future<void> _loadLegIdIfNeeded() async {
+    if (_legId != null) return;
+    if (_shareId == null) {
+      return;
+    }
+    try {
+      final share = await context.read<DataService>().fetchLegShare(_shareId!.toString());
+      if (!mounted) return;
+      _legId = share?.entry.id;
+      _currentLeg ??= _findCurrentLeg(_legId);
+    } catch (e) {
+      // ignore: avoid_empty_catches
+    }
+  }
+
+  void _prepareShareFuture() {
+    if (_shareId == null) return;
+    _shareFuture = context.read<DataService>().fetchLegShare(_shareId!.toString());
+  }
+
+  Future<void> _loadShareIfNeeded() async {
+    if (_share != null) return;
+    if (_shareId == null) return;
+    try {
+      final future = _shareFuture ??
+          context.read<DataService>().fetchLegShare(_shareId!.toString());
+      final share = await future;
+      if (!mounted) return;
+      _share = share;
+    } catch (e) {
+      // ignore: avoid_empty_catches
+    }
+  }
+
+  Leg? _findCurrentLeg(int? legId) {
+    if (legId == null) return null;
+    final data = context.read<DataService>();
+    try {
+      return data.legs.firstWhere((l) => l.id == legId);
+    } catch (_) {
+      return null;
+    }
+  }
+
+  String _formatDateTime(DateTime dateTime) {
+    return '${dateTime.year.toString().padLeft(4, '0')}-'
+        '${dateTime.month.toString().padLeft(2, '0')}-'
+        '${dateTime.day.toString().padLeft(2, '0')} '
+        '${dateTime.hour.toString().padLeft(2, '0')}:'
+        '${dateTime.minute.toString().padLeft(2, '0')}';
+  }
+
+  Widget _buildLegSummary(BuildContext context) {
+    final future = _shareFuture;
+    if (future == null) {
+      final leg = _currentLeg;
+      return leg == null ? const SizedBox.shrink() : _legSummaryRow(context, leg);
+    }
+
+    return FutureBuilder<LegShareData?>(
+      future: future,
+      builder: (context, snapshot) {
+        final share = snapshot.data;
+        if (share != null) {
+          _share = share;
+        }
+        final leg = share?.entry ?? _currentLeg;
+        if (leg == null) {
+          return const SizedBox.shrink();
+        }
+        return _legSummaryRow(context, leg);
+      },
+    );
+  }
+
+  Widget _legSummaryRow(BuildContext context, Leg leg) {
+    final start = leg.route.isNotEmpty ? leg.route.first : leg.start;
+    final end = leg.route.isNotEmpty ? leg.route.last : leg.end;
+    return Text('${_formatDateTime(leg.beginTime)} • $start → $end');
+  }
+
+  String _asString(dynamic value) {
+    if (value == null) return '';
+    return value.toString();
+  }
+
+  Loco? _resolveLocoById(int locoId, {Leg? shareLeg}) {
+    for (final loco in shareLeg?.locos ?? const <Loco>[]) {
+      if (loco.id == locoId) return loco;
+    }
+    for (final loco in _currentLeg?.locos ?? const <Loco>[]) {
+      if (loco.id == locoId) return loco;
+    }
+    for (final loco in context.read<DataService>().traction) {
+      if (loco.id == locoId) return loco;
+    }
+    return null;
+  }
+
+  String _locoDisplayName(Map<String, dynamic> loco, {Leg? shareLeg}) {
+    final locoId = _parseInt(loco['loco_id']);
+    var locoClass = _asString(loco['class'] ?? loco['loco_class']);
+    var number = _asString(loco['number'] ?? loco['loco_number']);
+    if ((locoClass.isEmpty || number.isEmpty) && locoId != null) {
+      final resolved = _resolveLocoById(locoId, shareLeg: shareLeg);
+      if (resolved != null) {
+        if (locoClass.isEmpty) locoClass = resolved.locoClass;
+        if (number.isEmpty) number = resolved.number;
+      }
+    }
+    final parts = <String>[];
+    if (locoClass.isNotEmpty) parts.add(locoClass);
+    if (number.isNotEmpty) parts.add(number);
+    if (parts.isNotEmpty) return parts.join(' ');
+    return 'Loco ${locoId ?? '?'}';
+  }
+
+
+  @override
+  Widget build(BuildContext context) {
+    final changes = _changes;
+    if (changes == null || changes.isEmpty) {
+      return const Text('No changes supplied.');
+    }
+    final entries = changes.entries.toList();
+    final shown = entries.take(_summaryLimit).toList();
+    final remaining = entries.length - shown.length;
+    final legSummary = _buildLegSummary(context);
+    final hasSummary = _shareFuture != null || _currentLeg != null;
+
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        if (hasSummary) legSummary,
+        if (hasSummary) const SizedBox(height: 8),
+        ...shown.map((e) => _changePreview(context, e)),
+        if (remaining > 0)
+          Padding(
+            padding: const EdgeInsets.only(top: 4.0),
+            child: Text('+$remaining others…', style: Theme.of(context).textTheme.bodySmall),
+          ),
+        const SizedBox(height: 8),
+        Wrap(
+          spacing: 8,
+          runSpacing: 8,
+          children: [
+            ElevatedButton(
+              onPressed: _loading ? null : () => _openDrawer(changes),
+              child: const Text('View changes'),
+            ),
+            TextButton(
+              onPressed: _loading ? null : _dismiss,
+              child: const Text('Dismiss changes'),
+            ),
+          ],
+        ),
+      ],
+    );
+  }
+
+  Widget _changePreview(BuildContext context, MapEntry<String, dynamic> change) {
+    final key = _prettyField(change.key);
+    final value = change.value;
+    String display;
+    if (change.key == 'locos' && value is List) {
+      display = '${value.length} traction update${value.length == 1 ? '' : 's'}';
+    } else {
+      display = _stringify(value);
+    }
+    return Padding(
+      padding: const EdgeInsets.only(top: 4.0),
+      child: Text('$key: $display'),
+    );
+  }
+
+  String _prettyField(String raw) {
+    switch (raw) {
+      case 'leg_notes':
+        return 'Notes';
+      case 'locos':
+        return 'Traction';
+      default:
+        return raw.replaceAll('_', ' ');
+    }
+  }
+
+  dynamic _currentValueForField(Leg leg, String key) {
+    switch (key) {
+      case 'leg_begin_time':
+        return leg.beginTime;
+      case 'leg_end_time':
+        return leg.endTime;
+      case 'leg_origin_time':
+        return leg.originTime;
+      case 'leg_destination_time':
+        return leg.destinationTime;
+      case 'leg_notes':
+        return leg.notes;
+      case 'leg_headcode':
+        return leg.headcode;
+      case 'leg_network':
+        return leg.network;
+      case 'leg_start':
+        return leg.start;
+      case 'leg_end':
+        return leg.end;
+      case 'leg_origin':
+        return leg.origin;
+      case 'leg_destination':
+        return leg.destination;
+      case 'leg_route':
+        return leg.route;
+      case 'leg_mileage':
+        return leg.mileage;
+      case 'leg_begin_delay':
+        return leg.beginDelayMinutes;
+      case 'leg_end_delay':
+        return leg.endDelayMinutes;
+      case 'locos':
+        return leg.locos;
+      default:
+        return null;
+    }
+  }
+
+  Widget _buildChangeValueWidget(
+    String key,
+    dynamic newValue,
+    Leg? currentLeg,
+    Widget Function(List<dynamic>) buildLocos,
+  ) {
+    final currentValue = currentLeg == null ? null : _currentValueForField(currentLeg, key);
+    if (key == 'locos' && newValue is List) {
+      final currentCount = (currentValue is List) ? currentValue.length : 0;
+      return Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Text('Current: $currentCount locos'),
+          const SizedBox(height: 4),
+          const Text('New:'),
+          buildLocos(newValue),
+        ],
+      );
+    }
+
+    final currentStr = _stringify(currentValue);
+    final newStr = _stringify(newValue);
+    return Row(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        Expanded(child: Text(currentStr, maxLines: 3, overflow: TextOverflow.ellipsis)),
+        const Padding(
+          padding: EdgeInsets.symmetric(horizontal: 6.0),
+          child: Icon(Icons.arrow_right_alt, size: 18),
+        ),
+        Expanded(child: Text(newStr, maxLines: 3, overflow: TextOverflow.ellipsis)),
+      ],
+    );
+  }
+
+  String _stringify(dynamic value) {
+    if (value is DateTime) return value.toIso8601String();
+    if (value == null) return '—';
+    if (value is List || value is Map) {
+      return jsonEncode(value);
+    }
+    return value.toString();
+  }
+
+  Future<void> _openDrawer(Map<String, dynamic> changes) async {
+    setState(() => _loading = true);
+    await _loadLegIdIfNeeded();
+    await _loadShareIfNeeded();
+    _currentLeg ??= _findCurrentLeg(_legId);
+    if (!mounted) return;
+    setState(() => _loading = false);
+    final legId = _legId;
+    if (legId == null) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        const SnackBar(content: Text('Unable to load shared leg.')),
+      );
+      return;
+    }
+
+    final selected = Map<String, bool>.fromEntries(
+      changes.keys.map((k) => MapEntry(k, false)),
+    );
+
+    await showModalBottomSheet<void>(
+      context: context,
+      isScrollControlled: true,
+      builder: (ctx) {
+        return StatefulBuilder(
+          builder: (context, setSheetState) {
+            Future<void> apply() async {
+              final payload = <String, dynamic>{};
+              for (final entry in changes.entries) {
+                if (selected[entry.key] == true) {
+                  payload[entry.key] = entry.value;
+                }
+              }
+              if (payload.isEmpty) {
+                Navigator.of(context).pop();
+                return;
+              }
+              final messenger = ScaffoldMessenger.of(context);
+              setSheetState(() => _loading = true);
+              try {
+                final data = context.read<DataService>();
+                await data.applyLegPartialUpdates(
+                  legId: legId,
+                  updates: payload,
+                );
+                if (!context.mounted) return;
+                await data.dismissNotifications([widget.notification.id]);
+                if (!context.mounted) return;
+                messenger.showSnackBar(
+                  const SnackBar(content: Text('Changes applied.')),
+                );
+                Navigator.of(context).pop();
+              } catch (e) {
+                messenger.showSnackBar(
+                  SnackBar(content: Text('Failed to apply changes: $e')),
+                );
+              } finally {
+                setSheetState(() => _loading = false);
+              }
+            }
+
+            Widget buildLocos(List<dynamic> locos) {
+              final parsed = locos
+                  .whereType<Map>()
+                  .map((e) => e.map((k, v) => MapEntry(k.toString(), v)))
+                  .toList();
+              parsed.sort((a, b) => (b['alloc_pos'] ?? 0).compareTo(a['alloc_pos'] ?? 0));
+              final leading = parsed.where((e) => (e['alloc_pos'] ?? 0) > 0).toList();
+              final trailing = parsed.where((e) => (e['alloc_pos'] ?? 0) <= 0).toList();
+
+              List<Widget> chipsFor(List<Map<String, dynamic>> list) {
+                return list
+                    .map(
+                      (loco) => Chip(
+                        backgroundColor:
+                            (loco['alloc_powering'] == 1 || loco['alloc_powering'] == true)
+                                ? Theme.of(context).colorScheme.primary.withValues(alpha: 0.12)
+                                : Theme.of(context).colorScheme.surfaceContainerHighest,
+                        label: Text(
+                          '${_locoDisplayName(loco, shareLeg: _share?.entry)} (pos ${loco['alloc_pos'] ?? '?'})',
+                        ),
+                        avatar: Icon(
+                          Icons.train,
+                          size: 16,
+                          color: (loco['alloc_powering'] == 1 || loco['alloc_powering'] == true)
+                              ? Theme.of(context).colorScheme.primary
+                              : Theme.of(context).hintColor,
+                        ),
+                      ),
+                    )
+                    .toList();
+              }
+
+              return Wrap(
+                spacing: 8,
+                runSpacing: 8,
+                crossAxisAlignment: WrapCrossAlignment.center,
+                children: [
+                  ...chipsFor(leading),
+                  if (leading.isNotEmpty && trailing.isNotEmpty)
+                    const SizedBox(
+                      width: 24,
+                      child: Center(child: Divider(height: 16)),
+                    ),
+                  ...chipsFor(trailing),
+                ],
+              );
+            }
+
+            return SafeArea(
+              child: Padding(
+                padding: EdgeInsets.only(
+                  left: 16,
+                  right: 16,
+                  bottom: MediaQuery.of(context).viewInsets.bottom + 16,
+                  top: 16,
+                ),
+                child: Column(
+                  mainAxisSize: MainAxisSize.min,
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Row(
+                      mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                      children: [
+                        Text('Review changes', style: Theme.of(context).textTheme.titleMedium),
+                        IconButton(
+                          icon: const Icon(Icons.close),
+                          onPressed: () => Navigator.of(context).pop(),
+                        ),
+                      ],
+                    ),
+                    const SizedBox(height: 12),
+                    Row(
+                      children: [
+                        TextButton(
+                          onPressed: () => setSheetState(() {
+                            for (final key in selected.keys) {
+                              selected[key] = true;
+                            }
+                          }),
+                          child: const Text('Select all'),
+                        ),
+                        const Spacer(),
+                        TextButton(
+                          onPressed: () => Navigator.of(context).pop(),
+                          child: const Text('Cancel'),
+                        ),
+                      ],
+                    ),
+                    const SizedBox(height: 8),
+                    ...changes.entries.map((entry) {
+                      final key = entry.key;
+                      final prettyKey = _prettyField(key);
+                      final value = entry.value;
+                      final currentLeg = _currentLeg ?? _findCurrentLeg(_legId);
+                      final valueWidget = _buildChangeValueWidget(
+                        key,
+                        value,
+                        currentLeg,
+                        buildLocos,
+                      );
+                      return Padding(
+                        padding: const EdgeInsets.only(bottom: 12.0),
+                        child: Row(
+                          crossAxisAlignment: CrossAxisAlignment.start,
+                          children: [
+                            Checkbox(
+                              value: selected[key] ?? false,
+                              onChanged: (v) => setSheetState(() {
+                                selected[key] = v ?? false;
+                              }),
+                            ),
+                            Expanded(
+                              child: Column(
+                                crossAxisAlignment: CrossAxisAlignment.start,
+                                children: [
+                                  Text(prettyKey, style: Theme.of(context).textTheme.titleSmall),
+                                  const SizedBox(height: 4),
+                                  valueWidget,
+                                ],
+                              ),
+                            ),
+                          ],
+                        ),
+                      );
+                    }),
+                    Align(
+                      alignment: Alignment.centerRight,
+                      child: FilledButton(
+                        onPressed: _loading ? null : apply,
+                        child: _loading
+                            ? const SizedBox(
+                                height: 18,
+                                width: 18,
+                                child: CircularProgressIndicator(strokeWidth: 2),
+                              )
+                            : const Text('Apply changes'),
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            );
+          },
+        );
+      },
+    );
+  }
+
+  Future<void> _dismiss() async {
+    await context.read<DataService>().dismissNotifications([widget.notification.id]);
+  }
+}

lib/components/widgets/leg_share_notification_card.dart

@@ -1,4 +1,5 @@
 import 'dart:async';
+import 'dart:convert';
 
 import 'package:flutter/material.dart';
 import 'package:go_router/go_router.dart';
@@ -6,16 +7,24 @@ import 'package:mileograph_flutter/objects/objects.dart';
 import 'package:mileograph_flutter/services/data_service.dart';
 import 'package:provider/provider.dart';
 
-class LegShareNotificationCard extends StatelessWidget {
+class LegShareNotificationCard extends StatefulWidget {
   const LegShareNotificationCard({super.key, required this.notification});
 
   final UserNotification notification;
 
+  @override
+  State<LegShareNotificationCard> createState() => _LegShareNotificationCardState();
+}
+
+class _LegShareNotificationCardState extends State<LegShareNotificationCard> {
+  bool _accepting = false;
+  bool _rejecting = false;
+
   @override
   Widget build(BuildContext context) {
     final data = context.read<DataService>();
-    final legShareId = notification.body.trim();
+    final legShareId = _extractLegShareId(widget.notification.body);
-    if (legShareId.isEmpty) {
+    if (legShareId == null) {
       return const Text('Invalid leg share notification.');
     }
     final future = data.fetchLegShare(legShareId);
@@ -77,16 +86,28 @@ class LegShareNotificationCard extends StatelessWidget {
               runSpacing: 8,
               children: [
                 ElevatedButton(
-                  onPressed: () => _accept(context, share),
+                  onPressed: _accepting ? null : () => _accept(context, share),
-                  child: const Text('Accept'),
+                  child: _accepting
+                      ? const SizedBox(
+                          height: 18,
+                          width: 18,
+                          child: CircularProgressIndicator(strokeWidth: 2),
+                        )
+                      : const Text('Accept'),
                 ),
                 OutlinedButton(
                   onPressed: () => _inspect(context, share),
                   child: const Text('Inspect'),
                 ),
                 TextButton(
-                  onPressed: () => _reject(context, share),
+                  onPressed: _rejecting ? null : () => _reject(context, share),
-                  child: const Text('Reject'),
+                  child: _rejecting
+                      ? const SizedBox(
+                          height: 18,
+                          width: 18,
+                          child: CircularProgressIndicator(strokeWidth: 2),
+                        )
+                      : const Text('Reject'),
                 ),
               ],
             ),
@@ -97,12 +118,13 @@ class LegShareNotificationCard extends StatelessWidget {
   }
 
   Future<void> _accept(BuildContext context, LegShareData share) async {
+    setState(() => _accepting = true);
     final data = context.read<DataService>();
     final messenger = ScaffoldMessenger.maybeOf(context);
     try {
       await data.acceptLegShare(share);
       if (!context.mounted) return;
-      await data.dismissNotifications([notification.id]);
+      await data.dismissNotifications([widget.notification.id]);
       // Refresh legs in the background.
       unawaited(data.refreshLegs());
       messenger?.showSnackBar(
@@ -112,16 +134,21 @@ class LegShareNotificationCard extends StatelessWidget {
       messenger?.showSnackBar(
         SnackBar(content: Text('Failed to add shared entry: $e')),
       );
+    } finally {
+      if (mounted) {
+        setState(() => _accepting = false);
+      }
     }
   }
 
   Future<void> _reject(BuildContext context, LegShareData share) async {
+    setState(() => _rejecting = true);
     final data = context.read<DataService>();
     final messenger = ScaffoldMessenger.maybeOf(context);
     try {
       await data.rejectLegShare(share.id);
       if (!context.mounted) return;
-      await data.dismissNotifications([notification.id]);
+      await data.dismissNotifications([widget.notification.id]);
       messenger?.showSnackBar(
         const SnackBar(content: Text('Share rejected')),
       );
@@ -129,6 +156,10 @@ class LegShareNotificationCard extends StatelessWidget {
       messenger?.showSnackBar(
         SnackBar(content: Text('Failed to reject share: $e')),
       );
+    } finally {
+      if (mounted) {
+        setState(() => _rejecting = false);
+      }
     }
   }
 
@@ -139,9 +170,24 @@ class LegShareNotificationCard extends StatelessWidget {
       Navigator.of(context).pop();
     }
     await Future<void>.delayed(Duration.zero);
-    final target = share.copyWith(notificationId: notification.id);
+    final target = share.copyWith(notificationId: widget.notification.id);
     final ts = DateTime.now().millisecondsSinceEpoch;
     final path = '/add?share=${Uri.encodeComponent(share.id)}&ts=$ts';
     router.go(path, extra: target);
   }
+
+  String? _extractLegShareId(String rawBody) {
+    final trimmed = rawBody.trim();
+    if (trimmed.isEmpty) return null;
+    if (RegExp(r'^[0-9]+$').hasMatch(trimmed)) return trimmed;
+    try {
+      final decoded = jsonDecode(trimmed);
+      if (decoded is Map) {
+        final id = decoded['share_id'] ?? decoded['leg_share_id'];
+        final str = id?.toString() ?? '';
+        if (RegExp(r'^[0-9]+$').hasMatch(str)) return str;
+      }
+    } catch (_) {}
+    return null;
+  }
 }

lib/objects/objects.dart

@@ -109,15 +109,21 @@ class UserData {
     required this.fullName,
     required this.userId,
     required this.email,
+    String? entriesVisibility,
+    String? mileageVisibility,
     bool? elevated,
     bool? disabled,
-  })  : elevated = elevated ?? false,
+  })  : entriesVisibility = entriesVisibility ?? 'private',
+        mileageVisibility = mileageVisibility ?? 'private',
+        elevated = elevated ?? false,
         disabled = disabled ?? false;
 
   final String userId;
   final String username;
   final String fullName;
   final String email;
+  final String entriesVisibility;
+  final String mileageVisibility;
   final bool elevated;
   final bool disabled;
 }
@@ -128,6 +134,8 @@ class AuthenticatedUserData extends UserData {
     required super.username,
     required super.fullName,
     required super.email,
+    super.entriesVisibility,
+    super.mileageVisibility,
     bool? elevated,
     bool? isElevated,
     bool? disabled,
@@ -148,6 +156,8 @@ class UserSummary extends UserData {
     required super.fullName,
     required super.userId,
     required super.email,
+    super.entriesVisibility,
+    super.mileageVisibility,
     super.elevated = false,
     super.disabled = false,
   });
@@ -159,11 +169,71 @@ class UserSummary extends UserData {
         fullName: _asString(json['full_name'] ?? json['name']),
         userId: _asString(json['user_id'] ?? json['id']),
         email: _asString(json['email']),
+        entriesVisibility: _asString(
+          json['user_entries_visibility'] ?? json['entries_visibility'],
+          'private',
+        ),
+        mileageVisibility: _asString(
+          json['user_mileage_visibility'] ?? json['mileage_visibility'],
+          'private',
+        ),
         elevated: _asBool(json['elevated'] ?? json['is_elevated'], false),
         disabled: _asBool(json['disabled'], false),
       );
 }
 
+class UserProfileDetail {
+  final String username;
+  final String fullName;
+  final double mileage;
+  final List<LocoSummary> topLocos;
+  final List<Leg> legs;
+  final Map<String, dynamic> privacyInfo;
+  final String friendshipStatus;
+
+  UserProfileDetail({
+    required this.username,
+    required this.fullName,
+    required this.mileage,
+    required this.topLocos,
+    required this.legs,
+    this.privacyInfo = const {},
+    this.friendshipStatus = 'none',
+  });
+
+  factory UserProfileDetail.fromJson(Map<String, dynamic> json) {
+    List<dynamic>? topLocosRaw;
+    final tl = json['top_locos'];
+    if (tl is List) {
+      topLocosRaw = tl;
+    }
+    List<dynamic>? legsRaw;
+    final legData = json['user_legs'];
+    if (legData is List) {
+      legsRaw = legData;
+    }
+    return UserProfileDetail(
+      username: _asString(json['username']),
+      fullName: _asString(json['full_name']),
+      mileage: _asDouble(json['mileage']),
+      topLocos: (topLocosRaw ?? const [])
+          .whereType<Map>()
+          .map((e) => LocoSummary.fromJson(
+                e.map((k, v) => MapEntry(k.toString(), v)),
+              ))
+          .toList(),
+      legs: (legsRaw ?? const [])
+          .whereType<Map>()
+          .map((e) => Leg.fromJson(e.map((k, v) => MapEntry(k.toString(), v))))
+          .toList(),
+      privacyInfo: json['privacy_info'] is Map
+          ? Map<String, dynamic>.from(json['privacy_info'] as Map)
+          : const {},
+      friendshipStatus: _asString(json['friendship_status'], 'none'),
+    );
+  }
+}
+
 class Friendship {
   final String? id;
   final String status;
@@ -350,6 +420,7 @@ class HomepageStats {
   final List<YearlyMileage> yearlyMileage;
   final List<LocoSummary> topLocos;
   final List<LeaderboardEntry> leaderboard;
+  final List<LeaderboardEntry> friendsLeaderboard;
   final List<TripSummary> trips;
   final int legCount;
   final UserData? user;
@@ -359,6 +430,7 @@ class HomepageStats {
     required this.yearlyMileage,
     required this.topLocos,
     required this.leaderboard,
+    required this.friendsLeaderboard,
     required this.trips,
     required this.legCount,
     this.user,
@@ -370,6 +442,17 @@ class HomepageStats {
     final totalMileage = mileageData is Map && mileageData['mileage'] != null
         ? (mileageData['mileage'] as num).toDouble()
         : 0.0;
+    List<LeaderboardEntry> parseLeaderboard(dynamic raw) {
+      if (raw is List) {
+        return raw
+            .whereType<Map>()
+            .map((e) => LeaderboardEntry.fromJson(
+                  e.map((k, v) => MapEntry(k.toString(), v)),
+                ))
+            .toList();
+      }
+      return const [];
+    }
     return HomepageStats(
       totalMileage: totalMileage,
       yearlyMileage: (json['yearly_mileage'] as List? ?? [])
@@ -378,9 +461,9 @@ class HomepageStats {
       topLocos: (json['top_locos'] as List? ?? [])
           .map((e) => LocoSummary.fromJson(e))
           .toList(),
-      leaderboard: (json['leaderboard_data'] as List? ?? [])
+      leaderboard: parseLeaderboard(json['leaderboard_data'] ?? json['leaderboard']),
-          .map((e) => LeaderboardEntry.fromJson(e))
+      friendsLeaderboard:
-          .toList(),
+          parseLeaderboard(json['friends_leaderboard'] ?? json['friendsLeaderboard']),
       trips: (json['trip_data'] as List? ?? [])
           .map((e) => TripSummary.fromJson(e))
           .toList(),
@@ -395,6 +478,16 @@ class HomepageStats {
               fullName: userData['full_name'] ?? '',
               userId: userData['user_id'] ?? '',
               email: userData['email'] ?? '',
+              entriesVisibility: _asString(
+                userData['user_entries_visibility'] ??
+                    userData['entries_visibility'],
+                'private',
+              ),
+              mileageVisibility: _asString(
+                userData['user_mileage_visibility'] ??
+                    userData['mileage_visibility'],
+                'private',
+              ),
               elevated:
                   _asBool(userData['elevated'] ?? userData['is_elevated'], false),
               disabled: _asBool(userData['disabled'], false),
@@ -660,6 +753,9 @@ class LocoSummary extends Loco {
   final String? owner;
   final String? livery;
   final String? location;
+  final String? visibility;
+  final String? matchedNumber;
+  final DateTime? matchedNumberValidTo;
   final Map<String, dynamic> extra;
 
   LocoSummary({
@@ -679,6 +775,9 @@ class LocoSummary extends Loco {
     this.owner,
     this.livery,
     this.location,
+    this.visibility,
+    this.matchedNumber,
+    this.matchedNumberValidTo,
     Map<String, dynamic>? extra,
     super.powering = true,
     super.allocPos = 0,
@@ -715,6 +814,9 @@ class LocoSummary extends Loco {
     owner: json['owner'] ?? json['loco_owner'],
     livery: json['livery'],
     location: json['location'],
+    visibility: json['visibility']?.toString(),
+    matchedNumber: json['matched_number']?.toString(),
+    matchedNumberValidTo: _asNullableDateTime(json['matched_number_valid_to']),
     extra: Map<String, dynamic>.from(json),
     powering: _asBool(json['alloc_powering'] ?? json['powering'], true),
     allocPos: _asInt(json['alloc_pos'], 0),
@@ -742,6 +844,8 @@ class LocoAttrVersion {
   final String? precisionLevel;
   final String? maskedValidFrom;
   final dynamic valueNorm;
+  final bool isPending;
+  final bool canModeratePending;
 
   const LocoAttrVersion({
     required this.attrCode,
@@ -764,6 +868,8 @@ class LocoAttrVersion {
     this.precisionLevel,
     this.maskedValidFrom,
     this.valueNorm,
+    this.isPending = false,
+    this.canModeratePending = false,
   });
 
   factory LocoAttrVersion.fromJson(Map<String, dynamic> json) {
@@ -788,6 +894,8 @@ class LocoAttrVersion {
       precisionLevel: json['precision_level']?.toString(),
       maskedValidFrom: json['masked_valid_from']?.toString(),
       valueNorm: json['value_norm'],
+      isPending: json['is_pending'] == true,
+      canModeratePending: json['can_moderate_pending'] == true,
     );
   }
 
@@ -823,17 +931,21 @@ class LocoAttrVersion {
       });
     }
     items.sort(
-      (a, b) {
+      compareByStart,
-        final aDate = a.validFrom ?? a.txnFrom ?? DateTime.fromMillisecondsSinceEpoch(0);
-        final bDate = b.validFrom ?? b.txnFrom ?? DateTime.fromMillisecondsSinceEpoch(0);
-        final dateCompare = aDate.compareTo(bDate);
-        if (dateCompare != 0) return dateCompare;
-        return a.attrCode.compareTo(b.attrCode);
-      },
     );
     return items;
   }
 
+  static int compareByStart(LocoAttrVersion a, LocoAttrVersion b) {
+    final aDate =
+        a.validFrom ?? a.txnFrom ?? DateTime.fromMillisecondsSinceEpoch(0);
+    final bDate =
+        b.validFrom ?? b.txnFrom ?? DateTime.fromMillisecondsSinceEpoch(0);
+    final dateCompare = aDate.compareTo(bDate);
+    if (dateCompare != 0) return dateCompare;
+    return a.attrCode.compareTo(b.attrCode);
+  }
+
   String get valueLabel {
     if (valueStr != null && valueStr!.isNotEmpty) return valueStr!;
     if (valueEnum != null && valueEnum!.isNotEmpty) return valueEnum!;
@@ -1061,6 +1173,8 @@ class Leg {
   final String origin, destination;
   final List<String> route;
   final String? legShareId;
+  final LegShareMeta? sharedFrom;
+  final List<LegShareMeta> sharedTo;
   final DateTime beginTime;
   final DateTime? endTime;
   final DateTime? originTime;
@@ -1092,6 +1206,8 @@ class Leg {
     this.origin = '',
     this.destination = '',
     this.legShareId,
+    this.sharedFrom,
+    this.sharedTo = const [],
   });
 
   factory Leg.fromJson(Map<String, dynamic> json) {
@@ -1099,6 +1215,25 @@ class Leg {
     final parsedEndTime = (endTimeRaw == null || '$endTimeRaw'.isEmpty)
         ? null
         : _asDateTime(endTimeRaw);
+    LegShareMeta? sharedFrom;
+    final sharedFromJson = json['shared_from'];
+    if (sharedFromJson is Map) {
+      sharedFrom = LegShareMeta.fromJson(
+        sharedFromJson.map((k, v) => MapEntry(k.toString(), v)),
+      );
+    }
+    List<LegShareMeta> sharedTo = const [];
+    final sharedToJson = json['shared_to'];
+    if (sharedToJson is List) {
+      sharedTo = sharedToJson
+          .whereType<Map>()
+          .map(
+            (e) => LegShareMeta.fromJson(
+              e.map((k, v) => MapEntry(k.toString(), v)),
+            ),
+          )
+          .toList();
+    }
     return Leg(
       id: _asInt(json['leg_id']),
       tripId: _asInt(json['leg_trip']),
@@ -1133,10 +1268,73 @@ class Leg {
       origin: _asString(json['leg_origin']),
       destination: _asString(json['leg_destination']),
       legShareId: _asString(json['leg_share_id']),
+      sharedFrom: sharedFrom,
+      sharedTo: sharedTo,
     );
   }
 }
 
+class LegShareMeta {
+  final int? legShareId;
+  final int? legId;
+  final String sharedToUserId;
+  final String sharedByUserId;
+  final String status;
+  final DateTime? respondedAt;
+  final bool? acceptedEdits;
+  final DateTime? sharedAt;
+  final String sharedToUsername;
+  final String sharedToFullName;
+  final String sharedByUsername;
+  final String sharedByFullName;
+
+  LegShareMeta({
+    this.legShareId,
+    this.legId,
+    required this.sharedToUserId,
+    required this.sharedByUserId,
+    required this.status,
+    this.respondedAt,
+    this.acceptedEdits,
+    this.sharedAt,
+    this.sharedToUsername = '',
+    this.sharedToFullName = '',
+    this.sharedByUsername = '',
+    this.sharedByFullName = '',
+  });
+
+  factory LegShareMeta.fromJson(Map<String, dynamic> json) {
+    DateTime? parseDate(dynamic raw) {
+      if (raw == null) return null;
+      if (raw is DateTime) return raw;
+      return DateTime.tryParse(raw.toString());
+    }
+
+    return LegShareMeta(
+      legShareId: _asInt(json['leg_share_id']),
+      legId: _asInt(json['leg_id']),
+      sharedToUserId: _asString(json['shared_to_user_id']),
+      sharedByUserId: _asString(json['shared_by_user_id']),
+      status: _asString(json['status'], 'pending'),
+      respondedAt: parseDate(json['responded_at']),
+      acceptedEdits: json['accepted_edits'] == null
+          ? null
+          : _asBool(json['accepted_edits'], false),
+      sharedAt: parseDate(json['shared_at']),
+      sharedToUsername: _asString(json['shared_to_username']),
+      sharedToFullName: _asString(json['shared_to_full_name']),
+      sharedByUsername: _asString(json['shared_by_username']),
+      sharedByFullName: _asString(json['shared_by_full_name']),
+    );
+  }
+
+  String get sharedFromDisplay =>
+      sharedByFullName.isNotEmpty ? sharedByFullName : sharedByUsername;
+
+  String get sharedToDisplay =>
+      sharedToFullName.isNotEmpty ? sharedToFullName : sharedToUsername;
+}
+
 class LegShareData {
   final String id;
   final Leg entry;

lib/services/accent_color_service.dart

@@ -0,0 +1,51 @@
+import 'package:flutter/material.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+class AccentColorService extends ChangeNotifier {
+  static const _prefsKeyUseSystem = 'accent_use_system';
+  static const _prefsKeySeed = 'accent_seed';
+  static const Color defaultSeed = Colors.red;
+
+  bool _useSystem = true;
+  Color _seedColor = defaultSeed;
+  bool _hasSavedSeed = false;
+  bool _loaded = false;
+
+  bool get useSystem => _useSystem;
+  Color get seedColor => _seedColor;
+  bool get hasSavedSeed => _hasSavedSeed;
+  bool get isLoaded => _loaded;
+
+  AccentColorService() {
+    _load();
+  }
+
+  Future<void> _load() async {
+    final prefs = await SharedPreferences.getInstance();
+    _useSystem = prefs.getBool(_prefsKeyUseSystem) ?? true;
+    final seedValue = prefs.getInt(_prefsKeySeed);
+    if (seedValue != null) {
+      _seedColor = Color(seedValue);
+      _hasSavedSeed = true;
+    }
+    _loaded = true;
+    notifyListeners();
+  }
+
+  Future<void> setUseSystem(bool value) async {
+    _useSystem = value;
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_prefsKeyUseSystem, _useSystem);
+    notifyListeners();
+  }
+
+  Future<void> setSeedColor(Color color) async {
+    _seedColor = color;
+    _useSystem = false;
+    _hasSavedSeed = true;
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setInt(_prefsKeySeed, color.toARGB32());
+    await prefs.setBool(_prefsKeyUseSystem, _useSystem);
+    notifyListeners();
+  }
+}

lib/services/authservice.dart

@@ -21,6 +21,8 @@ class AuthService extends ChangeNotifier {
   String? get userId => _user?.userId;
   String? get username => _user?.username;
   String? get fullName => _user?.fullName;
+  String get entriesVisibility => _user?.entriesVisibility ?? 'private';
+  String get mileageVisibility => _user?.mileageVisibility ?? 'private';
   bool get isElevated => _user?.isElevated ?? false;
   bool get isAdmin => isElevated; // alias for old name
   bool get isDisabled => _user?.disabled ?? false;
@@ -31,6 +33,8 @@ class AuthService extends ChangeNotifier {
     required String fullName,
     required String accessToken,
     required String email,
+    String entriesVisibility = 'private',
+    String mileageVisibility = 'private',
     bool isElevated = false,
     bool isDisabled = false,
   }) {
@@ -40,6 +44,8 @@ class AuthService extends ChangeNotifier {
       fullName: fullName,
       accessToken: accessToken,
       email: email,
+      entriesVisibility: entriesVisibility,
+      mileageVisibility: mileageVisibility,
       isElevated: isElevated,
       disabled: isDisabled,
     );
@@ -77,6 +83,14 @@ class AuthService extends ChangeNotifier {
       fullName: userResponse['full_name'],
       accessToken: accessToken,
       email: userResponse['email'],
+      entriesVisibility: _parseVisibility(
+        userResponse['user_entries_visibility'] ?? userResponse['entries_visibility'],
+        'private',
+      ),
+      mileageVisibility: _parseVisibility(
+        userResponse['user_mileage_visibility'] ?? userResponse['mileage_visibility'],
+        'private',
+      ),
       isElevated: _parseIsElevated(userResponse),
       isDisabled: _parseIsDisabled(userResponse),
     );
@@ -98,16 +112,24 @@ class AuthService extends ChangeNotifier {
         },
       );
 
-      setLoginData(
+    setLoginData(
-        userId: userResponse['user_id'],
+      userId: userResponse['user_id'],
-        username: userResponse['username'],
+      username: userResponse['username'],
-        fullName: userResponse['full_name'],
+      fullName: userResponse['full_name'],
-        accessToken: token,
+      accessToken: token,
-        email: userResponse['email'],
+      email: userResponse['email'],
-        isElevated: _parseIsElevated(userResponse),
+      entriesVisibility: _parseVisibility(
-        isDisabled: _parseIsDisabled(userResponse),
+        userResponse['user_entries_visibility'] ?? userResponse['entries_visibility'],
-      );
+        'private',
-    } catch (_) {
+      ),
+      mileageVisibility: _parseVisibility(
+        userResponse['user_mileage_visibility'] ?? userResponse['mileage_visibility'],
+        'private',
+      ),
+      isElevated: _parseIsElevated(userResponse),
+      isDisabled: _parseIsDisabled(userResponse),
+    );
+  } catch (_) {
       await _clearToken();
     } finally {
       _restoring = false;
@@ -224,4 +246,11 @@ class AuthService extends ChangeNotifier {
     if (str == null || str.isEmpty) return false;
     return ['1', 'true', 'yes', 'y', 'disabled'].contains(str);
   }
+
+  String _parseVisibility(dynamic value, String fallback) {
+    const allowed = ['private', 'friends', 'public'];
+    final str = value?.toString().toLowerCase().trim();
+    if (str != null && allowed.contains(str)) return str;
+    return fallback;
+  }
 }

lib/services/data_service/data_service_core.dart

@@ -6,6 +6,7 @@ class _LegFetchOptions {
   final int sortDirection;
   final String? dateRangeStart;
   final String? dateRangeEnd;
+  final bool unallocatedOnly;
 
   const _LegFetchOptions({
     this.limit = 100,
@@ -13,6 +14,7 @@ class _LegFetchOptions {
     this.sortDirection = 0,
     this.dateRangeStart,
     this.dateRangeEnd,
+    this.unallocatedOnly = false,
   });
 }
 
@@ -50,6 +52,8 @@ class DataService extends ChangeNotifier {
   bool get isTractionLoading => _isTractionLoading;
   bool _tractionHasMore = false;
   bool get tractionHasMore => _tractionHasMore;
+  int _pendingLocoCount = 0;
+  int get pendingLocoCount => _pendingLocoCount;
   List<LocoChange> _latestLocoChanges = [];
   List<LocoChange> get latestLocoChanges => _latestLocoChanges;
   bool _isLatestLocoChangesLoading = false;
@@ -92,6 +96,22 @@ class DataService extends ChangeNotifier {
   bool _isEventFieldsLoading = false;
   bool get isEventFieldsLoading => _isEventFieldsLoading;
 
+  Future<void> fetchPendingLocoCount() async {
+    try {
+      final json = await api.get('/loco/pending?limit=1000&offset=0');
+      if (json is List) {
+        _pendingLocoCount = json.length;
+      } else {
+        _pendingLocoCount = 0;
+      }
+    } catch (e) {
+      debugPrint('Failed to fetch pending loco count: $e');
+      _pendingLocoCount = 0;
+    } finally {
+      _notifyAsync();
+    }
+  }
+
   // Station Data
   final Map<String, List<Station>> _stationCache = {};
   final Map<String, Future<List<Station>>?> _stationInFlightByKey = {};
@@ -108,6 +128,10 @@ class DataService extends ChangeNotifier {
   bool get isHomepageLoading => _isHomepageLoading;
   bool _isOnThisDayLoading = false;
   bool get isOnThisDayLoading => _isOnThisDayLoading;
+  List<LeaderboardEntry> _friendsLeaderboard = [];
+  List<LeaderboardEntry> get friendsLeaderboard => _friendsLeaderboard;
+  bool _isFriendsLeaderboardLoading = false;
+  bool get isFriendsLeaderboardLoading => _isFriendsLeaderboardLoading;
 
   // Notifications
   List<UserNotification> _notifications = [];
@@ -115,6 +139,16 @@ class DataService extends ChangeNotifier {
   bool _isNotificationsLoading = false;
   bool get isNotificationsLoading => _isNotificationsLoading;
 
+  // Privacy
+  String _userEntriesVisibility = 'private';
+  String _userMileageVisibility = 'private';
+  bool _isPrivacyLoading = false;
+  bool _isPrivacySaving = false;
+  String get userEntriesVisibility => _userEntriesVisibility;
+  String get userMileageVisibility => _userMileageVisibility;
+  bool get isPrivacyLoading => _isPrivacyLoading;
+  bool get isPrivacySaving => _isPrivacySaving;
+
   // Badges
   List<BadgeAward> _badgeAwards = [];
   List<BadgeAward> get badgeAwards => _badgeAwards;
@@ -157,6 +191,127 @@ class DataService extends ChangeNotifier {
     });
   }
 
+  int _visibilityRank(String value) {
+    switch (value.toLowerCase()) {
+      case 'public':
+        return 2;
+      case 'friends':
+        return 1;
+      default:
+        return 0;
+    }
+  }
+
+  String _normaliseVisibility(
+    dynamic value, {
+    required String fallback,
+  }) {
+    const allowed = ['private', 'friends', 'public'];
+    final str = value?.toString().toLowerCase().trim();
+    if (str != null && allowed.contains(str)) return str;
+    return fallback;
+  }
+
+  String _clampMileageVisibility(String entries, String mileage) {
+    return _visibilityRank(mileage) < _visibilityRank(entries)
+        ? entries
+        : mileage;
+  }
+
+  void _applyPrivacy(dynamic source) {
+    String entries = _userEntriesVisibility;
+    String mileage = _userMileageVisibility;
+    if (source is Map) {
+      entries = _normaliseVisibility(
+        source['user_entries_visibility'] ?? source['entries_visibility'],
+        fallback: entries,
+      );
+      mileage = _normaliseVisibility(
+        source['user_mileage_visibility'] ?? source['mileage_visibility'],
+        fallback: mileage,
+      );
+    } else if (source is UserData) {
+      entries = _normaliseVisibility(
+        source.entriesVisibility,
+        fallback: entries,
+      );
+      mileage = _normaliseVisibility(
+        source.mileageVisibility,
+        fallback: mileage,
+      );
+    }
+    _userEntriesVisibility = entries;
+    _userMileageVisibility = _clampMileageVisibility(entries, mileage);
+  }
+
+  Future<void> fetchPrivacySettings({String? targetUserId}) async {
+    _isPrivacyLoading = true;
+    _notifyAsync();
+    try {
+      Map<String, dynamic>? payload;
+      final hasTarget = targetUserId?.isNotEmpty ?? false;
+      if (!hasTarget) {
+        try {
+          final json = await api.get('/users/me');
+          if (json is Map<String, dynamic>) {
+            payload = json;
+          } else if (json is Map) {
+            payload = json.map((k, v) => MapEntry(k.toString(), v));
+          }
+        } catch (e) {
+          debugPrint('Failed to fetch /users/me: $e');
+        }
+      }
+      if (payload == null) {
+        final query = hasTarget ? '?target_user_id=$targetUserId' : '';
+        try {
+          final json = await api.get('/users/privacy$query');
+          if (json is Map<String, dynamic>) {
+            payload = json;
+          } else if (json is Map) {
+            payload = json.map((k, v) => MapEntry(k.toString(), v));
+          }
+        } catch (e) {
+          debugPrint('Failed to fetch /users/privacy: $e');
+        }
+      }
+      if (payload != null) {
+        _applyPrivacy(payload);
+      }
+    } catch (e) {
+      debugPrint('Failed to fetch privacy settings: $e');
+    } finally {
+      _isPrivacyLoading = false;
+      _notifyAsync();
+    }
+  }
+
+  Future<void> updatePrivacySettings({
+    required String entriesVisibility,
+    required String mileageVisibility,
+    String? targetUserId,
+  }) async {
+    _isPrivacySaving = true;
+    _notifyAsync();
+    try {
+      final query = (targetUserId?.isNotEmpty ?? false)
+          ? '?target_user_id=$targetUserId'
+          : '';
+      await api.post('/users/privacy$query', {
+        'user_entries_visibility': entriesVisibility,
+        'user_mileage_visibility': mileageVisibility,
+      });
+      _userEntriesVisibility = entriesVisibility;
+      _userMileageVisibility = mileageVisibility;
+    } catch (e) {
+      debugPrint('Failed to update privacy settings: $e');
+      rethrow;
+    } finally {
+      _isPrivacySaving = false;
+      _notifyAsync();
+    }
+  }
+
   Future<void> fetchHomepageStats() async {
     _isHomepageLoading = true;
 
@@ -165,16 +320,68 @@ class DataService extends ChangeNotifier {
       _homepageStats = HomepageStats.fromJson(json);
       _trips = [...(_homepageStats?.trips ?? const [])]
         ..sort(TripSummary.compareByDateDesc);
+      _friendsLeaderboard = _homepageStats?.friendsLeaderboard ?? [];
+      if (_homepageStats?.user != null) {
+        _applyPrivacy(_homepageStats!.user!);
+      }
     } catch (e) {
       debugPrint('Failed to fetch homepage stats: $e');
       _homepageStats = null;
       _trips = [];
+      _friendsLeaderboard = [];
     } finally {
       _isHomepageLoading = false;
       _notifyAsync();
     }
   }
 
+  Future<UserProfileDetail?> fetchUserProfileDetail(String userId) async {
+    try {
+      final json = await api.get('/user/$userId');
+      if (json is Map) {
+        return UserProfileDetail.fromJson(
+          json.map((k, v) => MapEntry(k.toString(), v)),
+        );
+      }
+    } catch (e) {
+      debugPrint('Failed to fetch user profile for $userId: $e');
+    }
+    return null;
+  }
+
+  Future<List<Leg>> fetchUserLegs({
+    required String userId,
+    int offset = 0,
+    int limit = 25,
+  }) async {
+    try {
+      final json =
+          await api.get('/legs/user/$userId?offset=$offset&limit=$limit');
+      List<dynamic>? list;
+      if (json is List) {
+        list = json;
+      } else if (json is Map) {
+        for (final key in ['legs', 'data', 'results', 'items']) {
+          final value = json[key];
+          if (value is List) {
+            list = value;
+            break;
+          }
+        }
+      }
+      if (list == null) return const [];
+      return list
+          .whereType<Map>()
+          .map((e) => Leg.fromJson(
+                e.map((k, v) => MapEntry(k.toString(), v)),
+              ))
+          .toList();
+    } catch (e) {
+      debugPrint('Failed to fetch user legs for $userId: $e');
+      return const [];
+    }
+  }
+
   Future<void> fetchLegs({
     int offset = 0,
     int limit = 100,
@@ -183,6 +390,7 @@ class DataService extends ChangeNotifier {
     String? dateRangeStart,
     String? dateRangeEnd,
     bool append = false,
+    bool unallocatedOnly = false,
   }) async {
     _isLegsLoading = true;
     if (!append) {
@@ -192,6 +400,7 @@ class DataService extends ChangeNotifier {
         sortDirection: sortDirection,
         dateRangeStart: dateRangeStart,
         dateRangeEnd: dateRangeEnd,
+        unallocatedOnly: unallocatedOnly,
       );
     }
     final buffer = StringBuffer(
@@ -203,6 +412,9 @@ class DataService extends ChangeNotifier {
     if (dateRangeEnd != null && dateRangeEnd.isNotEmpty) {
       buffer.write('&date_range_end=$dateRangeEnd');
     }
+    if (unallocatedOnly) {
+      buffer.write('&unallocated_only=true');
+    }
     try {
       final json = await api.get('/user/legs${buffer.toString()}');
 
@@ -231,6 +443,7 @@ class DataService extends ChangeNotifier {
       sortDirection: _lastLegsFetch.sortDirection,
       dateRangeStart: _lastLegsFetch.dateRangeStart,
       dateRangeEnd: _lastLegsFetch.dateRangeEnd,
+      unallocatedOnly: _lastLegsFetch.unallocatedOnly,
     );
   }
 
@@ -393,6 +606,39 @@ class DataService extends ChangeNotifier {
     }
   }
 
+  Future<void> deletePendingEvent({
+    required int eventId,
+  }) async {
+    try {
+      await api.delete('/event/pending/$eventId');
+    } catch (e) {
+      debugPrint('Failed to delete pending event $eventId: $e');
+      rethrow;
+    }
+  }
+
+  Future<void> approvePendingEvent({
+    required int eventId,
+  }) async {
+    try {
+      await api.put('/event/approve/$eventId', null);
+    } catch (e) {
+      debugPrint('Failed to approve pending event $eventId: $e');
+      rethrow;
+    }
+  }
+
+  Future<void> rejectPendingEvent({
+    required int eventId,
+  }) async {
+    try {
+      await api.put('/event/reject/$eventId', null);
+    } catch (e) {
+      debugPrint('Failed to reject pending event $eventId: $e');
+      rethrow;
+    }
+  }
+
   void clear() {
     _currentUserId = null;
     _lastLegsFetch = const _LegFetchOptions();
@@ -425,6 +671,10 @@ class DataService extends ChangeNotifier {
     _stationFiltersFetchedAt = null;
     _notifications = [];
     _isNotificationsLoading = false;
+    _userEntriesVisibility = 'private';
+    _userMileageVisibility = 'private';
+    _isPrivacyLoading = false;
+    _isPrivacySaving = false;
     _badgeAwards = [];
     _badgeAwardsHasMore = false;
     _isBadgeAwardsLoading = false;
@@ -437,11 +687,24 @@ class DataService extends ChangeNotifier {
     _notifyAsync();
   }
 
-  void handleAuthChanged(String? userId) {
+  void handleAuthChanged(
-    if (_currentUserId == userId) return;
+    String? userId, {
-    _currentUserId = userId;
+    String? entriesVisibility,
-    clear();
+    String? mileageVisibility,
+  }) {
+    final sameUser = _currentUserId == userId;
     _currentUserId = userId;
+    if (!sameUser) {
+      clear();
+      _currentUserId = userId;
+    }
+    if (entriesVisibility != null || mileageVisibility != null) {
+      _applyPrivacy({
+        'user_entries_visibility': entriesVisibility,
+        'user_mileage_visibility': mileageVisibility,
+      });
+      _notifyAsync();
+    }
   }
 
   double getMileageForCurrentYear() {

lib/services/data_service/data_service_friendships.dart

@@ -151,6 +151,8 @@ extension DataServiceFriendships on DataService {
       overrideAddressee: targetUser,
     );
     _pendingOutgoing = [friendship, ..._pendingOutgoing];
+    await fetchFriendships();
+    await fetchPendingFriendships();
     _notifyAsync();
     return friendship;
   }
@@ -159,6 +161,8 @@ extension DataServiceFriendships on DataService {
     final json = await api.post('/friendships/$friendshipId/accept', {});
     final friendship = _parseAndUpsertFriendship(json, fallbackStatus: 'accepted');
     _pendingIncoming = _pendingIncoming.where((f) => f.id != friendshipId).toList();
+    await fetchFriendships();
+    await fetchPendingFriendships();
     _notifyAsync();
     return friendship;
   }
@@ -177,6 +181,8 @@ extension DataServiceFriendships on DataService {
         _parseAndRemoveFriendship(json, friendshipId, status: 'none');
     _pendingOutgoing =
         _pendingOutgoing.where((f) => f.id != friendshipId).toList();
+    await fetchFriendships();
+    await fetchPendingFriendships();
     _notifyAsync();
     return friendship;
   }
@@ -193,6 +199,8 @@ extension DataServiceFriendships on DataService {
         _pendingIncoming.where((f) => f.id != friendshipId).toList();
     _pendingOutgoing =
         _pendingOutgoing.where((f) => f.id != friendshipId).toList();
+    await fetchFriendships();
+    await fetchPendingFriendships();
     _notifyAsync();
   }
 

lib/services/data_service/data_service_leg_share.dart

@@ -88,6 +88,18 @@ extension DataServiceLegShare on DataService {
     return null;
   }
 
+  Future<void> applyLegPartialUpdates({
+    required int legId,
+    required Map<String, dynamic> updates,
+  }) async {
+    try {
+      await api.post('/leg/update/$legId/partial', updates);
+    } catch (e) {
+      debugPrint('Failed to apply partial updates for leg $legId: $e');
+      rethrow;
+    }
+  }
+
   int? _parseNullableInt(dynamic value) {
     if (value is int) return value;
     if (value is num) return value.toInt();

lib/services/data_service/data_service_stats.dart

@@ -25,4 +25,38 @@ extension DataServiceStats on DataService {
       _notifyAsync();
     }
   }
+
+  Future<void> fetchFriendsLeaderboard() async {
+    if (_isFriendsLeaderboardLoading) return;
+    _isFriendsLeaderboardLoading = true;
+    _notifyAsync();
+    try {
+      final json = await api.get('/stats/leaderboard/friends');
+      List<dynamic>? list;
+      if (json is List) {
+        list = json;
+      } else if (json is Map) {
+        for (final key in ['leaderboard', 'data', 'items', 'results']) {
+          final value = json[key];
+          if (value is List) {
+            list = value;
+            break;
+          }
+        }
+      }
+      _friendsLeaderboard = list
+              ?.whereType<Map>()
+              .map((e) => LeaderboardEntry.fromJson(
+                    e.map((k, v) => MapEntry(k.toString(), v)),
+                  ))
+              .toList() ??
+          const [];
+    } catch (e) {
+      debugPrint('Failed to fetch friends leaderboard: $e');
+      _friendsLeaderboard = [];
+    } finally {
+      _isFriendsLeaderboardLoading = false;
+      _notifyAsync();
+    }
+  }
 }

lib/services/data_service/data_service_traction.dart

@@ -62,18 +62,73 @@ extension DataServiceTraction on DataService {
       _tractionHasMore = false;
     } finally {
       _isTractionLoading = false;
-      _notifyAsync();
+    _notifyAsync();
-    }
   }
 
-  Future<List<LocoAttrVersion>> fetchLocoTimeline(int locoId) async {
+  }
+
+  Future<List<LocoAttrVersion>> fetchLocoTimeline(
+    int locoId, {
+    bool includeAllPending = false,
+  }) async {
     _isLocoTimelineLoading[locoId] = true;
     _notifyAsync();
     try {
-      final json = await api.get('/loco/get-timeline/$locoId');
+      final baseJson = await api.get('/loco/get-timeline/$locoId');
-      final timeline = LocoAttrVersion.fromGroupedJson(json);
+      final timeline = LocoAttrVersion.fromGroupedJson(baseJson);
-      _locoTimelines[locoId] = timeline;
+      final baseKeys = timeline
-      return timeline;
+          .map(_entryKey)
+          .where((key) => key.isNotEmpty)
+          .toSet();
+      final pendingEntries = <LocoAttrVersion>[];
+      final pendingSeen = <String>{};
+
+      void addPending(List<LocoAttrVersion> entries) {
+        for (final entry in entries) {
+          final key = _entryKey(entry);
+          if (pendingSeen.contains(key)) continue;
+          if (baseKeys.contains(key)) continue;
+          pendingSeen.add(key);
+          pendingEntries.add(entry);
+          baseKeys.add(key);
+        }
+      }
+
+      try {
+        final pendingJson =
+            await api.get('/event/pending/user?loco_id=$locoId');
+        addPending(
+          _parsePendingLocoEvents(
+            pendingJson,
+            locoId,
+            canModerate: false,
+          ),
+        );
+      } catch (e) {
+        debugPrint('Failed to fetch pending loco events for $locoId: $e');
+      }
+
+      if (includeAllPending) {
+        try {
+          final pendingJson = await api.get('/event/pending?loco_id=$locoId');
+          addPending(
+            _parsePendingLocoEvents(
+              pendingJson,
+              locoId,
+              canModerate: true,
+            ),
+          );
+        } catch (e) {
+          debugPrint('Failed to fetch all pending loco events for $locoId: $e');
+        }
+      }
+
+      final merged = [
+        ...timeline,
+        ...pendingEntries,
+      ]..sort(LocoAttrVersion.compareByStart);
+      _locoTimelines[locoId] = merged;
+      return merged;
     } catch (e) {
       debugPrint('Failed to fetch loco timeline for $locoId: $e');
       _locoTimelines[locoId] = [];
@@ -84,6 +139,173 @@ extension DataServiceTraction on DataService {
     }
   }
 
+  Future<List<LocoAttrVersion>> fetchUserPendingEvents(int locoId) async {
+    try {
+      final pendingJson = await api.get('/event/pending/user?loco_id=$locoId');
+      return _parsePendingLocoEvents(
+        pendingJson,
+        locoId,
+        canModerate: false,
+      );
+    } catch (e) {
+      debugPrint('Failed to fetch user pending events for $locoId: $e');
+      return const [];
+    }
+  }
+
+  List<LocoAttrVersion> _parsePendingLocoEvents(
+    dynamic json,
+    int fallbackLocoId, {
+    bool canModerate = false,
+  }) {
+    if (json is! List) return const <LocoAttrVersion>[];
+    final entries = <LocoAttrVersion>[];
+    final seen = <String>{};
+    for (final item in json) {
+      if (item is! Map) continue;
+      final map = _extractPendingEventMap(item);
+      final locoId = (map['loco_id'] as num?)?.toInt() ?? fallbackLocoId;
+      final maskedValidFrom = map['masked_valid_from']?.toString();
+      final precision = map['precision_level']?.toString();
+      final username = map['username']?.toString();
+      final sourceEventId = (map['loco_event_id'] as num?)?.toInt();
+      final startDate = _parsePendingDate(map);
+      final status = map['moderation_status']?.toString().toLowerCase();
+      if (status != null && status != 'pending') continue;
+      if (startDate == null &&
+          (maskedValidFrom == null || maskedValidFrom.trim().isEmpty)) {
+        continue;
+      }
+      final valueMap = _decodeEventValues(map['loco_event_value']);
+      if (valueMap.isEmpty) continue;
+
+      valueMap.forEach((attr, rawValue) {
+        final attrCode = attr.toString();
+        if (attrCode.isEmpty) return;
+        final key = [
+          sourceEventId?.toString() ?? '',
+          attrCode.toLowerCase(),
+          maskedValidFrom ?? '',
+          startDate?.toIso8601String() ?? '',
+        ].join('|');
+        if (seen.contains(key)) return;
+        seen.add(key);
+        final parsedValue = _PendingTimelineValue.fromDynamic(rawValue);
+        entries.add(
+          LocoAttrVersion(
+            attrCode: attrCode,
+            locoId: locoId,
+            valueStr: parsedValue.valueStr,
+            valueInt: parsedValue.valueInt,
+            valueBool: parsedValue.valueBool,
+            valueDate: parsedValue.valueDate,
+            valueNorm: parsedValue.valueNorm ?? rawValue,
+            validFrom: startDate,
+            maskedValidFrom: maskedValidFrom,
+            precisionLevel: precision,
+            suggestedBy: username,
+            sourceEventId: sourceEventId,
+            isPending: true,
+            canModeratePending: canModerate,
+          ),
+        );
+      });
+    }
+    return entries;
+  }
+
+  String _entryKey(LocoAttrVersion entry) {
+    final attr = entry.attrCode.toLowerCase();
+    final masked = entry.maskedValidFrom?.trim() ?? '';
+    final start = entry.validFrom?.toIso8601String() ?? '';
+    final source = entry.sourceEventId?.toString() ?? '';
+    return '$attr|$masked|$start|$source';
+  }
+
+  Map<String, dynamic> _extractPendingEventMap(Map raw) {
+    if (raw['event_info'] is Map) {
+      final eventInfo = Map<String, dynamic>.from(raw['event_info']);
+      final merged = {...eventInfo};
+      for (final key in [
+        'loco_id',
+        'masked_valid_from',
+        'precision_level',
+        'username',
+        'loco_event_id',
+        'earliest_date',
+        'valid_from',
+        'loco_event_date',
+        'event_year',
+        'event_month',
+        'event_day',
+        'loco_event_value',
+      ]) {
+        merged.putIfAbsent(key, () => raw[key]);
+      }
+      return merged;
+    }
+    return Map<String, dynamic>.from(raw);
+  }
+
+  Map<String, dynamic> _decodeEventValues(dynamic raw) {
+    if (raw is Map) {
+      return raw.map((key, value) => MapEntry(key.toString(), value));
+    }
+    if (raw is String) {
+      final trimmed = raw.trim();
+      if (trimmed.isEmpty) return const {};
+      try {
+        final decoded = jsonDecode(trimmed);
+        if (decoded is Map) {
+          return decoded.map((key, value) => MapEntry(key.toString(), value));
+        }
+      } catch (_) {}
+    }
+    return const <String, dynamic>{};
+  }
+
+  DateTime? _parsePendingDate(Map<String, dynamic> json) {
+    DateTime? parseDate(dynamic value) {
+      if (value == null) return null;
+      if (value is DateTime) return value;
+      return DateTime.tryParse(value.toString());
+    }
+
+    // Try masked date by normalising unknown parts to 01 so we can position on the axis.
+    final masked = json['masked_valid_from']?.toString();
+    if (masked is String && masked.contains('-')) {
+      final sanitized = masked
+          .replaceAll(RegExp(r'[Xx?]{2}'), '01')
+          .replaceAll(RegExp(r'[Xx?]'), '1');
+      final parsedMasked = DateTime.tryParse(sanitized);
+      if (parsedMasked != null) return parsedMasked;
+    }
+
+    for (final key in ['earliest_date', 'valid_from', 'loco_event_date']) {
+      final parsed = parseDate(json[key]);
+      if (parsed != null) return parsed;
+    }
+
+    final year = _asNullableInt(json['event_year']);
+    if (year != null && year > 0) {
+      final monthValue = _asNullableInt(json['event_month']) ?? 1;
+      final dayValue = _asNullableInt(json['event_day']) ?? 1;
+      final month = monthValue.clamp(1, 12).toInt();
+      final day = dayValue.clamp(1, 31).toInt();
+      try {
+        return DateTime(year, month, day);
+      } catch (_) {}
+    }
+    return null;
+  }
+
+  int? _asNullableInt(dynamic value) {
+    if (value == null) return null;
+    if (value is int) return value;
+    if (value is num) return value.toInt();
+    return int.tryParse(value.toString());
+  }
+
   Future<dynamic> createLoco(Map<String, dynamic> payload) async {
     try {
       final response = await api.put('/loco/new', payload);
@@ -101,8 +323,9 @@ extension DataServiceTraction on DataService {
     }
   }
 
-  Future<List<String>> fetchClassList() async {
+  Future<List<String>> fetchClassList({bool force = false}) async {
-    if (_locoClasses.isNotEmpty) return _locoClasses;
+    if (!force && _locoClasses.isNotEmpty) return _locoClasses;
+    if (force) _locoClasses = [];
     try {
       final json = await api.get('/loco/classlist');
       if (json is List) {
@@ -179,4 +402,140 @@ extension DataServiceTraction on DataService {
     }
     return null;
   }
+
+  Future<List<LeaderboardEntry>> fetchClassLeaderboard(
+    String locoClass, {
+    bool friends = false,
+  }) async {
+    try {
+      final path = Uri.encodeComponent(locoClass);
+      final suffix = friends ? '/friends' : '';
+      final json = await api.get('/stats/class/$path/leaderboard$suffix');
+      List<dynamic>? list;
+      if (json is List) {
+        list = json;
+      } else if (json is Map) {
+        for (final key in ['leaderboard', 'data', 'items', 'results']) {
+          final value = json[key];
+          if (value is List) {
+            list = value;
+            break;
+          }
+        }
+      }
+      return list
+              ?.whereType<Map>()
+              .map((e) => LeaderboardEntry.fromJson(
+                    e.map((k, v) => MapEntry(k.toString(), v)),
+                  ))
+              .toList() ??
+          const [];
+    } catch (e) {
+      debugPrint(
+        'Failed to fetch class leaderboard for $locoClass (friends=$friends): $e',
+      );
+      return const [];
+    }
+  }
+
+  Future<void> acceptPendingLoco({required int locoId}) async {
+    try {
+      await api.put('/loco/pending/approve/$locoId', null);
+    } catch (e) {
+      debugPrint('Failed to approve pending loco $locoId: $e');
+      rethrow;
+    }
+  }
+
+  Future<void> rejectPendingLoco({
+    required int locoId,
+    int? replacementLocoId,
+    String? rejectedReason,
+  }) async {
+    try {
+      final body = <String, dynamic>{};
+      if (replacementLocoId != null) {
+        body['replacement_loco_id'] = replacementLocoId;
+      }
+      if (rejectedReason != null && rejectedReason.trim().isNotEmpty) {
+        body['rejected_reason'] = rejectedReason.trim();
+      }
+      await api.put('/loco/pending/reject/$locoId', body.isEmpty ? null : body);
+    } catch (e) {
+      debugPrint('Failed to reject pending loco $locoId: $e');
+      rethrow;
+    }
+  }
+
+  Future<void> transferAllocations({
+    required int fromLocoId,
+    required int toLocoId,
+  }) async {
+    try {
+      await api.post('/loco/alloc/transfer', {
+        'from_loco_id': fromLocoId,
+        'to_loco_id': toLocoId,
+      });
+    } catch (e) {
+      debugPrint('Failed to transfer allocations $fromLocoId -> $toLocoId: $e');
+      rethrow;
+    }
+  }
+
+  Future<void> adminDeleteLoco({required int locoId}) async {
+    try {
+      await api.delete('/loco/admin/delete/$locoId');
+    } catch (e) {
+      debugPrint('Failed to delete loco $locoId as admin: $e');
+      rethrow;
+    }
+  }
+}
+
+class _PendingTimelineValue {
+  final String? valueStr;
+  final int? valueInt;
+  final bool? valueBool;
+  final DateTime? valueDate;
+  final dynamic valueNorm;
+
+  const _PendingTimelineValue({
+    this.valueStr,
+    this.valueInt,
+    this.valueBool,
+    this.valueDate,
+    this.valueNorm,
+  });
+
+  factory _PendingTimelineValue.fromDynamic(dynamic raw) {
+    if (raw is Map || raw is List) {
+      return _PendingTimelineValue(valueStr: jsonEncode(raw));
+    }
+    if (raw is bool) return _PendingTimelineValue(valueBool: raw);
+    if (raw is int) return _PendingTimelineValue(valueInt: raw);
+    if (raw is num) return _PendingTimelineValue(valueNorm: raw);
+    if (raw is String) {
+      final trimmed = raw.trim();
+      if (trimmed.isEmpty) return const _PendingTimelineValue(valueStr: '');
+      final lower = trimmed.toLowerCase();
+      if (['true', 'yes', 'y'].contains(lower)) {
+        return const _PendingTimelineValue(valueBool: true);
+      }
+      if (['false', 'no', 'n'].contains(lower)) {
+        return const _PendingTimelineValue(valueBool: false);
+      }
+      final intVal = int.tryParse(trimmed);
+      if (intVal != null) return _PendingTimelineValue(valueInt: intVal);
+      final doubleVal = double.tryParse(trimmed);
+      if (doubleVal != null) {
+        return _PendingTimelineValue(valueNorm: doubleVal);
+      }
+      final dateVal = DateTime.tryParse(trimmed);
+      if (dateVal != null) {
+        return _PendingTimelineValue(valueDate: dateVal);
+      }
+      return _PendingTimelineValue(valueStr: trimmed);
+    }
+    return _PendingTimelineValue(valueNorm: raw);
+  }
 }

lib/services/theme_mode_service.dart

@@ -0,0 +1,47 @@
+import 'package:flutter/material.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+class ThemeModeService extends ChangeNotifier {
+  static const _prefsKey = 'theme_mode_preference';
+
+  ThemeMode _mode = ThemeMode.system;
+  bool _loaded = false;
+
+  ThemeMode get mode => _mode;
+  bool get isLoaded => _loaded;
+
+  ThemeModeService() {
+    _load();
+  }
+
+  Future<void> _load() async {
+    final prefs = await SharedPreferences.getInstance();
+    final saved = prefs.getString(_prefsKey);
+    if (saved != null) {
+      switch (saved) {
+        case 'light':
+          _mode = ThemeMode.light;
+          break;
+        case 'dark':
+          _mode = ThemeMode.dark;
+          break;
+        default:
+          _mode = ThemeMode.system;
+      }
+    }
+    _loaded = true;
+    notifyListeners();
+  }
+
+  Future<void> setMode(ThemeMode mode) async {
+    _mode = mode;
+    final prefs = await SharedPreferences.getInstance();
+    final value = switch (mode) {
+      ThemeMode.light => 'light',
+      ThemeMode.dark => 'dark',
+      _ => 'system',
+    };
+    await prefs.setString(_prefsKey, value);
+    notifyListeners();
+  }
+}

lib/ui/app_shell.dart

@@ -20,12 +20,17 @@ import 'package:mileograph_flutter/components/pages/profile.dart';
 import 'package:mileograph_flutter/components/pages/settings.dart';
 import 'package:mileograph_flutter/components/pages/stats.dart';
 import 'package:mileograph_flutter/components/pages/traction.dart';
+import 'package:mileograph_flutter/components/pages/traction/traction_pending_page.dart';
+import 'package:mileograph_flutter/components/pages/more/user_profile_page.dart';
 import 'package:mileograph_flutter/components/widgets/friend_request_notification_card.dart';
+import 'package:mileograph_flutter/components/widgets/leg_share_edit_notification_card.dart';
 import 'package:mileograph_flutter/components/widgets/leg_share_notification_card.dart';
 import 'package:mileograph_flutter/objects/objects.dart';
 import 'package:mileograph_flutter/services/authservice.dart';
+import 'package:mileograph_flutter/services/accent_color_service.dart';
 import 'package:mileograph_flutter/services/data_service.dart';
 import 'package:mileograph_flutter/services/navigation_guard.dart';
+import 'package:mileograph_flutter/services/theme_mode_service.dart';
 import 'package:provider/provider.dart';
 
 final GlobalKey<NavigatorState> _shellNavigatorKey =
@@ -100,12 +105,6 @@ class _MyAppState extends State<MyApp> {
   late final GoRouter _router;
   bool _routerInitialized = false;
 
-  final ColorScheme defaultLight = ColorScheme.fromSeed(seedColor: Colors.red);
-  final ColorScheme defaultDark = ColorScheme.fromSeed(
-    seedColor: Colors.red,
-    brightness: Brightness.dark,
-  );
-
   @override
   void didChangeDependencies() {
     super.didChangeDependencies();
@@ -168,7 +167,59 @@ class _MyAppState extends State<MyApp> {
             ),
             GoRoute(
               path: '/traction',
-              builder: (context, state) => TractionPage(),
+              builder: (context, state) {
+                final selectionParam =
+                    state.uri.queryParameters['selection'] ??
+                        (state.extra is Map
+                            ? (state.extra as Map)['selection']?.toString()
+                            : null);
+                final replacementPendingLocoIdStr =
+                    state.uri.queryParameters['replacementPendingLocoId'];
+                final replacementPendingLocoId = replacementPendingLocoIdStr != null
+                    ? int.tryParse(replacementPendingLocoIdStr)
+                    : state.extra is Map
+                        ? int.tryParse(
+                            (state.extra as Map)['replacementPendingLocoId']
+                                    ?.toString() ??
+                                '',
+                          )
+                        : null;
+                final transferFromLocoIdStr =
+                    state.uri.queryParameters['transferFromLocoId'];
+                final transferFromLocoId = transferFromLocoIdStr != null
+                    ? int.tryParse(transferFromLocoIdStr)
+                    : state.extra is Map
+                        ? int.tryParse(
+                            (state.extra as Map)['transferFromLocoId']
+                                    ?.toString() ??
+                                '',
+                          )
+                        : null;
+                final transferFromLabel = state.uri.queryParameters['transferFromLabel'] ??
+                    (state.extra is Map
+                        ? (state.extra as Map)['transferFromLabel']?.toString()
+                        : null);
+                final selectionMode =
+                    (selectionParam != null && selectionParam.isNotEmpty) ||
+                        replacementPendingLocoId != null ||
+                        transferFromLocoId != null;
+                final selectionSingle = replacementPendingLocoId != null ||
+                    transferFromLocoId != null ||
+                    selectionParam?.toLowerCase() == 'single' ||
+                        selectionParam == '1' ||
+                        selectionParam?.toLowerCase() == 'true';
+                return TractionPage(
+                  selectionMode: selectionMode,
+                  selectionSingle: selectionSingle,
+                  replacementPendingLocoId: replacementPendingLocoId,
+                  transferFromLabel: transferFromLabel,
+                  transferFromLocoId: transferFromLocoId,
+                );
+              },
+            ),
+            GoRoute(
+              path: '/traction/pending',
+              builder: (context, state) => const TractionPendingPage(),
             ),
             GoRoute(
               path: '/profile',
@@ -227,6 +278,28 @@ class _MyAppState extends State<MyApp> {
               path: '/more/profile',
               builder: (context, state) => const ProfilePage(),
             ),
+            GoRoute(
+              path: '/more/user-profile',
+              name: 'user-profile',
+              builder: (context, state) {
+                final extra = state.extra;
+                UserSummary? user;
+                String? userId;
+                if (extra is UserSummary) {
+                  user = extra;
+                  userId = extra.userId;
+                } else if (extra is Map) {
+                  final value = extra['user'];
+                  if (value is UserSummary) user = value;
+                  userId = extra['userId']?.toString();
+                }
+                userId ??= state.uri.queryParameters['user_id'];
+                return UserProfilePage(
+                  userId: userId,
+                  initialUser: user,
+                );
+              },
+            ),
             GoRoute(
               path: '/more/badges',
               builder: (context, state) => const BadgesPage(),
@@ -267,20 +340,34 @@ class _MyAppState extends State<MyApp> {
 
   @override
   Widget build(BuildContext context) {
+    final accent = context.watch<AccentColorService>();
+    final themeModeService = context.watch<ThemeModeService>();
+    final seedColor =
+        accent.hasSavedSeed ? accent.seedColor : AccentColorService.defaultSeed;
+    final useSystemColors = accent.useSystem;
     return DynamicColorBuilder(
       builder: (ColorScheme? lightDynamic, ColorScheme? darkDynamic) {
+        final colorSchemeLight = useSystemColors && lightDynamic != null
+            ? lightDynamic
+            : ColorScheme.fromSeed(seedColor: seedColor);
+        final colorSchemeDark = useSystemColors && darkDynamic != null
+            ? darkDynamic
+            : ColorScheme.fromSeed(
+                seedColor: seedColor,
+                brightness: Brightness.dark,
+              );
         return MaterialApp.router(
           title: 'Mileograph',
           routerConfig: _router,
           theme: ThemeData(
             useMaterial3: true,
-            colorScheme: lightDynamic ?? defaultLight,
+            colorScheme: colorSchemeLight,
           ),
           darkTheme: ThemeData(
             useMaterial3: true,
-            colorScheme: darkDynamic ?? defaultDark,
+            colorScheme: colorSchemeDark,
           ),
-          themeMode: ThemeMode.system,
+          themeMode: themeModeService.mode,
         );
       },
     );
@@ -436,26 +523,34 @@ class _MyHomePageState extends State<MyHomePage> {
             )
             .toList();
 
+        final logo = Text.rich(
+          TextSpan(
+            children: const [
+              TextSpan(text: "Mile"),
+              TextSpan(
+                text: "O",
+                style: TextStyle(color: Colors.red),
+              ),
+              TextSpan(text: "graph"),
+            ],
+            style: const TextStyle(
+              decoration: TextDecoration.none,
+              color: Colors.white,
+              fontFamily: "Tomatoes",
+            ),
+          ),
+        );
+
         return Scaffold(
           appBar: AppBar(
             backgroundColor: Theme.of(context).colorScheme.inversePrimary,
-            title: Text.rich(
+            title: isWide
-              TextSpan(
+                ? logo
-                children: const [
+                : FittedBox(
-                  TextSpan(text: "Mile"),
+                    fit: BoxFit.scaleDown,
-                  TextSpan(
+                    alignment: Alignment.centerLeft,
-                    text: "O",
+                    child: logo,
-                    style: TextStyle(color: Colors.red),
                   ),
-                  TextSpan(text: "graph"),
-                ],
-                style: const TextStyle(
-                  decoration: TextDecoration.none,
-                  color: Colors.white,
-                  fontFamily: "Tomatoes",
-                ),
-              ),
-            ),
             actions: [
               _buildNotificationAction(context, data),
               IconButton(
@@ -708,7 +803,8 @@ class _MyHomePageState extends State<MyHomePage> {
             final item = notifications[index];
             final isFriendRequest = _isFriendRequestNotification(item);
             final isLegShare = _isLegShareNotification(item);
-            final isSpecial = isFriendRequest || isLegShare;
+            final isLegShareEdit = _isLegShareEditNotification(item);
+            final isSpecial = isFriendRequest || isLegShare || isLegShareEdit;
             return Card(
               child: Padding(
                 padding: const EdgeInsets.all(12.0),
@@ -731,10 +827,12 @@ class _MyHomePageState extends State<MyHomePage> {
                               ),
                               const SizedBox(height: 4),
                               Text(
-                                isFriendRequest || isLegShare
+                                isSpecial
                                     ? isFriendRequest
                                         ? 'Accept to share entries'
-                                        : 'Shared entry details below.'
+                                        : isLegShareEdit
+                                            ? 'Shared leg edits below.'
+                                            : 'Shared entry details below.'
                                     : item.body,
                                 style: Theme.of(context).textTheme.bodyMedium,
                               ),
@@ -778,6 +876,13 @@ class _MyHomePageState extends State<MyHomePage> {
                           notification: item,
                         ),
                       ),
+                    if (_isLegShareEditNotification(item))
+                      Padding(
+                        padding: const EdgeInsets.only(top: 8.0),
+                        child: LegShareEditNotificationCard(
+                          notification: item,
+                        ),
+                      ),
                     if (isLegShare)
                       Padding(
                         padding: const EdgeInsets.only(top: 8.0),
@@ -867,7 +972,22 @@ class _MyHomePageState extends State<MyHomePage> {
   bool _isLegShareNotification(UserNotification notification) {
     final channel = notification.channel.trim().toLowerCase();
     final type = notification.type.trim().toLowerCase();
-    return channel.contains('leg_share') || type.contains('leg_share');
+    final isAcceptEdits =
+        _isLegShareAcceptEdits(channel) || _isLegShareAcceptEdits(type);
+    return (channel.contains('leg_share') || type.contains('leg_share')) &&
+        !isAcceptEdits;
+  }
+
+  bool _isLegShareEditNotification(UserNotification notification) {
+    final channel = notification.channel.trim().toLowerCase();
+    final type = notification.type.trim().toLowerCase();
+    return _isLegShareAcceptEdits(channel) || _isLegShareAcceptEdits(type);
+  }
+
+  bool _isLegShareAcceptEdits(String value) {
+    final normalized = value.trim().toLowerCase();
+    // Match both singular/plural: leg_share_accept_edit / leg_share_accept_edits
+    return normalized.contains('leg_share_accept_edit');
   }
 
   Widget _buildBadge(String label) {

pubspec.yaml

@@ -16,7 +16,7 @@ publish_to: "none" # Remove this line if you wish to publish to pub.dev
 # https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html
 # In Windows, build-name is used as the major, minor, and patch parts
 # of the product and file versions while build-number is used as the build suffix.
-version: 0.6.0+3
+version: 0.7.3+11
 
 environment:
   sdk: ^3.8.1