feat(pwa): implement real offline mode with IndexedDB sync

Add genuine offline read/write capability for trips:

- Dexie IndexedDB schema (trips, places, packing, todo, budget,
  reservations, files, mutationQueue, syncMeta, blobCache)
- Repo layer for all domains: offline reads from Dexie, writes
  optimistically to Dexie and enqueue mutations for later replay
- Mutation queue with UUID idempotency keys (X-Idempotency-Key),
  FIFO flush, temp-ID reconciliation on 2xx, fail-and-continue on 4xx
- Trip sync manager: caches all trips with end_date >= today or null,
  auto-evicts 7d after end_date, fetches bundle endpoint in one request
- Map tile prefetcher: bbox from place coords, zooms 10-16, 50MB cap,
  warms SW cache via fetch
- Sync triggers: network online → flush + syncAll; WS reconnect →
  flush only (rate-limiter safe); visibilitychange/30s → flush only
- WS remoteEventHandler writes through to Dexie on every event
- Server idempotency middleware + idempotency_keys table (migration 100,
  24h TTL nightly cleanup)
- GET /api/trips/:id/bundle endpoint for efficient single-request sync
- OfflineBanner component: amber (offline) / blue (syncing) / hidden
- OfflineTab in Settings: cached trip list, re-sync and clear actions
- usePendingMutations hook for per-item pending indicators

Closes #505 #541

client/src/repo/budgetRepo.ts

@@ -0,0 +1,18 @@
+import { budgetApi } from '../api/client'
+import { offlineDb, upsertBudgetItems } from '../db/offlineDb'
+import type { BudgetItem } from '../types'
+
+export const budgetRepo = {
+  async list(tripId: number | string): Promise<{ items: BudgetItem[] }> {
+    if (!navigator.onLine) {
+      const cached = await offlineDb.budgetItems
+        .where('trip_id')
+        .equals(Number(tripId))
+        .toArray()
+      return { items: cached }
+    }
+    const result = await budgetApi.list(tripId)
+    upsertBudgetItems(result.items)
+    return result
+  },
+}

client/src/repo/dayRepo.ts

@@ -0,0 +1,18 @@
+import { daysApi } from '../api/client'
+import { offlineDb, upsertDays } from '../db/offlineDb'
+import type { Day } from '../types'
+
+export const dayRepo = {
+  async list(tripId: number | string): Promise<{ days: Day[] }> {
+    if (!navigator.onLine) {
+      const cached = await offlineDb.days
+        .where('trip_id')
+        .equals(Number(tripId))
+        .sortBy('day_number' as keyof Day)
+      return { days: cached as Day[] }
+    }
+    const result = await daysApi.list(tripId)
+    upsertDays(result.days)
+    return result
+  },
+}

client/src/repo/fileRepo.ts

@@ -0,0 +1,18 @@
+import { filesApi } from '../api/client'
+import { offlineDb, upsertTripFiles } from '../db/offlineDb'
+import type { TripFile } from '../types'
+
+export const fileRepo = {
+  async list(tripId: number | string): Promise<{ files: TripFile[] }> {
+    if (!navigator.onLine) {
+      const cached = await offlineDb.tripFiles
+        .where('trip_id')
+        .equals(Number(tripId))
+        .toArray()
+      return { files: cached }
+    }
+    const result = await filesApi.list(tripId)
+    upsertTripFiles(result.files)
+    return result
+  },
+}

client/src/repo/packingRepo.ts

