Support multi-leg (layover) flights (#1146)

* feat(transport): support multi-leg (layover) flights in the booking form

A flight booking can now hold an ordered chain of airports (e.g. FRA -> BER ->
HND) instead of a single departure/arrival pair. The route is entered as a list
of waypoints with a '+ add stop' button; each stop carries its own arrival and
departure time plus the airline/flight number of the segment leaving it, while
the whole booking keeps one price.

Stored without a schema change: the existing reservation_endpoints rows carry the
ordered waypoints (from/stop/to by sequence) and a metadata.legs array holds the
per-leg detail. Top-level metadata (departure_airport/arrival_airport/airline/
flight_number) mirrors the first and last leg, so a single-leg flight persists
exactly as before and legacy readers keep working.

* feat(planner): show each flight leg as its own day-plan entry, ordered by time

A multi-leg flight now expands into one entry per leg (BER -> FRA, then FRA ->
HND), each on its own day with its own times, instead of a single span. Each leg
is an addressable slot (reservation id + leg index) so places and notes can be
dropped into the layover gap between legs; the per-leg position is persisted in
metadata.legs[i].day_positions and survives a reload.

Day-plan items are now ordered chronologically: anything with a time (a place's
time, a flight leg, a timed note) sorts by that time, and untimed items inherit
the time of the item before them so they stay where they were placed.

* feat(planner): show the full multi-stop route in the bookings panel

The route row now lists every waypoint (FRA -> BER -> HND) by sequence instead of
just the first and last airport.

* feat(map): draw multi-leg flights as connected legs with a marker per airport

Both the Leaflet and Mapbox overlays now render a flight over all its waypoints:
one great-circle arc per leg and a marker at every airport, with the label
showing the full route and the summed distance. A single-leg flight is unchanged.

Also drops the floating stats badge that was drawn on transport arcs.

* fix(map): centre a clicked place above the bottom inspector panel

Selecting a place panned/flew it to the dead centre of the screen, where it sat
behind the detail card. Both overlays now bias the target into the visible area
above the bottom panel (Leaflet offsets the pan by the inspector inset; Mapbox
passes the padding to flyTo).

* feat: show the full multi-stop flight route in PDF and calendar export

The PDF day list and the ICS export now render the whole route (FRA → BER → HND)
for a multi-leg flight instead of just the first and last airport, falling back to
the flat metadata for single-leg flights. The ICS keeps a single event per booking.

* feat(import): group connecting flight legs into one multi-leg booking

When a booking confirmation contains several flight legs sharing a PNR that
connect at the same airport with a short layover (under 24h), they are now
imported as a single multi-leg booking (from/stop/to endpoints + metadata.legs)
instead of one booking per leg. A round trip (same PNR, multi-day gap) stays two
separate bookings, and a single flight is unchanged.

* i18n: translate the new flight-route strings into all languages

* i18n: translate the Costs page into every language

The Budget → Costs rework left the new costs.* strings untranslated in every
non-English locale (they fell back to English). Translate them across all
supported languages.

* Revert "fix(map): centre a clicked place above the bottom inspector panel"

This reverts commit 0936103f04.

client/src/utils/dayMerge.test.ts

@@ -126,18 +126,18 @@ describe('getMergedItems', () => {
     expect(types).toEqual(['place', 'transport', 'place'])
   })
 
-  it('per-day position overrides time-based insertion', () => {
+  it('orders a timed transport chronologically regardless of a stale per-day position', () => {
     const dayAssignments = [
       { id: 1, order_index: 0, place: { place_time: '08:00' } },
       { id: 2, order_index: 1, place: { place_time: '13:00' } },
     ]
-    // Transport at 10:30 would normally go between the two places
-    // but per-day position 1.5 puts it after the second place
+    // The train is at 10:30, so it sorts between the 08:00 and 13:00 places by time —
+    // timed items are arranged chronologically even if an old manual position exists.
     const dayTransports = [
       { id: 20, type: 'train', day_id: 5, end_day_id: 5, reservation_time: '10:30', day_positions: { 5: 1.5 } },
     ]
     const result = getMergedItems({ dayAssignments, dayNotes: [], dayTransports, dayId: 5 })
     const types = result.map(i => i.type)
-    expect(types).toEqual(['place', 'place', 'transport'])
+    expect(types).toEqual(['place', 'transport', 'place'])
   })
 })

client/src/utils/dayMerge.ts

@@ -39,12 +39,66 @@ export function getDisplayTimeForDay(
   return r.reservation_time || null
 }
 
+/** Per-leg detail of a multi-leg flight, or null for single-leg / non-flight. */
+function parseFlightLegs(r: any): any[] | null {
+  if (r?.type !== 'flight') return null
+  let meta = r.metadata
+  if (typeof meta === 'string') { try { meta = JSON.parse(meta || '{}') } catch { meta = {} } }
+  // Defensive: recover metadata that was accidentally double-encoded by an earlier
+  // bug (a JSON string of a JSON string) so already-saved flights heal on read.
+  if (typeof meta === 'string') { try { meta = JSON.parse(meta || '{}') } catch { meta = {} } }
+  if (meta && Array.isArray(meta.legs) && meta.legs.length > 1) return meta.legs
+  return null
+}
+
+/**
+ * Expand a multi-leg flight into one synthetic reservation per leg that touches
+ * `dayId`, each with its own day span + departure/arrival time so it slots into
+ * the timeline independently. A single-leg flight (or any other reservation) is
+ * returned untouched, so existing behaviour is unchanged.
+ */
+export function expandFlightLegsForDay(
+  r: any,
+  dayId: number,
+  getDayOrder: (id: number) => number,
+  days: Array<{ id: number; date?: string | null }>
+): any[] {
+  const legs = parseFlightLegs(r)
+  if (!legs) return [r]
+  const dateOf = (id: number | null): string | null => (id == null ? null : (days.find(d => d.id === id)?.date ?? null))
+  const thisOrder = getDayOrder(dayId)
+  const out: any[] = []
+  legs.forEach((leg, i) => {
+    const dep = leg.dep_day_id ?? r.day_id ?? null
+    const arr = leg.arr_day_id ?? dep
+    if (dep == null) return
+    const depOrder = getDayOrder(dep)
+    const arrOrder = getDayOrder(arr ?? dep)
+    if (!(thisOrder >= depOrder && thisOrder <= arrOrder)) return
+    const depDate = dateOf(dep)
+    const arrDate = dateOf(arr ?? dep)
+    out.push({
+      ...r,
+      day_id: dep,
+      end_day_id: arr ?? dep,
+      reservation_time: leg.dep_time ? (depDate ? `${depDate}T${leg.dep_time}` : leg.dep_time) : null,
+      reservation_end_time: leg.arr_time ? (arrDate ? `${arrDate}T${leg.arr_time}` : leg.arr_time) : null,
+      // Each leg carries its OWN saved position (not the booking's) so items can be
+      // dropped between legs and persist; absent → falls back to time ordering.
+      day_positions: leg.day_positions || undefined,
+      day_plan_position: undefined,
+      __leg: { index: i, total: legs.length, from: leg.from ?? null, to: leg.to ?? null, airline: leg.airline ?? null, flight_number: leg.flight_number ?? null },
+    })
+  })
+  return out
+}
+
 /** Filter reservations that are active transports for the given day, excluding assignment-linked ones. */
 export function getTransportForDay(opts: {
   reservations: any[]
   dayId: number
   dayAssignmentIds: number[]
-  days: Array<{ id: number; day_number?: number }>
+  days: Array<{ id: number; day_number?: number; date?: string | null }>
 }): any[] {
   const { reservations, dayId, dayAssignmentIds, days } = opts
 
@@ -69,7 +123,34 @@ export function getTransportForDay(opts: {
       return thisDayOrder >= startOrder && thisDayOrder <= endOrder
     }
     return startDayId === dayId
-  })
+  }).flatMap(r => expandFlightLegsForDay(r, dayId, getDayOrder, days))
+}
+
+/**
+ * Order items chronologically: anything with a time (a place's place_time, a
+ * transport/leg display time, a timed note) sorts by that time. An item WITHOUT a
+ * time inherits the time of the timed item before it, so untimed items stay where
+ * they were manually placed. Stable on the incoming order for ties.
+ */
+function applyChronoOrder(
+  items: MergedItem[],
+  dayId: number,
+  getDisplayTime: (r: any, dayId: number) => string | null
+): MergedItem[] {
+  const timeOf = (it: MergedItem): number | null => {
+    if (it.type === 'place') return parseTimeToMinutes(it.data?.place?.place_time)
+    if (it.type === 'note') return parseTimeToMinutes(it.data?.time)
+    return parseTimeToMinutes(getDisplayTime(it.data, dayId))
+  }
+  let last = -Infinity
+  return items
+    .map((it, i) => {
+      const t = timeOf(it)
+      if (t != null) last = t
+      return { it, i, eff: t != null ? t : last }
+    })
+    .sort((a, b) => a.eff - b.eff || a.i - b.i)
+    .map(k => k.it)
 }
 
 /** Merge places, notes, and transports into a single ordered day timeline. */
