chore: release v0.1.0.68

Stoppt den Bootstrap nach einem erfolgreichen Hard-Recovery sofort, damit vor dem asynchronen Reload kein React-Render mehr gestartet wird.

Co-authored-by: Cursor <cursoragent@cursor.com>

VERSION

@@ -1 +1 @@
-0.1.0.65
+0.1.0.69

client/nginx.conf

@@ -4,7 +4,7 @@ server {
     client_max_body_size 50M;
 
     # Service worker and app shell must revalidate so PWA updates are detected
-    location ~* ^/(sw\.js|workbox-.*\.js|manifest\.webmanifest)$ {
+    location ~* ^/(sw\.js|workbox-.*\.js|manifest\.webmanifest|version\.json)$ {
         root /usr/share/nginx/html;
         add_header Cache-Control "no-cache, no-store, must-revalidate";
     }

client/src/App.css

@@ -1371,6 +1371,140 @@ html.scheme-dark .themed-select-option.is-selected {
   gap: 20px;
 }
 
+.dashboard-list-controls {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+
+.dashboard-filter-bar {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.dashboard-sort-bar {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.dashboard-sort-label {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--app-text-muted);
+}
+
+.dashboard-sort-row {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+  align-items: stretch;
+}
+
+.dashboard-sort-group {
+  display: flex;
+  flex: 0 0 auto;
+  gap: 6px;
+}
+
+.dashboard-sort-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 36px;
+  height: 36px;
+  padding: 0;
+  border-radius: 8px;
+  border: 1px solid var(--app-border-subtle);
+  background: var(--app-surface-alt);
+  color: var(--app-text-muted);
+  cursor: pointer;
+  transition: border-color 0.2s, background-color 0.2s, color 0.2s;
+}
+
+.dashboard-sort-btn:hover {
+  border-color: var(--app-border);
+  color: var(--app-text-heading);
+}
+
+.dashboard-sort-btn.is-active {
+  border-color: var(--app-accent-border);
+  background: var(--app-accent-bg);
+  color: var(--app-accent-light);
+}
+
+.dashboard-sort-btn:focus-visible {
+  outline: 2px solid var(--app-accent-focus-ring);
+  outline-offset: 2px;
+}
+
+.dashboard-filter-label {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--app-text-muted);
+  margin: 0;
+}
+
+.dashboard-filter-input-wrap {
+  position: relative;
+  display: flex;
+  align-items: center;
+  width: 100%;
+}
+
+.dashboard-filter-icon {
+  position: absolute;
+  left: 14px;
+  color: var(--app-text-muted);
+  pointer-events: none;
+  flex-shrink: 0;
+}
+
+.dashboard-filter-input {
+  width: 100%;
+  padding-left: 42px;
+  padding-right: 42px;
+  min-height: 44px;
+}
+
+.dashboard-filter-input::-webkit-search-cancel-button {
+  display: none;
+}
+
+.dashboard-filter-clear {
+  position: absolute;
+  right: 6px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 32px;
+  height: 32px;
+  padding: 0;
+  border: none;
+  border-radius: 6px;
+  background: transparent;
+  color: var(--app-text-muted);
+  cursor: pointer;
+  transition: color 0.2s, background-color 0.2s;
+}
+
+.dashboard-filter-clear:hover {
+  color: var(--app-text-heading);
+  background: var(--app-accent-bg);
+}
+
+.dashboard-filter-clear:focus-visible {
+  outline: 2px solid var(--app-accent-focus-ring);
+  outline-offset: 2px;
+}
+
+.dashboard-filter-meta {
+  margin: 0;
+  font-size: 13px;
+  color: var(--app-text-muted);
+}
+
 .section-title-bar {
   display: flex;
   justify-content: space-between;
@@ -2322,6 +2456,37 @@ html.scheme-dark .themed-select-option.is-selected {
     word-break: break-word;
   }
 
+  .dashboard-sort-bar {
+    flex-direction: row;
+    align-items: center;
+    gap: 10px;
+  }
+
+  .dashboard-sort-label {
+    flex-shrink: 0;
+    min-width: 4.75rem;
+  }
+
+  .dashboard-sort-row {
+    flex: 1;
+    min-width: 0;
+    flex-wrap: nowrap;
+    gap: 12px;
+  }
+
+  .dashboard-sort-group {
+    flex: 1;
+    min-width: 0;
+    gap: 6px;
+  }
+
+  .dashboard-sort-btn {
+    flex: 1;
+    width: auto;
+    min-width: 44px;
+    height: 44px;
+  }
+
   .logbooks-grid {
     grid-template-columns: 1fr;
     gap: 16px;
@@ -3632,6 +3797,59 @@ html.theme-cupertino .events-scroll-container {
   .stats-kpi-value {
     font-size: 20px;
   }
+
+  .profile-stats-section.form-card {
+    padding: 20px 16px;
+  }
+
+  .profile-stats-section .form-header {
+    margin-bottom: 12px;
+    gap: 10px;
+  }
+
+  .profile-stats-section .form-header h2 {
+    font-size: 18px;
+  }
+
+  .profile-stats-section .stats-subtitle {
+    font-size: 12px;
+    line-height: 1.35;
+  }
+
+  .profile-stats-kpi-grid {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    gap: 8px;
+    margin-top: 0;
+  }
+
+  .profile-stats-kpi-grid .stats-kpi-card {
+    padding: 10px;
+    gap: 8px;
+    align-items: center;
+  }
+
+  .profile-stats-kpi-grid .stats-kpi-icon {
+    margin-top: 0;
+  }
+
+  .profile-stats-kpi-grid .stats-kpi-icon svg {
+    width: 16px;
+    height: 16px;
+  }
+
+  .profile-stats-kpi-grid .stats-kpi-label {
+    font-size: 11px;
+    margin-bottom: 2px;
+    line-height: 1.25;
+  }
+
+  .profile-stats-kpi-grid .stats-kpi-value {
+    font-size: 16px;
+  }
+
+  .profile-stats-kpi-grid .stats-kpi-unit {
+    font-size: 11px;
+  }
 }
 
 .signature-grid {

client/src/App.tsx

@@ -1,5 +1,4 @@
 import { useState, useEffect, useCallback, useRef } from 'react'
-import './App.css'
 import { DialogProvider } from './components/ModalDialog.tsx'
 import AuthOnboarding from './components/AuthOnboarding.tsx'
 import UserProfilePage from './components/UserProfilePage.tsx'

client/src/components/LogbookDashboard.tsx

@@ -1,4 +1,4 @@
-import React, { useState, useEffect, useRef } from 'react'
+import React, { useState, useEffect, useRef, useMemo } from 'react'
 import { useTranslation } from 'react-i18next'
 import { useSyncIndicator } from '../hooks/useSyncIndicator.js'
 import { fetchLogbooks, createLogbook, deleteLogbook, updateLogbookTitle, type DecryptedLogbook } from '../services/logbook.js'
@@ -7,7 +7,7 @@ import BetaBadge from './BetaBadge.tsx'
 import { PlausibleEvents, trackPlausibleEvent } from '../services/analytics.js'
 import { logoutUser } from '../services/auth.js'
 import { useDialog } from './ModalDialog.tsx'
-import { BookOpen, Plus, Trash2, LogOut, Languages, RefreshCw, Ship, User, Wifi, WifiOff } from 'lucide-react'
+import { BookOpen, Plus, Trash2, LogOut, Languages, RefreshCw, Ship, User, Wifi, WifiOff, Search, X, CalendarDays, CaseSensitive, ArrowUp, ArrowDown } from 'lucide-react'
 import DisclaimerHeaderButton from './DisclaimerHeaderButton.tsx'
 import FeedbackHeaderButton from './FeedbackHeaderButton.tsx'
 
@@ -17,6 +17,46 @@ interface LogbookDashboardProps {
   onOpenProfile: () => void
 }
 
+function logbookMatchesFilter(lb: DecryptedLogbook, query: string, locale: string): boolean {
+  const q = query.trim().toLowerCase()
+  if (!q) return true
+
+  if (lb.title.toLowerCase().includes(q)) return true
+
+  const updated = new Date(lb.updatedAt)
+  const year = updated.getFullYear().toString()
+  if (year.includes(q)) return true
+
+  const dateLabel = updated.toLocaleDateString(locale, {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric'
+  }).toLowerCase()
+  if (dateLabel.includes(q)) return true
+
+  return false
+}
+
+type LogbookSortKey = 'name' | 'date'
+type LogbookSortDirection = 'asc' | 'desc'
+
+function sortLogbooks(
+  items: DecryptedLogbook[],
+  sortBy: LogbookSortKey,
+  direction: LogbookSortDirection,
+  locale: string
+): DecryptedLogbook[] {
+  const sorted = [...items]
+  sorted.sort((a, b) => {
+    const cmp =
+      sortBy === 'name'
+        ? a.title.localeCompare(b.title, locale, { sensitivity: 'base' })
+        : new Date(a.updatedAt).getTime() - new Date(b.updatedAt).getTime()
+    return direction === 'asc' ? cmp : -cmp
+  })
+  return sorted
+}
+
 export default function LogbookDashboard({ onSelectLogbook, onLogout, onOpenProfile }: LogbookDashboardProps) {
   const { t, i18n } = useTranslation()
   const { showConfirm } = useDialog()
@@ -28,6 +68,10 @@ export default function LogbookDashboard({ onSelectLogbook, onLogout, onOpenProf
   const [loading, setLoading] = useState(false)
   const [refreshing, setRefreshing] = useState(false)
   const [error, setError] = useState<string | null>(null)
+  const [filterQuery, setFilterQuery] = useState('')
+  const [sortBy, setSortBy] = useState<LogbookSortKey>('date')
+  const [sortDirection, setSortDirection] = useState<LogbookSortDirection>('desc')
+  const filterInputRef = useRef<HTMLInputElement>(null)
   const [online, setOnline] = useState(navigator.onLine)
   const [username] = useState(localStorage.getItem('active_username') || 'Skipper')
 
@@ -156,6 +200,25 @@ export default function LogbookDashboard({ onSelectLogbook, onLogout, onOpenProf
   const ownedLogbooks = logbooks.filter((lb) => !lb.isShared)
   const sharedLogbooks = logbooks.filter((lb) => lb.isShared)
 
+  const filterActive = filterQuery.trim().length > 0
+  const filteredOwnedLogbooks = useMemo(
+    () => ownedLogbooks.filter((lb) => logbookMatchesFilter(lb, filterQuery, i18n.language)),
+    [ownedLogbooks, filterQuery, i18n.language]
+  )
+  const filteredSharedLogbooks = useMemo(
+    () => sharedLogbooks.filter((lb) => logbookMatchesFilter(lb, filterQuery, i18n.language)),
+    [sharedLogbooks, filterQuery, i18n.language]
+  )
+  const sortedOwnedLogbooks = useMemo(
+    () => sortLogbooks(filteredOwnedLogbooks, sortBy, sortDirection, i18n.language),
+    [filteredOwnedLogbooks, sortBy, sortDirection, i18n.language]
+  )
+  const sortedSharedLogbooks = useMemo(
+    () => sortLogbooks(filteredSharedLogbooks, sortBy, sortDirection, i18n.language),
+    [filteredSharedLogbooks, sortBy, sortDirection, i18n.language]
+  )
+  const filteredLogbookCount = sortedOwnedLogbooks.length + sortedSharedLogbooks.length
+
   const renderLogbookCard = (lb: DecryptedLogbook) => {
     const isEditingTitle = editingLogbookId === lb.id
 
@@ -376,17 +439,115 @@ export default function LogbookDashboard({ onSelectLogbook, onLogout, onOpenProf
           ) : logbooks.length === 0 ? (
             <div className="dashboard-status-msg glass">{t('dashboard.no_logbooks')}</div>
           ) : (
-            <div className="logbook-sections">
-              {ownedLogbooks.length > 0 && renderLogbookSection(
-                sharedLogbooks.length > 0 ? t('dashboard.section_owned') : t('dashboard.title'),
-                ownedLogbooks
+            <>
+              <div className="dashboard-list-controls">
+                <div className="dashboard-filter-bar">
+                  <label className="dashboard-filter-label" htmlFor="logbook-list-filter">
+                    {t('dashboard.filter_label')}
+                  </label>
+                  <div className="dashboard-filter-input-wrap">
+                    <Search size={18} className="dashboard-filter-icon" aria-hidden="true" />
+                    <input
+                      ref={filterInputRef}
+                      id="logbook-list-filter"
+                      type="search"
+                      className="input-text dashboard-filter-input"
+                      placeholder={t('dashboard.filter_placeholder')}
+                      value={filterQuery}
+                      onChange={(e) => setFilterQuery(e.target.value)}
+                      autoComplete="off"
+                      spellCheck={false}
+                      aria-describedby={filterActive ? 'logbook-filter-status' : undefined}
+                    />
+                    {filterActive && (
+                      <button
+                        type="button"
+                        className="dashboard-filter-clear"
+                        onClick={() => {
+                          setFilterQuery('')
+                          filterInputRef.current?.focus()
+                        }}
+                        title={t('dashboard.filter_clear')}
+                        aria-label={t('dashboard.filter_clear')}
+                      >
+                        <X size={16} aria-hidden="true" />
+                      </button>
+                    )}
+                  </div>
+                  {filterActive && (
+                    <p id="logbook-filter-status" className="dashboard-filter-meta" role="status">
+                      {t('dashboard.filter_results', { count: filteredLogbookCount })}
+                    </p>
+                  )}
+                </div>
+
+                <div className="dashboard-sort-bar">
+                  <span className="dashboard-sort-label">{t('dashboard.sort_label')}</span>
+                  <div className="dashboard-sort-row">
+                    <div className="dashboard-sort-group" role="group" aria-label={t('dashboard.sort_by_label')}>
+                      <button
+                        type="button"
+                        className={`dashboard-sort-btn${sortBy === 'name' ? ' is-active' : ''}`}
+                        onClick={() => setSortBy('name')}
+                        aria-pressed={sortBy === 'name'}
+                        aria-label={t('dashboard.sort_by_name')}
+                        title={t('dashboard.sort_by_name')}
+                      >
+                        <CaseSensitive size={16} aria-hidden="true" />
+                      </button>
+                      <button
+                        type="button"
+                        className={`dashboard-sort-btn${sortBy === 'date' ? ' is-active' : ''}`}
+                        onClick={() => setSortBy('date')}
+                        aria-pressed={sortBy === 'date'}
+                        aria-label={t('dashboard.sort_by_date')}
+                        title={t('dashboard.sort_by_date')}
+                      >
+                        <CalendarDays size={16} aria-hidden="true" />
+                      </button>
+                    </div>
+                    <div className="dashboard-sort-group" role="group" aria-label={t('dashboard.sort_dir_label')}>
+                      <button
+                        type="button"
+                        className={`dashboard-sort-btn${sortDirection === 'asc' ? ' is-active' : ''}`}
+                        onClick={() => setSortDirection('asc')}
+                        aria-pressed={sortDirection === 'asc'}
+                        aria-label={sortBy === 'name' ? t('dashboard.sort_name_asc') : t('dashboard.sort_date_asc')}
+                        title={sortBy === 'name' ? t('dashboard.sort_name_asc') : t('dashboard.sort_date_asc')}
+                      >
+                        <ArrowUp size={16} aria-hidden="true" />
+                      </button>
+                      <button
+                        type="button"
+                        className={`dashboard-sort-btn${sortDirection === 'desc' ? ' is-active' : ''}`}
+                        onClick={() => setSortDirection('desc')}
+                        aria-pressed={sortDirection === 'desc'}
+                        aria-label={sortBy === 'name' ? t('dashboard.sort_name_desc') : t('dashboard.sort_date_desc')}
+                        title={sortBy === 'name' ? t('dashboard.sort_name_desc') : t('dashboard.sort_date_desc')}
+                      >
+                        <ArrowDown size={16} aria-hidden="true" />
+                      </button>
+                    </div>
+                  </div>
+                </div>
+              </div>
+
+              {filterActive && filteredLogbookCount === 0 ? (
+                <div className="dashboard-status-msg glass">{t('dashboard.filter_no_results')}</div>
+              ) : (
+                <div className="logbook-sections">
+                  {sortedOwnedLogbooks.length > 0 && renderLogbookSection(
+                    sortedSharedLogbooks.length > 0 ? t('dashboard.section_owned') : t('dashboard.title'),
+                    sortedOwnedLogbooks
+                  )}
+                  {sortedSharedLogbooks.length > 0 && renderLogbookSection(
+                    t('dashboard.section_shared'),
+                    sortedSharedLogbooks,
+                    t('dashboard.section_shared_hint')
+                  )}
+                </div>
               )}
-              {sharedLogbooks.length > 0 && renderLogbookSection(
-                t('dashboard.section_shared'),
-                sharedLogbooks,
-                t('dashboard.section_shared_hint')
-              )}
-            </div>
+            </>
           )}
         </section>
       </main>

client/src/components/UserProfilePage.tsx

@@ -726,7 +726,7 @@ export default function UserProfilePage({ onBack, onLogout }: UserProfilePagePro
               </div>
             </section>
 
-            <section className="form-card">
+            <section className="form-card profile-stats-section">
               <div className="form-header">
                 <BarChart2 size={24} className="form-icon" />
                 <div>
@@ -736,7 +736,7 @@ export default function UserProfilePage({ onBack, onLogout }: UserProfilePagePro
               </div>
 
               {(statsTotals || profile) && (
-                <div className="stats-kpi-grid">
+                <div className="stats-kpi-grid profile-stats-kpi-grid">
                   <KpiCard
                     icon={<BookOpen size={20} />}
                     label={t('profile.stats_logbooks')}

client/src/hooks/usePwaUpdate.ts

@@ -1,12 +1,19 @@
 import { useEffect, useRef } from 'react'
 import { useRegisterSW } from 'virtual:pwa-register/react'
-import { markReloadAttempt, recentlyAttemptedReload } from '../services/pwaStartup.js'
+import {
+  forcePwaRecovery,
+  markReloadAttempt,
+  recentlyAttemptedReload,
+  triggerServiceWorkerUpdate
+} from '../services/pwaStartup.js'
+import { isDeployedVersionNewer } from '../services/pwaVersion.js'
 
-const UPDATE_CHECK_INTERVAL_MS = 60 * 60 * 1000
+const UPDATE_CHECK_INTERVAL_MS = 15 * 60 * 1000
 const UPDATE_SUPPRESS_KEY = 'pwa_update_suppress_until'
 const UPDATE_SUPPRESS_MS = 30_000
-const UPDATE_DISMISS_SUPPRESS_MS = 60 * 60 * 1000
-const UPDATE_RELOAD_FALLBACK_MS = 2000
+const UPDATE_DISMISS_SUPPRESS_MS = 15 * 60 * 1000
+const UPDATE_RELOAD_FALLBACK_MS = 2_000
+const UPDATE_HARD_RECOVERY_MS = 5_000
 
 function isUpdateSuppressed(): boolean {
   const suppressUntil = Number(sessionStorage.getItem(UPDATE_SUPPRESS_KEY) || '0')
@@ -21,10 +28,16 @@ function clearUpdateSuppression(): void {
   sessionStorage.removeItem(UPDATE_SUPPRESS_KEY)
 }
 
-function scheduleUpdateChecks(registration: ServiceWorkerRegistration): () => void {
+function scheduleUpdateChecks(
+  registration: ServiceWorkerRegistration,
+  onOutdated: () => void
+): () => void {
   const checkForUpdate = () => {
     if (isUpdateSuppressed()) return
     registration.update().catch(() => {})
+    void isDeployedVersionNewer().then((outdated) => {
+      if (outdated) onOutdated()
+    })
   }
 
   const onVisibilityChange = () => {
@@ -33,12 +46,20 @@ function scheduleUpdateChecks(registration: ServiceWorkerRegistration): () => vo
     }
   }
 
+  const onOnline = () => {
+    checkForUpdate()
+  }
+
   document.addEventListener('visibilitychange', onVisibilityChange)
-  const intervalId = window.setInterval(checkForUpdate, UPDATE_CHECK_INTERVAL_MS)
+  window.addEventListener('online', onOnline)
+  const updateIntervalId = window.setInterval(checkForUpdate, UPDATE_CHECK_INTERVAL_MS)
+
+  checkForUpdate()
 
   return () => {
     document.removeEventListener('visibilitychange', onVisibilityChange)
-    window.clearInterval(intervalId)
+    window.removeEventListener('online', onOnline)
+    window.clearInterval(updateIntervalId)
   }
 }
 
@@ -51,6 +72,18 @@ function reloadForServiceWorkerTakeover(): void {
 
 export function usePwaUpdate() {
   const cleanupRef = useRef<(() => void) | null>(null)
+  const reloadFallbackTimerRef = useRef<number | null>(null)
+  const forceRecoveryTimerRef = useRef<number | null>(null)
+  const setNeedRefreshRef = useRef<((value: boolean) => void) | null>(null)
+  const pendingNeedRefreshRef = useRef<boolean | null>(null)
+
+  const applyNeedRefresh = (value: boolean) => {
+    if (setNeedRefreshRef.current) {
+      setNeedRefreshRef.current(value)
+      return
+    }
+    pendingNeedRefreshRef.current = value
+  }
 
   const {
     needRefresh: [needRefresh, setNeedRefresh],
@@ -58,32 +91,56 @@ export function usePwaUpdate() {
   } = useRegisterSW({
     immediate: !import.meta.env.DEV,
     onNeedReload() {
-      reloadForServiceWorkerTakeover()
+      if (isUpdateSuppressed()) return
+      applyNeedRefresh(true)
     },
     onNeedRefresh() {
       if (isUpdateSuppressed()) return
-      setNeedRefresh(true)
+      applyNeedRefresh(true)
     },
     onRegisteredSW(_swUrl: string, registration: ServiceWorkerRegistration | undefined) {
       if (!registration) return
 
       if (isUpdateSuppressed() || !registration.waiting) {
-        setNeedRefresh(false)
+        applyNeedRefresh(false)
       }
 
       cleanupRef.current?.()
-      cleanupRef.current = scheduleUpdateChecks(registration)
+      cleanupRef.current = scheduleUpdateChecks(registration, () => {
+        if (isUpdateSuppressed()) return
+        applyNeedRefresh(true)
+      })
     }
   })
 
+  setNeedRefreshRef.current = setNeedRefresh
+
   useEffect(() => {
     if (isUpdateSuppressed()) {
       setNeedRefresh(false)
+    } else if (pendingNeedRefreshRef.current !== null) {
+      const pending = pendingNeedRefreshRef.current
+      pendingNeedRefreshRef.current = null
+      setNeedRefresh(pending)
     }
 
+    void isDeployedVersionNewer().then((outdated) => {
+      if (outdated) {
+        setNeedRefresh(true)
+      }
+    })
+
     return () => {
       cleanupRef.current?.()
       cleanupRef.current = null
+      if (reloadFallbackTimerRef.current !== null) {
+        window.clearTimeout(reloadFallbackTimerRef.current)
+        reloadFallbackTimerRef.current = null
+      }
+      if (forceRecoveryTimerRef.current !== null) {
+        window.clearTimeout(forceRecoveryTimerRef.current)
+        forceRecoveryTimerRef.current = null
+      }
     }
   }, [setNeedRefresh])
 
@@ -92,11 +149,24 @@ export function usePwaUpdate() {
     suppressUpdatePrompt()
 
     await updateServiceWorker(true)
+    await triggerServiceWorkerUpdate()
 
-    // vite-plugin-pwa reloads via the "controlling" event; fallback if that does not fire.
-    window.setTimeout(() => {
+    if (reloadFallbackTimerRef.current !== null) {
+      window.clearTimeout(reloadFallbackTimerRef.current)
+    }
+    if (forceRecoveryTimerRef.current !== null) {
+      window.clearTimeout(forceRecoveryTimerRef.current)
+    }
+
+    reloadFallbackTimerRef.current = window.setTimeout(() => {
+      reloadFallbackTimerRef.current = null
       reloadForServiceWorkerTakeover()
     }, UPDATE_RELOAD_FALLBACK_MS)
+
+    forceRecoveryTimerRef.current = window.setTimeout(() => {
+      forceRecoveryTimerRef.current = null
+      void forcePwaRecovery()
+    }, UPDATE_HARD_RECOVERY_MS)
   }
 
   const dismissUpdate = () => {

client/src/i18n/locales/de.json

@@ -304,7 +304,23 @@
       "edit_title": "Logbuch umbenennen",
       "edit_placeholder": "Neuer Name des Logbuchs",
       "edit_success": "Logbuch erfolgreich umbenannt",
-      "edit_btn": "Umbenennen"
+      "edit_btn": "Umbenennen",
+      "filter_label": "Logbücher filtern",
+      "filter_placeholder": "Name, Jahr oder Datum …",
+      "filter_clear": "Filter zurücksetzen",
+      "filter_results": "{{count}} Treffer",
+      "filter_no_results": "Keine Logbücher passen zu deiner Suche. Probiere einen anderen Namen oder ein anderes Jahr.",
+      "sort_label": "Sortieren",
+      "sort_by_label": "Sortieren nach",
+      "sort_by_name": "Name",
+      "sort_by_date": "Datum",
+      "sort_dir_label": "Reihenfolge",
+      "sort_asc": "Aufsteigend",
+      "sort_desc": "Absteigend",
+      "sort_name_asc": "Name A bis Z",
+      "sort_name_desc": "Name Z bis A",
+      "sort_date_asc": "Älteste zuerst",
+      "sort_date_desc": "Neueste zuerst"
     },
     "profile": {
       "title": "Benutzerprofil",

client/src/i18n/locales/en.json

@@ -304,7 +304,23 @@
       "edit_title": "Rename Logbook",
       "edit_placeholder": "New name of the logbook",
       "edit_success": "Logbook renamed successfully",
-      "edit_btn": "Rename"
+      "edit_btn": "Rename",
+      "filter_label": "Filter logbooks",
+      "filter_placeholder": "Name, year or date …",
+      "filter_clear": "Clear filter",
+      "filter_results": "{{count}} matches",
+      "filter_no_results": "No logbooks match your search. Try a different name or year.",
+      "sort_label": "Sort",
+      "sort_by_label": "Sort by",
+      "sort_by_name": "Name",
+      "sort_by_date": "Date",
+      "sort_dir_label": "Order",
+      "sort_asc": "Ascending",
+      "sort_desc": "Descending",
+      "sort_name_asc": "Name A to Z",
+      "sort_name_desc": "Name Z to A",
+      "sort_date_asc": "Oldest first",
+      "sort_date_desc": "Newest first"
     },
     "profile": {
       "title": "User profile",

client/src/index.css

@@ -1,64 +1,8 @@
-:root {
-  --text: #6b6375;
-  --text-h: #08060d;
-  --bg: #fff;
-  --border: #e5e4e7;
-  --code-bg: #f4f3ec;
-  --accent: #aa3bff;
-  --accent-bg: rgba(170, 59, 255, 0.1);
-  --accent-border: rgba(170, 59, 255, 0.5);
-  --social-bg: rgba(244, 243, 236, 0.5);
-  --shadow:
-    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+/* Minimal app shell — component styles live in App.css / themes.css */
 
-  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
-  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
-  --mono: ui-monospace, Consolas, monospace;
-
-  font: 18px/145% var(--sans);
-  letter-spacing: 0.18px;
-  color-scheme: light dark;
-  color: var(--text);
-  background: var(--bg);
-  font-synthesis: none;
-  text-rendering: optimizeLegibility;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-
-  @media (max-width: 1024px) {
-    font-size: 16px;
-  }
-}
-
-@media (prefers-color-scheme: dark) {
-  :root {
-    --text: #9ca3af;
-    --text-h: #f3f4f6;
-    --bg: #16171d;
-    --border: #2e303a;
-    --code-bg: #1f2028;
-    --accent: #c084fc;
-    --accent-bg: rgba(192, 132, 252, 0.15);
-    --accent-border: rgba(192, 132, 252, 0.5);
-    --social-bg: rgba(47, 48, 58, 0.5);
-    --shadow:
-      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
-  }
-
-  #social .button-icon {
-    filter: invert(1) brightness(2);
-  }
-}
-
-#root {
-  width: 1126px;
-  max-width: 100%;
-  margin: 0 auto;
-  text-align: center;
-  border-inline: 1px solid var(--border);
-  min-height: 100svh;
-  display: flex;
-  flex-direction: column;
+*,
+*::before,
+*::after {
   box-sizing: border-box;
 }
 
@@ -66,44 +10,11 @@ body {
   margin: 0;
 }
 
-h1,
-h2 {
-  font-family: var(--heading);
-  font-weight: 500;
-  color: var(--text-h);
-}
-
-h1 {
-  font-size: 56px;
-  letter-spacing: -1.68px;
-  margin: 32px 0;
-  @media (max-width: 1024px) {
-    font-size: 36px;
-    margin: 20px 0;
-  }
-}
-h2 {
-  font-size: 24px;
-  line-height: 118%;
-  letter-spacing: -0.24px;
-  margin: 0 0 8px;
-  @media (max-width: 1024px) {
-    font-size: 20px;
-  }
-}
-p {
-  margin: 0;
-}
-
-code,
-.counter {
-  font-family: var(--mono);
-  display: inline-flex;
-  border-radius: 4px;
-}
-
-code {
-  font-size: 15px;
-  line-height: 135%;
-  padding: 4px 8px;
+#root {
+  width: 100%;
+  max-width: 100%;
+  min-height: 100svh;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
 }

client/src/main.tsx

@@ -3,13 +3,14 @@ import { createRoot } from 'react-dom/client'
 import 'leaflet/dist/leaflet.css'
 import './themes.css'
 import './index.css'
+import './App.css'
 import './i18n'
 import App from './App.tsx'
 import { applyAppearanceToDocument } from './services/appearance.ts'
 import {
   installStaleAssetRecovery,
   markReloadAttempt,
-  reconcileServiceWorkerOnStartup
+  reconcileVersionOnStartup
 } from './services/pwaStartup.ts'
 
 /** Stale PWA precache on localhost can shadow Vite dev modules. */
@@ -43,12 +44,15 @@ async function bootstrap(): Promise<void> {
   installStaleAssetRecovery()
   await clearDevServiceWorkerCaches()
 
-  const shouldReloadForWaitingSw = await reconcileServiceWorkerOnStartup()
-  if (shouldReloadForWaitingSw) {
+  const startupResult = await reconcileVersionOnStartup()
+  if (startupResult === 'reload') {
     markReloadAttempt()
     window.location.reload()
     return
   }
+  if (startupResult === 'recovered') {
+    return
+  }
 
   const rootEl = document.getElementById('root')
   if (!rootEl) {

client/src/services/appearancePrefs.test.ts

@@ -69,4 +69,28 @@ describe('appearancePrefs', () => {
     await saveAppearancePrefsToServer('ocean', 'light')
     expect(mockedApiJson).not.toHaveBeenCalled()
   })
+
+  it('syncAppearancePrefs skips server sync when userId does not match active session', async () => {
+    localStorage.setItem('active_userid', 'session-user')
+    setThemePreference('other-user', 'ocean')
+    mockedApiJson.mockResolvedValue({
+      theme: 'material',
+      colorScheme: 'dark',
+      persisted: true
+    })
+
+    await syncAppearancePrefs('other-user')
+
+    expect(mockedApiJson).not.toHaveBeenCalled()
+    expect(localStorage.getItem('user_pref_theme_other-user')).toBe('ocean')
+  })
+
+  it('syncAppearancePrefs skips server sync when active session is missing', async () => {
+    setThemePreference(USER_ID, 'ocean')
+
+    await syncAppearancePrefs(USER_ID)
+
+    expect(mockedApiJson).not.toHaveBeenCalled()
+    expect(localStorage.getItem(`user_pref_theme_${USER_ID}`)).toBe('ocean')
+  })
 })

client/src/services/appearancePrefs.ts

@@ -23,16 +23,30 @@ function hasLocalAppearancePrefs(userId: string): boolean {
   )
 }
 
-export async function fetchAppearancePrefs(): Promise<AppearancePrefs> {
-  if (!getActiveUserId()) {
+function resolveSyncedUserId(userId?: string | null): string | null {
+  const id = userId?.trim() || getActiveUserId()?.trim() || null
+  if (!id) return null
+
+  const activeId = getActiveUserId()?.trim() || null
+  if (!activeId || activeId !== id) return null
+
+  return id
+}
+
+export async function fetchAppearancePrefs(userId?: string | null): Promise<AppearancePrefs> {
+  if (!resolveSyncedUserId(userId)) {
     return { theme: 'auto', colorScheme: 'auto', persisted: false }
   }
 
   return apiJson<AppearancePrefs>(API_BASE)
 }
 
-export async function saveAppearancePrefsToServer(theme: string, colorScheme: string): Promise<void> {
-  if (!getActiveUserId()) return
+export async function saveAppearancePrefsToServer(
+  theme: string,
+  colorScheme: string,
+  userId?: string | null
+): Promise<void> {
+  if (!resolveSyncedUserId(userId)) return
 
   await apiJson<AppearancePrefs>(API_BASE, {
     method: 'PUT',
@@ -42,17 +56,17 @@ export async function saveAppearancePrefsToServer(theme: string, colorScheme: st
 
 /** Merge server-stored appearance with local cache (server wins after cache wipe). */
 export async function syncAppearancePrefs(userId?: string | null): Promise<void> {
-  const id = userId?.trim() || getActiveUserId()
+  const id = resolveSyncedUserId(userId)
   if (!id) return
 
   try {
-    const server = await fetchAppearancePrefs()
+    const server = await fetchAppearancePrefs(id)
 
     if (server.persisted) {
       setThemePreference(id, server.theme)
       setColorSchemePreference(id, server.colorScheme)
     } else if (hasLocalAppearancePrefs(id)) {
-      await saveAppearancePrefsToServer(getThemePreference(id), getColorSchemePreference(id))
+      await saveAppearancePrefsToServer(getThemePreference(id), getColorSchemePreference(id), id)
     }
   } catch (err) {
     console.warn('Failed to sync appearance preferences:', err)

client/src/services/pwaStartup.test.ts

@@ -1,10 +1,15 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import {
+  forcePwaRecovery,
   markReloadAttempt,
   recentlyAttemptedReload,
-  reconcileServiceWorkerOnStartup
+  reconcileServiceWorkerOnStartup,
+  reconcileVersionOnStartup
 } from './pwaStartup.js'
 
+const STALE_RECOVERY_COUNT_KEY = 'pwa_stale_recovery_count'
+const STALE_RECOVERY_LAST_KEY = 'pwa_stale_recovery_last_ts'
+
 describe('pwaStartup reload guards', () => {
   beforeEach(() => {
     sessionStorage.clear()
@@ -18,6 +23,45 @@ describe('pwaStartup reload guards', () => {
   })
 })
 
+describe('forcePwaRecovery stale counter reset', () => {
+  beforeEach(() => {
+    sessionStorage.clear()
+    vi.unstubAllEnvs()
+    vi.restoreAllMocks()
+  })
+
+  it('clears stale recovery counter before hard recovery reload', async () => {
+    vi.stubEnv('DEV', false)
+    sessionStorage.setItem(STALE_RECOVERY_COUNT_KEY, '2')
+    sessionStorage.setItem(STALE_RECOVERY_LAST_KEY, String(Date.now()))
+
+    const reload = vi.fn()
+    vi.stubGlobal('location', { reload })
+    vi.stubGlobal('caches', {
+      keys: vi.fn().mockResolvedValue([]),
+      delete: vi.fn()
+    })
+    Object.defineProperty(navigator, 'serviceWorker', {
+      configurable: true,
+      value: {
+        getRegistrations: vi.fn().mockResolvedValue([])
+      }
+    })
+
+    await forcePwaRecovery()
+
+    expect(sessionStorage.getItem(STALE_RECOVERY_COUNT_KEY)).toBeNull()
+    expect(sessionStorage.getItem(STALE_RECOVERY_LAST_KEY)).toBeNull()
+    expect(reload).toHaveBeenCalledOnce()
+  })
+
+  it('returns false when hard recovery was just attempted', async () => {
+    sessionStorage.setItem('pwa_hard_recovery_ts', String(Date.now()))
+    const result = await forcePwaRecovery()
+    expect(result).toBe(false)
+  })
+})
+
 describe('reconcileServiceWorkerOnStartup', () => {
   beforeEach(() => {
     sessionStorage.clear()
@@ -35,11 +79,68 @@ describe('reconcileServiceWorkerOnStartup', () => {
       configurable: true,
       value: {
         controller: {},
-        getRegistration: vi.fn().mockResolvedValue({ waiting: null }),
+        getRegistration: vi.fn().mockResolvedValue({
+          waiting: null,
+          installing: null,
+          update: vi.fn().mockResolvedValue(undefined),
+          addEventListener: vi.fn()
+        }),
         addEventListener: vi.fn()
       }
     })
 
     await expect(reconcileServiceWorkerOnStartup()).resolves.toBe(false)
   })
+
+  it('returns false when waiting worker activation never takes over', async () => {
+    vi.useFakeTimers()
+    const postMessage = vi.fn()
+    const addEventListener = vi.fn()
+    vi.stubEnv('DEV', false)
+
+    Object.defineProperty(navigator, 'serviceWorker', {
+      configurable: true,
+      value: {
+        controller: { scriptURL: '/sw.js?v=1' },
+        getRegistration: vi.fn().mockResolvedValue({
+          waiting: { postMessage },
+          installing: null,
+          update: vi.fn().mockResolvedValue(undefined),
+          addEventListener: vi.fn()
+        }),
+        addEventListener
+      }
+    })
+
+    const reconcilePromise = reconcileServiceWorkerOnStartup()
+    await vi.advanceTimersByTimeAsync(4_000)
+
+    await expect(reconcilePromise).resolves.toBe(false)
+    expect(postMessage).toHaveBeenCalledWith({ type: 'SKIP_WAITING' })
+    vi.useRealTimers()
+  })
+})
+
+describe('reconcileVersionOnStartup', () => {
+  beforeEach(() => {
+    sessionStorage.clear()
+    vi.unstubAllEnvs()
+    vi.restoreAllMocks()
+  })
+
+  it('returns noop in dev mode', async () => {
+    vi.stubEnv('DEV', true)
+    await expect(reconcileVersionOnStartup()).resolves.toBe('noop')
+  })
+
+  it('returns noop when deployed version matches bundled version', async () => {
+    vi.stubEnv('DEV', false)
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ version: '0.1.0.57' })
+    }))
+    vi.stubGlobal('__APP_VERSION__', '0.1.0.57')
+
+    await expect(reconcileVersionOnStartup()).resolves.toBe('noop')
+  })
 })

client/src/services/pwaStartup.ts

@@ -1,7 +1,14 @@
+import { isNewerAppVersion, fetchDeployedVersion, getAppVersion } from './pwaVersion.js'
+
 const RELOAD_ATTEMPT_KEY = 'pwa_reload_attempt_ts'
 const COLD_START_UPDATE_KEY = 'pwa_coldstart_update_ts'
+const HARD_RECOVERY_KEY = 'pwa_hard_recovery_ts'
+const STALE_RECOVERY_COUNT_KEY = 'pwa_stale_recovery_count'
+const STALE_RECOVERY_LAST_KEY = 'pwa_stale_recovery_last_ts'
+const STALE_RECOVERY_WINDOW_MS = 60_000
 const RELOAD_DEBOUNCE_MS = 4_000
 const COLD_START_UPDATE_DEBOUNCE_MS = 15_000
+const HARD_RECOVERY_DEBOUNCE_MS = 30_000
 
 export function recentlyAttemptedReload(now = Date.now()): boolean {
   const last = Number(sessionStorage.getItem(RELOAD_ATTEMPT_KEY) || '0')
@@ -21,6 +28,34 @@ function markColdStartUpdateAttempt(now = Date.now()): void {
   sessionStorage.setItem(COLD_START_UPDATE_KEY, String(now))
 }
 
+function recentlyAttemptedHardRecovery(now = Date.now()): boolean {
+  const last = Number(sessionStorage.getItem(HARD_RECOVERY_KEY) || '0')
+  return now - last < HARD_RECOVERY_DEBOUNCE_MS
+}
+
+function markHardRecoveryAttempt(now = Date.now()): void {
+  sessionStorage.setItem(HARD_RECOVERY_KEY, String(now))
+}
+
+function resetStaleRecoveryCount(): void {
+  sessionStorage.removeItem(STALE_RECOVERY_COUNT_KEY)
+  sessionStorage.removeItem(STALE_RECOVERY_LAST_KEY)
+}
+
+function incrementStaleRecoveryCount(now = Date.now()): number {
+  const last = Number(sessionStorage.getItem(STALE_RECOVERY_LAST_KEY) || '0')
+  let current = Number(sessionStorage.getItem(STALE_RECOVERY_COUNT_KEY) || '0')
+
+  if (now - last > STALE_RECOVERY_WINDOW_MS) {
+    current = 0
+  }
+
+  const next = current + 1
+  sessionStorage.setItem(STALE_RECOVERY_COUNT_KEY, String(next))
+  sessionStorage.setItem(STALE_RECOVERY_LAST_KEY, String(now))
+  return next
+}
+
 function isStaleModuleLoadError(error: unknown): boolean {
   const message =
     error instanceof Error
@@ -32,10 +67,120 @@ function isStaleModuleLoadError(error: unknown): boolean {
   return (
     message.includes('Failed to fetch dynamically imported module') ||
     message.includes('Importing a module script failed') ||
-    message.includes('error loading dynamically imported module')
+    message.includes('error loading dynamically imported module') ||
+    message.includes('Loading chunk') ||
+    message.includes('ChunkLoadError') ||
+    message.includes('Unable to preload CSS')
   )
 }
 
+export async function clearPwaCachesAndWorkers(): Promise<void> {
+  if ('serviceWorker' in navigator) {
+    const registrations = await navigator.serviceWorker.getRegistrations()
+    await Promise.all(registrations.map((registration) => registration.unregister()))
+  }
+
+  if ('caches' in window) {
+    const keys = await caches.keys()
+    await Promise.all(keys.map((key) => caches.delete(key)))
+  }
+}
+
+/**
+ * Last-resort recovery when soft reloads cannot escape a stale precache.
+ * Equivalent to manually clearing site data / reinstalling the PWA.
+ */
+export async function forcePwaRecovery(): Promise<boolean> {
+  if (recentlyAttemptedHardRecovery()) return false
+
+  markHardRecoveryAttempt()
+  markReloadAttempt()
+  resetStaleRecoveryCount()
+  await clearPwaCachesAndWorkers()
+  window.location.reload()
+  return true
+}
+
+async function waitForWaitingWorker(
+  registration: ServiceWorkerRegistration,
+  timeoutMs: number
+): Promise<ServiceWorker | null> {
+  if (registration.waiting) {
+    return registration.waiting
+  }
+
+  return new Promise((resolve) => {
+    const timeoutId = window.setTimeout(() => resolve(null), timeoutMs)
+
+    const inspectWorker = (worker: ServiceWorker | null) => {
+      if (!worker) return
+
+      if (worker.state === 'installed' && navigator.serviceWorker.controller) {
+        window.clearTimeout(timeoutId)
+        resolve(worker)
+        return
+      }
+
+      worker.addEventListener(
+        'statechange',
+        () => {
+          if (worker.state === 'installed' && navigator.serviceWorker.controller) {
+            window.clearTimeout(timeoutId)
+            resolve(worker)
+          }
+        },
+        { once: true }
+      )
+    }
+
+    inspectWorker(registration.installing)
+
+    registration.addEventListener(
+      'updatefound',
+      () => {
+        inspectWorker(registration.installing)
+      },
+      { once: true }
+    )
+  })
+}
+
+export async function triggerServiceWorkerUpdate(timeoutMs = 5_000): Promise<boolean> {
+  if (import.meta.env.DEV || !('serviceWorker' in navigator)) {
+    return false
+  }
+
+  const registration = await navigator.serviceWorker.getRegistration()
+  if (!registration) return false
+
+  try {
+    await registration.update()
+  } catch {
+    return false
+  }
+
+  const waiting = await waitForWaitingWorker(registration, timeoutMs)
+  return waiting !== null
+}
+
+async function activateWaitingWorker(waiting: ServiceWorker): Promise<boolean> {
+  const currentController = navigator.serviceWorker.controller?.scriptURL ?? null
+  waiting.postMessage({ type: 'SKIP_WAITING' })
+
+  return new Promise<boolean>((resolve) => {
+    const timeoutId = window.setTimeout(() => resolve(false), 4_000)
+    navigator.serviceWorker.addEventListener(
+      'controllerchange',
+      () => {
+        window.clearTimeout(timeoutId)
+        const nextController = navigator.serviceWorker.controller?.scriptURL ?? null
+        resolve(nextController !== null && nextController !== currentController)
+      },
+      { once: true }
+    )
+  })
+}
+
 /**
  * After missed deploys, a waiting SW may exist while the page still runs an old bundle.
  * Apply the waiting worker once on cold start (one controlled reload) instead of hanging.
@@ -50,38 +195,95 @@ export async function reconcileServiceWorkerOnStartup(): Promise<boolean> {
   }
 
   const registration = await navigator.serviceWorker.getRegistration()
-  const waiting = registration?.waiting
+  let waiting = registration?.waiting ?? null
+
+  if (!waiting && registration) {
+    await registration.update().catch(() => {})
+    waiting = await waitForWaitingWorker(registration, 4_000)
+  }
+
   if (!waiting || !navigator.serviceWorker.controller) {
     return false
   }
 
-  markColdStartUpdateAttempt()
-  waiting.postMessage({ type: 'SKIP_WAITING' })
+  const activated = await activateWaitingWorker(waiting)
+  if (activated) {
+    markColdStartUpdateAttempt()
+  }
+  return activated
+}
 
-  await new Promise<void>((resolve) => {
-    const timeoutId = window.setTimeout(resolve, 4_000)
-    navigator.serviceWorker.addEventListener(
-      'controllerchange',
-      () => {
-        window.clearTimeout(timeoutId)
-        resolve()
-      },
-      { once: true }
-    )
-  })
+/**
+ * Compare deployed version.json with the bundled app version.
+ * When the server is ahead, try a soft SW takeover before hard recovery.
+ */
+export async function reconcileVersionOnStartup(): Promise<'reload' | 'recovered' | 'noop'> {
+  if (import.meta.env.DEV || !navigator.onLine) {
+    return 'noop'
+  }
 
-  return true
+  const deployedVersion = await fetchDeployedVersion()
+  if (!deployedVersion || !isNewerAppVersion(deployedVersion, getAppVersion())) {
+    return 'noop'
+  }
+
+  const reconciled = await reconcileServiceWorkerOnStartup()
+  if (reconciled) {
+    return 'reload'
+  }
+
+  const updated = await triggerServiceWorkerUpdate()
+  if (updated) {
+    const registration = await navigator.serviceWorker.getRegistration()
+    const waiting = registration?.waiting
+    if (waiting) {
+      const activated = await activateWaitingWorker(waiting)
+      if (activated) {
+        markColdStartUpdateAttempt()
+        return 'reload'
+      }
+    }
+  }
+
+  if (!recentlyAttemptedHardRecovery()) {
+    const recovered = await forcePwaRecovery()
+    if (recovered) {
+      return 'recovered'
+    }
+  }
+
+  return 'noop'
 }
 
 export function installStaleAssetRecovery(): void {
   if (import.meta.env.DEV) return
 
-  window.addEventListener('unhandledrejection', (event) => {
-    if (!isStaleModuleLoadError(event.reason)) return
+  const recoverFromStaleAssets = () => {
     if (recentlyAttemptedReload()) return
 
+    const attempts = incrementStaleRecoveryCount()
     markReloadAttempt()
-    event.preventDefault()
+
+    if (attempts >= 2) {
+      void forcePwaRecovery()
+      return
+    }
+
     window.location.reload()
+  }
+
+  window.addEventListener('unhandledrejection', (event) => {
+    if (!isStaleModuleLoadError(event.reason)) return
+    event.preventDefault()
+    recoverFromStaleAssets()
   })
+
+  window.addEventListener(
+    'error',
+    (event) => {
+      if (!isStaleModuleLoadError(event.message)) return
+      recoverFromStaleAssets()
+    },
+    true
+  )
 }

client/src/services/pwaVersion.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+import {
+  compareAppVersions,
+  isNewerAppVersion,
+  parseAppVersion
+} from './pwaVersion.js'
+
+describe('pwaVersion', () => {
+  it('parses semantic build versions', () => {
+    expect(parseAppVersion('v0.1.0.57')).toEqual([0, 1, 0, 57])
+  })
+
+  it('compares build numbers numerically', () => {
+    expect(compareAppVersions('0.1.0.65', '0.1.0.57')).toBeGreaterThan(0)
+    expect(compareAppVersions('0.1.0.57', '0.1.0.65')).toBeLessThan(0)
+    expect(compareAppVersions('0.1.0.57', '0.1.0.57')).toBe(0)
+  })
+
+  it('detects newer deployed versions', () => {
+    expect(isNewerAppVersion('0.1.0.66', '0.1.0.57')).toBe(true)
+    expect(isNewerAppVersion('0.1.0.57', '0.1.0.57')).toBe(false)
+  })
+})

client/src/services/pwaVersion.ts

@@ -0,0 +1,59 @@
+const APP_VERSION =
+  typeof __APP_VERSION__ !== 'undefined' ? __APP_VERSION__ : '0.0.0.0-dev'
+
+export function getAppVersion(): string {
+  return APP_VERSION
+}
+
+export function parseAppVersion(version: string): number[] {
+  return version
+    .replace(/^v/i, '')
+    .split('.')
+    .map((part) => Number.parseInt(part, 10) || 0)
+}
+
+/** Positive when `a` is newer than `b`. */
+export function compareAppVersions(a: string, b: string): number {
+  const partsA = parseAppVersion(a)
+  const partsB = parseAppVersion(b)
+  const length = Math.max(partsA.length, partsB.length)
+
+  for (let index = 0; index < length; index += 1) {
+    const diff = (partsA[index] ?? 0) - (partsB[index] ?? 0)
+    if (diff !== 0) return diff
+  }
+
+  return 0
+}
+
+export function isNewerAppVersion(serverVersion: string, clientVersion: string): boolean {
+  return compareAppVersions(serverVersion, clientVersion) > 0
+}
+
+export async function fetchDeployedVersion(timeoutMs = 4_000): Promise<string | null> {
+  if (!navigator.onLine) return null
+
+  const controller = new AbortController()
+  const timeoutId = window.setTimeout(() => controller.abort(), timeoutMs)
+
+  try {
+    const response = await fetch(`/version.json?_=${Date.now()}`, {
+      cache: 'no-store',
+      signal: controller.signal
+    })
+    if (!response.ok) return null
+
+    const payload = (await response.json()) as { version?: unknown }
+    return typeof payload.version === 'string' ? payload.version.trim() : null
+  } catch {
+    return null
+  } finally {
+    window.clearTimeout(timeoutId)
+  }
+}
+
+export async function isDeployedVersionNewer(): Promise<boolean> {
+  const deployedVersion = await fetchDeployedVersion()
+  if (!deployedVersion) return false
+  return isNewerAppVersion(deployedVersion, getAppVersion())
+}

client/src/sw.ts

@@ -1,13 +1,32 @@
 /// <reference lib="webworker" />
 import { clientsClaim } from 'workbox-core'
-import { cleanupOutdatedCaches, precacheAndRoute } from 'workbox-precaching'
+import { cleanupOutdatedCaches, createHandlerBoundToURL, precacheAndRoute } from 'workbox-precaching'
+import { registerRoute } from 'workbox-routing'
+import { NetworkFirst, NetworkOnly } from 'workbox-strategies'
 
 declare let self: ServiceWorkerGlobalScope
 
+const appShellFallback = createHandlerBoundToURL('/index.html')
+const navigationStrategy = new NetworkFirst({
+  cacheName: 'app-shell',
+  networkTimeoutSeconds: 3
+})
+
+registerRoute(({ request }) => request.mode === 'navigate', async (context) => {
+  try {
+    return await navigationStrategy.handle(context)
+  } catch {
+    return appShellFallback(context)
+  }
+})
+
 precacheAndRoute(self.__WB_MANIFEST)
 cleanupOutdatedCaches()
 clientsClaim()
 
+// Always fetch the live deploy version, even under an older precache.
+registerRoute(({ url }) => url.pathname === '/version.json', new NetworkOnly())
+
 self.addEventListener('message', (event) => {
   if (event.data?.type === 'SKIP_WAITING') {
     void self.skipWaiting()

client/vite.config.ts

@@ -2,9 +2,10 @@
 import { defineConfig } from 'vite'
 import react from '@vitejs/plugin-react'
 import { VitePWA } from 'vite-plugin-pwa'
-import { readFileSync } from 'node:fs'
+import { readFileSync, writeFileSync } from 'node:fs'
 import { resolve, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import type { Plugin } from 'vite'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 
@@ -19,6 +20,19 @@ function readAppVersion(): string {
   }
 }
 
+function versionJsonPlugin(version: string): Plugin {
+  return {
+    name: 'version-json',
+    writeBundle(options) {
+      const outDir = options.dir ?? resolve(__dirname, 'dist')
+      writeFileSync(
+        resolve(outDir, 'version.json'),
+        `${JSON.stringify({ version }, null, 2)}\n`
+      )
+    }
+  }
+}
+
 // https://vite.dev/config/
 export default defineConfig({
   test: {
@@ -42,6 +56,7 @@ export default defineConfig({
   },
   plugins: [
     react(),
+    versionJsonPlugin(readAppVersion()),
     VitePWA({
       strategies: 'injectManifest',
       srcDir: 'src',