@@ -0,0 +1,88 @@
+import { packingApi } from '../api/client'
+import { offlineDb, upsertPackingItems } from '../db/offlineDb'
+import { mutationQueue, generateUUID } from '../sync/mutationQueue'
+import type { PackingItem } from '../types'
+
+export const packingRepo = {
+  async list(tripId: number | string): Promise<{ items: PackingItem[] }> {
+    if (!navigator.onLine) {
+      const cached = await offlineDb.packingItems
+        .where('trip_id')
+        .equals(Number(tripId))
+        .toArray()
+      return { items: cached }
+    }
+    const result = await packingApi.list(tripId)
+    upsertPackingItems(result.items)
+    return result
+  },
+
+  async create(tripId: number | string, data: Record<string, unknown>): Promise<{ item: PackingItem }> {
+    if (!navigator.onLine) {
+      const tempId = -(Date.now())
+      const tempItem: PackingItem = {
+        ...(data as Partial<PackingItem>),
+        id: tempId,
+        trip_id: Number(tripId),
+        name: (data.name as string) ?? 'New item',
+        checked: 0,
+      } as PackingItem
+      await offlineDb.packingItems.put(tempItem)
+      const id = generateUUID()
+      await mutationQueue.enqueue({
+        id,
+        tripId: Number(tripId),
+        method: 'POST',
+        url: `/trips/${tripId}/packing`,
+        body: data,
+        resource: 'packingItems',
+        tempId,
+      })
+      return { item: tempItem }
+    }
+    const result = await packingApi.create(tripId, data)
+    offlineDb.packingItems.put(result.item)
+    return result
+  },
+
+  async update(tripId: number | string, id: number, data: Record<string, unknown>): Promise<{ item: PackingItem }> {
+    if (!navigator.onLine) {
+      const existing = await offlineDb.packingItems.get(id)
+      const optimistic: PackingItem = { ...(existing ?? {} as PackingItem), ...(data as Partial<PackingItem>), id }
+      await offlineDb.packingItems.put(optimistic)
+      const mutId = generateUUID()
+      await mutationQueue.enqueue({
+        id: mutId,
+        tripId: Number(tripId),
+        method: 'PUT',
+        url: `/trips/${tripId}/packing/${id}`,
+        body: data,
+        resource: 'packingItems',
+      })
+      return { item: optimistic }
+    }
+    const result = await packingApi.update(tripId, id, data)
+    offlineDb.packingItems.put(result.item)
+    return result
+  },
+
+  async delete(tripId: number | string, id: number): Promise<unknown> {
+    if (!navigator.onLine) {
+      await offlineDb.packingItems.delete(id)
+      const mutId = generateUUID()
+      await mutationQueue.enqueue({
+        id: mutId,
+        tripId: Number(tripId),
+        method: 'DELETE',
+        url: `/trips/${tripId}/packing/${id}`,
+        body: undefined,
+        resource: 'packingItems',
+        entityId: id,
+      })
+      return { success: true }
+    }
+    const result = await packingApi.delete(tripId, id)
+    offlineDb.packingItems.delete(id)
+    return result
+  },
+}

client/src/repo/placeRepo.ts