@@ -94,9 +175,9 @@ export function getMergedItems(opts: {
     minutes: parseTimeToMinutes(getDisplayTime(r, dayId)) ?? 0,
   })).sort((a, b) => a.minutes - b.minutes)
 
-  if (timedTransports.length === 0) return baseItems
+  if (timedTransports.length === 0) return applyChronoOrder(baseItems, dayId, getDisplayTime)
   if (baseItems.length === 0) {
-    return timedTransports.map((item, i) => ({ type: item.type, sortKey: i, data: item.data }))
+    return applyChronoOrder(timedTransports.map((item, i) => ({ type: item.type, sortKey: i, data: item.data })), dayId, getDisplayTime)
   }
 
   // Insert transports among base items based on per-day position or time
@@ -132,5 +213,5 @@ export function getMergedItems(opts: {
     result.push({ type: timed.type, sortKey, data: timed.data })
   }
 
-  return result.sort((a, b) => a.sortKey - b.sortKey)
+  return applyChronoOrder(result.sort((a, b) => a.sortKey - b.sortKey), dayId, getDisplayTime)
 }

client/src/utils/flightLegs.ts

@@ -0,0 +1,105 @@
+// Multi-leg (layover) flight support.
+//
+// A flight booking is ONE reservation whose route is an ordered chain of airports
+// (e.g. FRA -> BER -> HND). The geometry + order are the source of truth in
+// `reservation.endpoints` (role 'from' for the first airport, 'stop' for each
+// intermediate one, 'to' for the last, ordered by `sequence`). The per-leg detail
+// — airline, flight number, and each segment's own day/time — lives in
+// `metadata.legs`. The top-level metadata (`departure_airport`/`arrival_airport`/
+// `airline`/`flight_number`) and `day_id`/`end_day_id` mirror the FIRST and LAST
+// leg so legacy readers keep working.
+//
+// A legacy single-leg flight (two endpoints, flat metadata, no `metadata.legs`)
+// is normalised here into a one-leg chain, so every renderer can use one path.
+
+import type { Reservation, ReservationEndpoint } from '../types'
+
+export interface FlightLeg {
+  from: string | null // IATA code (or null)
+  to: string | null
+  airline?: string
+  flight_number?: string
+  dep_day_id?: number | null
+  dep_time?: string | null // 'HH:mm'
+  arr_day_id?: number | null
+  arr_time?: string | null
+}
+
+/** reservation.metadata may be a JSON string or an already-parsed object. */
+export function parseReservationMetadata(r: Pick<Reservation, 'metadata'>): Record<string, any> {
+  const m = r.metadata
+  if (!m) return {}
+  if (typeof m === 'string') {
+    try {
+      let parsed = JSON.parse(m || '{}')
+      // Defensive: an earlier bug could double-encode metadata (a JSON string of a
+      // JSON string) — unwrap it once more so saved flights heal on read.
+      if (typeof parsed === 'string') { try { parsed = JSON.parse(parsed) } catch { /* keep */ } }
+      return (parsed && typeof parsed === 'object') ? parsed : {}
+    } catch { return {} }
+  }
+  return m as Record<string, any>
+}
+
+/** Endpoints ordered by `sequence` (geometry + order source of truth). */
+export function orderedEndpoints(r: Pick<Reservation, 'endpoints'>): ReservationEndpoint[] {
+  return (r.endpoints || []).slice().sort((a, b) => (a.sequence ?? 0) - (b.sequence ?? 0))
+}
+
+/**
+ * Ordered legs of a flight. `metadata.legs` is preferred; otherwise a single leg
+ * is derived from the endpoints (and finally the flat metadata) so that legacy
+ * single-leg flights — and flights created before this feature — still work.
+ */
+export function getFlightLegs(r: Reservation): FlightLeg[] {
+  const meta = parseReservationMetadata(r)
+  if (Array.isArray(meta.legs) && meta.legs.length > 0) {
+    return meta.legs.map((l: any): FlightLeg => ({
+      from: l.from ?? null,
+      to: l.to ?? null,
+      airline: l.airline || undefined,
+      flight_number: l.flight_number || undefined,
+      dep_day_id: l.dep_day_id ?? null,
+      dep_time: l.dep_time ?? null,
+      arr_day_id: l.arr_day_id ?? null,
+      arr_time: l.arr_time ?? null,
+    }))
+  }
+  // Legacy fallback: one leg from the endpoints / flat metadata.
+  const eps = orderedEndpoints(r)
+  const first = eps[0]
+  const last = eps[eps.length - 1]
+  const fromCode = first?.code ?? meta.departure_airport ?? null
+  const toCode = last?.code ?? meta.arrival_airport ?? null
+  if (!fromCode && !toCode) return []
+  return [{
+    from: fromCode,
+    to: toCode,
+    airline: meta.airline || undefined,
+    flight_number: meta.flight_number || undefined,
+    dep_day_id: r.day_id ?? null,
+    dep_time: first?.local_time ?? null,
+    arr_day_id: r.end_day_id ?? r.day_id ?? null,
+    arr_time: last?.local_time ?? null,
+  }]
+}
+
+/** Number of flight segments. 1 for a simple from -> to booking. */
+export function legCount(r: Reservation): number {
+  return getFlightLegs(r).length
+}
+
+export function isMultiLegFlight(r: Reservation): boolean {
+  return r.type === 'flight' && legCount(r) > 1
+}
+
+/**
+ * Ordered route labels (IATA codes, or names when no code) for display, e.g.
+ * ['FRA','BER','HND']. Uses endpoints; falls back to the flat metadata pair.
+ */
+export function routeStops(r: Reservation): string[] {
+  const eps = orderedEndpoints(r)
+  if (eps.length >= 2) return eps.map(e => e.code || e.name)
+  const meta = parseReservationMetadata(r)
+  return [meta.departure_airport, meta.arrival_airport].filter(Boolean) as string[]
+}