spa hardening, offline logging, rate limit fixes

server:
- backup exporter, auth extractors, error shapes, CONTEXT (prior work)
- spa assets served outside the rate limit via route_layer
- requests_per_second went to per_second(), which takes an interval not a
  rate: 50 meant one request per 50s once burst was spent. now converted
  properly. 15/s, burst 60

spa fixes:
- account delete cleared snake_case token keys that were never written
- refresh interceptor could retry forever
- date ranges used local day boundaries stamped +00:00
- "all" period trend plotted one page; calendar days fabricated mood 3
- chart grid invisible: hsl(var(--border)) against rgba tokens
- blob url leak, orphaned media on failed save, devtools in prod bundle
- pt-safe/safe-area-pb classes never existed

spa features:
- offline outbox: entries queue to IndexedDB, replay with backoff, only
  server refusals count against an entry
- drafts persist, quick-log sheet, diary infinite scroll + filters
- route error boundary, stale-chunk recovery, no service worker in dev

a11y + perf:
- mood picker is a radiogroup, activity picker keyboard-operable,
  text alternatives for colour/emoji, locale week start
- dark glass over the bright photo: worst case 1.4:1 -> 4.9-9.6:1
- initial payload 1095->769kB raw, 306->230kB gzip; 38 unused components
  and 5 deps dropped; fonts 218->133kB

53 tests added (43 spa, 10 server)

crates/application/tests/entry/mood_stats_test.rs

@@ -80,3 +80,72 @@ fn user_in(name: &str, timezone: &str) -> domain::user::User {
     user.update_timezone(Some(Timezone::new(timezone).unwrap()));
     user
 }
+
+fn a_user_in_warsaw() -> domain::user::User {
+    user_in("alice", "Europe/Warsaw")
+}
+
+async fn stats_of(
+    store: &Arc<InMemoryStore>,
+    user: &domain::user::User,
+    range: Option<domain::entry::DateRange>,
+) -> get_mood_stats::MoodStats {
+    let deps = get_mood_stats::Deps {
+        query: store.clone(),
+        users: store.clone(),
+    };
+
+    get_mood_stats::execute(
+        MoodStatsQuery {
+            user_id: user.id().clone(),
+            range,
+        },
+        &deps,
+    )
+    .await
+    .unwrap()
+}
+
+#[tokio::test]
+async fn the_bounds_are_the_days_the_journal_actually_spans() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    for days_ago in [0, 5, 40] {
+        let entry = domain::testing::test_entry_days_ago(user.id().clone(), Mood::Good, days_ago);
+        MoodEntryCommandPort::save(store.as_ref(), &entry)
+            .await
+            .unwrap();
+    }
+
+    let stats = stats_of(&store, &user, None).await;
+
+    let today = domain::entry::Date::from_instant(
+        &chrono::Utc::now().fixed_offset(),
+        &domain::user::Timezone::new("Europe/Warsaw").unwrap(),
+    );
+
+    assert_eq!(
+        stats.last_logged_on,
+        Some(today),
+        "the newest entry was logged today"
+    );
+    assert!(
+        stats.first_logged_on.unwrap() < today,
+        "the oldest was forty days back"
+    );
+}
+
+#[tokio::test]
+async fn an_empty_journal_has_no_bounds() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    let stats = stats_of(&store, &user, None).await;
+
+    assert_eq!(stats.total_entries, 0);
+    assert_eq!(stats.first_logged_on, None);
+    assert_eq!(stats.last_logged_on, None);
+}