@@ -0,0 +1,87 @@
+import { placesApi } from '../api/client'
+import { offlineDb, upsertPlaces } from '../db/offlineDb'
+import { mutationQueue, generateUUID } from '../sync/mutationQueue'
+import type { Place } from '../types'
+
+export const placeRepo = {
+  async list(tripId: number | string, params?: Record<string, unknown>): Promise<{ places: Place[] }> {
+    if (!navigator.onLine) {
+      const cached = await offlineDb.places
+        .where('trip_id')
+        .equals(Number(tripId))
+        .toArray()
+      return { places: cached }
+    }
+    const result = await placesApi.list(tripId, params)
+    upsertPlaces(result.places)
+    return result
+  },
+
+  async create(tripId: number | string, data: Record<string, unknown>): Promise<{ place: Place }> {
+    if (!navigator.onLine) {
+      const tempId = -(Date.now())
+      const tempPlace: Place = {
+        ...(data as Partial<Place>),
+        id: tempId,
+        trip_id: Number(tripId),
+        name: (data.name as string) ?? 'New place',
+      } as Place
+      await offlineDb.places.put(tempPlace)
+      const id = generateUUID()
+      await mutationQueue.enqueue({
+        id,
+        tripId: Number(tripId),
+        method: 'POST',
+        url: `/trips/${tripId}/places`,
+        body: data,
+        resource: 'places',
+        tempId,
+      })
+      return { place: tempPlace }
+    }
+    const result = await placesApi.create(tripId, data)
+    offlineDb.places.put(result.place)
+    return result
+  },
+
+  async update(tripId: number | string, id: number | string, data: Record<string, unknown>): Promise<{ place: Place }> {
+    if (!navigator.onLine) {
+      const existing = await offlineDb.places.get(Number(id))
+      const optimistic: Place = { ...(existing ?? {} as Place), ...(data as Partial<Place>), id: Number(id) }
+      await offlineDb.places.put(optimistic)
+      const mutId = generateUUID()
+      await mutationQueue.enqueue({
+        id: mutId,
+        tripId: Number(tripId),
+        method: 'PUT',
+        url: `/trips/${tripId}/places/${id}`,
+        body: data,
+        resource: 'places',
+      })
+      return { place: optimistic }
+    }
+    const result = await placesApi.update(tripId, id, data)
+    offlineDb.places.put(result.place)
+    return result
+  },
+
+  async delete(tripId: number | string, id: number | string): Promise<unknown> {
+    if (!navigator.onLine) {
+      await offlineDb.places.delete(Number(id))
+      const mutId = generateUUID()
+      await mutationQueue.enqueue({
+        id: mutId,
+        tripId: Number(tripId),
+        method: 'DELETE',
+        url: `/trips/${tripId}/places/${id}`,
+        body: undefined,
+        resource: 'places',
+        entityId: Number(id),
+      })
+      return { success: true }
+    }
+    const result = await placesApi.delete(tripId, id)
+    offlineDb.places.delete(Number(id))
+    return result
+  },
+}

client/src/repo/reservationRepo.ts

@@ -0,0 +1,18 @@
+import { reservationsApi } from '../api/client'
+import { offlineDb, upsertReservations } from '../db/offlineDb'
+import type { Reservation } from '../types'
+
+export const reservationRepo = {
+  async list(tripId: number | string): Promise<{ reservations: Reservation[] }> {
+    if (!navigator.onLine) {
+      const cached = await offlineDb.reservations
+        .where('trip_id')
+        .equals(Number(tripId))
+        .toArray()
+      return { reservations: cached }
+    }
+    const result = await reservationsApi.list(tripId)
+    upsertReservations(result.reservations)
+    return result
+  },
+}

client/src/repo/todoRepo.ts

@@ -0,0 +1,18 @@
+import { todoApi } from '../api/client'
+import { offlineDb, upsertTodoItems } from '../db/offlineDb'
+import type { TodoItem } from '../types'
+
+export const todoRepo = {
+  async list(tripId: number | string): Promise<{ items: TodoItem[] }> {
+    if (!navigator.onLine) {
+      const cached = await offlineDb.todoItems
+        .where('trip_id')
+        .equals(Number(tripId))
+        .toArray()
+      return { items: cached }
+    }
+    const result = await todoApi.list(tripId)
+    upsertTodoItems(result.items)
+    return result
+  },
+}

client/src/repo/tripRepo.ts

@@ -0,0 +1,16 @@
+import { tripsApi } from '../api/client'
+import { offlineDb, upsertTrip } from '../db/offlineDb'
+import type { Trip } from '../types'
+
+export const tripRepo = {
+  async get(tripId: number | string): Promise<{ trip: Trip }> {
+    if (!navigator.onLine) {
+      const cached = await offlineDb.trips.get(Number(tripId))
+      if (cached) return { trip: cached }
+      throw new Error('No cached trip data available offline')
+    }
+    const result = await tripsApi.get(tripId)
+    upsertTrip(result.trip)
+    return result
+  },
+}