From 0947b29a2e633aec6442b7b963959577dee1031f Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 19 Oct 2026 19:01:15 +0000
Subject: [PATCH 1/7] perf(dashboard): load the history dialogs, and Chart.js
 with them, on first tap

CarDiagram imported the tyre and level history dialogs directly, which put
Chart.js (about 190 KB, 67 KB gzipped) on every dashboard visit. Each dialog
is now fetched when it is first opened, mounted closed and opened on the next
tick so its fade-in and its fetch still start from the change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L6DtW2eHhipteRopmy3cif
---
 frontend/src/components/CarDiagram.vue        | 34 +++++--
 .../components/__tests__/CarDiagram.spec.ts   | 95 +++++++++++++++++++
 2 files changed, 122 insertions(+), 7 deletions(-)
 create mode 100644 frontend/src/components/__tests__/CarDiagram.spec.ts

diff --git a/frontend/src/components/CarDiagram.vue b/frontend/src/components/CarDiagram.vue
index 9eb4c5d6..f86eda2f 100644
--- a/frontend/src/components/CarDiagram.vue
+++ b/frontend/src/components/CarDiagram.vue
@@ -1,15 +1,13 @@
 <script setup lang="ts">
 import '@/assets/carDiagram.css'
 import { useI18n } from 'vue-i18n'
-import { computed, ref } from 'vue'
+import { computed, nextTick, ref, shallowRef } from 'vue'
 import CardInfoWrap from './CardInfoWrap.vue'
 import CarLightBeams from './carDiagram/CarLightBeams.vue'
 import LevelBadge from './carDiagram/LevelBadge.vue'
 import SpeedGauge from './carDiagram/SpeedGauge.vue'
 import TyreIndicators from './carDiagram/TyreIndicators.vue'
 import TyreLabels from './carDiagram/TyreLabels.vue'
-import TyreHistoryModal from './TyreHistoryModal.vue'
-import LevelHistoryModal from './LevelHistoryModal.vue'
 import { CAR_SILHOUETTE_VIEWBOX, CAR_SILHOUETTE_MARKUP } from '@/assets/carSilhouette'
 import type { LevelKind } from '@/composables/useStatisticsCharts'
 import { useTyrePressureThresholds } from '@/composables/useTyrePressureThresholds'
@@ -26,8 +24,23 @@ const tyreHistoryOpen = ref(false)
 const levelHistoryOpen = ref(false)
 const levelHistory = ref<LevelKind>('fuel')
 
-function openLevelHistory(level: LevelKind) {
+// The dialogs chart with Chart.js, which is as large as the rest of the dashboard together, so
+// each is fetched on its first tap rather than with the page. It is mounted closed and opened on
+// the next tick: a dialog mounted already open would skip its fade-in and the fetch its watcher
+// starts when it opens.
+const TyreHistoryModal = shallowRef<typeof import('./TyreHistoryModal.vue').default | null>(null)
+const LevelHistoryModal = shallowRef<typeof import('./LevelHistoryModal.vue').default | null>(null)
+
+async function openTyreHistory() {
+  TyreHistoryModal.value ??= (await import('./TyreHistoryModal.vue')).default
+  await nextTick()
+  tyreHistoryOpen.value = true
+}
+
+async function openLevelHistory(level: LevelKind) {
+  LevelHistoryModal.value ??= (await import('./LevelHistoryModal.vue')).default
   levelHistory.value = level
+  await nextTick()
   levelHistoryOpen.value = true
 }
 
@@ -289,7 +302,7 @@ const motionBlurAmount = computed(() => {
             <TyreIndicators :pressures="tyrePressures" />
           </svg>
 
-          <TyreLabels :pressures="tyrePressures" @select="tyreHistoryOpen = true" />
+          <TyreLabels :pressures="tyrePressures" @select="openTyreHistory" />
 
           <!-- Open panel icon badges – positioned over SVG at each panel location -->
           <template v-for="badge in doorBadges" :key="badge.key">
@@ -333,8 +346,15 @@ const motionBlurAmount = computed(() => {
         </div>
       </div>
     </div>
-    <TyreHistoryModal :open="tyreHistoryOpen" @close="tyreHistoryOpen = false" />
-    <LevelHistoryModal
+    <component
+      :is="TyreHistoryModal"
+      v-if="TyreHistoryModal"
+      :open="tyreHistoryOpen"
+      @close="tyreHistoryOpen = false"
+    />
+    <component
+      :is="LevelHistoryModal"
+      v-if="LevelHistoryModal"
       :open="levelHistoryOpen"
       :level="levelHistory"
       @close="levelHistoryOpen = false"
diff --git a/frontend/src/components/__tests__/CarDiagram.spec.ts b/frontend/src/components/__tests__/CarDiagram.spec.ts
new file mode 100644
index 00000000..569c65fd
--- /dev/null
+++ b/frontend/src/components/__tests__/CarDiagram.spec.ts
@@ -0,0 +1,95 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { defineComponent, h } from 'vue'
+import { flushPromises, mount } from '@vue/test-utils'
+import { createPinia, setActivePinia } from 'pinia'
+import { createI18n } from 'vue-i18n'
+import en from '@/locales/en.json'
+import CarDiagram from '../CarDiagram.vue'
+
+// The dialogs chart with Chart.js; stand-ins that say whether they are open, and what they show,
+// and remember whether they were open the moment they mounted.
+const openAtMount = vi.hoisted(() => [] as boolean[])
+const modalStub = (name: string) =>
+  defineComponent({
+    name,
+    props: { open: Boolean, level: { type: String, default: null } },
+    setup: (props) => {
+      openAtMount.push(props.open)
+      return () =>
+        h('div', { class: name, 'data-open': String(props.open), 'data-level': props.level })
+    },
+  })
+
+vi.mock('@/components/TyreHistoryModal.vue', () => ({ default: modalStub('tyre-history') }))
+vi.mock('@/components/LevelHistoryModal.vue', () => ({ default: modalStub('level-history') }))
+
+vi.mock('@/composables/useTyrePressureThresholds', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@/composables/useTyrePressureThresholds')>()
+  const { ref } = await import('vue')
+  return {
+    ...actual,
+    useTyrePressureThresholds: () => ref(actual.DEFAULT_TYRE_PRESSURE_THRESHOLDS),
+  }
+})
+
+const i18n = createI18n({ legacy: false, locale: 'en', messages: { en } })
+
+function mountDiagram() {
+  return mount(CarDiagram, {
+    props: {
+      frontLeft: 2.4,
+      frontRight: 2.4,
+      rearLeft: 2.4,
+      rearRight: 2.4,
+      fuelLevelPercent: 60,
+    },
+    global: { plugins: [i18n], stubs: { FontAwesomeIcon: true } },
+  })
+}
+
+beforeEach(() => {
+  setActivePinia(createPinia())
+  openAtMount.length = 0
+})
+
+describe('CarDiagram', () => {
+  it('leaves the history dialogs out until one is asked for', () => {
+    const wrapper = mountDiagram()
+
+    expect(wrapper.find('.tyre-history').exists()).toBe(false)
+    expect(wrapper.find('.level-history').exists()).toBe(false)
+  })
+
+  it("opens the tyre history from a tyre's pressure, mounted closed first", async () => {
+    const wrapper = mountDiagram()
+
+    await wrapper.find('.tyre-label').trigger('click')
+    await flushPromises()
+
+    // Mounted closed, then opened: its fade-in and its fetch both start from the change.
+    expect(openAtMount).toEqual([false])
+    expect(wrapper.find('.tyre-history').attributes('data-open')).toBe('true')
+  })
+
+  it('opens the level history for the level that was tapped', async () => {
+    const wrapper = mountDiagram()
+
+    await wrapper.find('.diagram-level--fuel').trigger('click')
+    await flushPromises()
+
+    const dialog = wrapper.find('.level-history')
+    expect(dialog.attributes('data-open')).toBe('true')
+    expect(dialog.attributes('data-level')).toBe('fuel')
+  })
+
+  it('closes a dialog it opened and keeps it mounted for the fade-out', async () => {
+    const wrapper = mountDiagram()
+    await wrapper.find('.tyre-label').trigger('click')
+    await flushPromises()
+
+    wrapper.findComponent({ name: 'tyre-history' }).vm.$emit('close')
+    await flushPromises()
+
+    expect(wrapper.find('.tyre-history').attributes('data-open')).toBe('false')
+  })
+})

From 1ac10ed4c2a5ca2c8ffe55cc23e6e1cb994d2cf4 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 19 Oct 2026 19:01:15 +0000
Subject: [PATCH 2/7] fix(frontend): read the status again when the live
 connection comes back

Telemetry pushed while the SignalR connection was down never reached the page,
which kept showing the old state until the next poll. useSignalR now reports a
reconnect (automatic or after its own restart) and App refetches the status.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L6DtW2eHhipteRopmy3cif
---
 frontend/src/App.vue                          |  4 ++
 .../composables/__tests__/useSignalR.spec.ts  | 41 +++++++++++++++++++
 frontend/src/composables/useSignalR.ts        | 11 +++++
 3 files changed, 56 insertions(+)

diff --git a/frontend/src/App.vue b/frontend/src/App.vue
index f40ce9a0..de1bae5d 100644
--- a/frontend/src/App.vue
+++ b/frontend/src/App.vue
@@ -111,6 +111,10 @@ const {
   },
   onTripCompleted: () => vehicleStore.notifyTripCompleted(),
   onCommandResult: (result) => vehicleStore.applyCommandResult(result),
+  // Telemetry that arrived while the connection was down never reached this page.
+  onReconnected: () => {
+    if (vehicleStore.activeVin) void vehicleStore.fetchStatus(vehicleStore.activeVin)
+  },
 })
 
 // Only show "paused" once we've actually attempted a connection, not during the
diff --git a/frontend/src/composables/__tests__/useSignalR.spec.ts b/frontend/src/composables/__tests__/useSignalR.spec.ts
index 130c22c5..4568b33d 100644
--- a/frontend/src/composables/__tests__/useSignalR.spec.ts
+++ b/frontend/src/composables/__tests__/useSignalR.spec.ts
@@ -43,6 +43,7 @@ const callbacks: SignalRCallbacks = {
   onNotificationReceived: vi.fn<SignalRCallbacks['onNotificationReceived']>(),
   onTripCompleted: vi.fn<SignalRCallbacks['onTripCompleted']>(),
   onCommandResult: vi.fn<SignalRCallbacks['onCommandResult']>(),
+  onReconnected: vi.fn<NonNullable<SignalRCallbacks['onReconnected']>>(),
 }
 
 function mountSignalR() {
@@ -60,8 +61,14 @@ function mountSignalR() {
 
 afterEach(() => {
   hub.connections.length = 0
+  vi.clearAllMocks()
 })
 
+// The handler the composable registered through one of the connection's on... methods.
+function handlerOf(connection: Record<string, ReturnType<typeof vi.fn>>, method: string) {
+  return connection[method]!.mock.calls[0]![0] as () => Promise<void> | void
+}
+
 describe('useSignalR', () => {
   it('connects and joins the vehicle group', async () => {
     const { api } = mountSignalR()
@@ -107,4 +114,38 @@ describe('useSignalR', () => {
 
     expect(hub.connections[0]!.stop).toHaveBeenCalledOnce()
   })
+
+  it('does not count the first connection as a reconnect', async () => {
+    const { api } = mountSignalR()
+
+    await api.start(7)
+
+    expect(callbacks.onReconnected).not.toHaveBeenCalled()
+  })
+
+  it('reports an automatic reconnect once the vehicle group is joined again', async () => {
+    const { api } = mountSignalR()
+    await api.start(7)
+    const connection = hub.connections[0]!
+
+    await handlerOf(connection, 'onreconnected')()
+
+    expect(connection.invoke).toHaveBeenLastCalledWith('JoinVehicle', 7)
+    expect(callbacks.onReconnected).toHaveBeenCalledOnce()
+  })
+
+  it('reports a reconnect after the connection closed and was started again', async () => {
+    const { api } = mountSignalR()
+    await api.start(7)
+    const connection = hub.connections[0]!
+
+    handlerOf(connection, 'onclose')()
+    // The first retry waits no time at all, but still goes through a timer.
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    await flushPromises()
+
+    expect(connection.start).toHaveBeenCalledTimes(2)
+    expect(callbacks.onReconnected).toHaveBeenCalledOnce()
+    expect(api.connected.value).toBe(true)
+  })
 })
diff --git a/frontend/src/composables/useSignalR.ts b/frontend/src/composables/useSignalR.ts
index d6d890db..94831fe6 100644
--- a/frontend/src/composables/useSignalR.ts
+++ b/frontend/src/composables/useSignalR.ts
@@ -9,6 +9,11 @@ export interface SignalRCallbacks {
   onNotificationReceived: (notification: AppNotification) => void
   onTripCompleted: (vehicleId: number) => void
   onCommandResult: (result: CommandResult) => void
+  /**
+   * The connection is back after dropping. Whatever the server pushed in between is lost, so this
+   * is the moment to read the live state again.
+   */
+  onReconnected?: () => void
 }
 
 // Backoff between reconnect attempts, reused for both the automatic reconnect and our own
@@ -53,6 +58,8 @@ export function useSignalR(callbacks: SignalRCallbacks) {
   // Bumped by every start() and stop(), so an attempt still waiting for the client library can
   // tell that the caller has since ended it or asked for another vehicle.
   let session = 0
+  // Whether this session's connection has been up before, so a later start is a reconnect.
+  let hasConnected = false
 
   // Only warming the download here; a failure surfaces, and is retried, when a connection opens.
   loadClient().catch(() => {})
@@ -105,6 +112,7 @@ export function useSignalR(callbacks: SignalRCallbacks) {
     created.onreconnected(async () => {
       connected.value = true
       await created.invoke('JoinVehicle', vehicleId)
+      callbacks.onReconnected?.()
     })
     created.onclose(() => {
       connected.value = false
@@ -128,6 +136,8 @@ export function useSignalR(callbacks: SignalRCallbacks) {
       await connection.invoke('JoinVehicle', vehicleId)
       connected.value = true
       restartAttempt = 0
+      if (hasConnected) callbacks.onReconnected?.()
+      hasConnected = true
     } catch {
       if (attempt !== session) return
       // The server is unreachable (still starting, restarting, or the network is down), or the
@@ -143,6 +153,7 @@ export function useSignalR(callbacks: SignalRCallbacks) {
     session += 1
     stopped = false
     restartAttempt = 0
+    hasConnected = false
     await openConnection(vehicleId)
   }
 

From 5315ad618c902e3752d695e871f6c322f6a62f13 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 19 Oct 2026 19:01:15 +0000
Subject: [PATCH 3/7] fix(frontend): send an unknown address to the dashboard

An old bookmark or a typo rendered an empty page.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L6DtW2eHhipteRopmy3cif
---
 frontend/src/router/__tests__/router.spec.ts | 6 ++++++
 frontend/src/router/index.ts                 | 7 +++++++
 2 files changed, 13 insertions(+)

diff --git a/frontend/src/router/__tests__/router.spec.ts b/frontend/src/router/__tests__/router.spec.ts
index 31f47672..9495a24a 100644
--- a/frontend/src/router/__tests__/router.spec.ts
+++ b/frontend/src/router/__tests__/router.spec.ts
@@ -164,6 +164,12 @@ describe('router guard', () => {
 
     expect(dashboard?.meta.preconnect).toContain(RASTER_TILE_ORIGIN)
   })
+  it('sends an address no view answers to on to the dashboard', () => {
+    const unknown = router.resolve('/no/such/page')
+
+    expect(unknown.name).toBe('notFound')
+    expect(unknown.matched[0]?.redirect).toEqual({ name: 'dashboard' })
+  })
 })
 
 function preconnectLink(origin: string): Element | null {
diff --git a/frontend/src/router/index.ts b/frontend/src/router/index.ts
index aa79da4c..a2ff3cc0 100644
--- a/frontend/src/router/index.ts
+++ b/frontend/src/router/index.ts
@@ -59,6 +59,13 @@ const router = createRouter({
       name: 'logs',
       component: () => import('@/views/LogsView.vue'),
     },
+    {
+      // An address no view answers to (an old bookmark, a typo) lands on the dashboard rather than
+      // on an empty page.
+      path: '/:pathMatch(.*)*',
+      name: 'notFound',
+      redirect: { name: 'dashboard' },
+    },
   ],
   // No scrollBehavior: the scroll container is the main content element, not the window, so
   // App.vue scrolls it to the top on every route change itself.

From c850e23634b188631dad36f41c53b65f45ffe855 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 19 Oct 2026 19:01:15 +0000
Subject: [PATCH 4/7] fix(upstream): back off as long as Retry-After asks

Open Charge Map, Overpass, Nominatim, Valhalla and the RDW each backed off a
fixed time after a 429/503/504, whatever the server said. The gate now reads
Retry-After (seconds or a date), kept between a second and an hour, and falls
back to each client's own default without one.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L6DtW2eHhipteRopmy3cif
---
 .../Helpers/UpstreamRateGate.cs               | 35 ++++++++++++-
 .../Services/NominatimApiClient.cs            |  4 +-
 src/GarageStack.Data/Services/OcmApiClient.cs |  4 +-
 .../Services/OverpassApiClient.cs             |  8 +--
 src/GarageStack.Data/Services/RdwApiClient.cs |  6 +--
 .../Services/ValhallaApiClient.cs             |  4 +-
 .../UpstreamRateGateTests.cs                  | 51 +++++++++++++++++++
 7 files changed, 98 insertions(+), 14 deletions(-)

diff --git a/src/GarageStack.Core/Helpers/UpstreamRateGate.cs b/src/GarageStack.Core/Helpers/UpstreamRateGate.cs
index 23031543..69db8e19 100644
--- a/src/GarageStack.Core/Helpers/UpstreamRateGate.cs
+++ b/src/GarageStack.Core/Helpers/UpstreamRateGate.cs
@@ -1,3 +1,5 @@
+using System.Net.Http.Headers;
+
 namespace GarageStack.Core.Helpers;
 
 /// <summary>Why a request did not get to go upstream just now.</summary>
@@ -16,7 +18,7 @@ public enum GateRefusal
 /// <summary>
 /// The politeness rules every third-party API client (Open Charge Map, Overpass, Nominatim,
 /// Valhalla, the RDW) needs: one request in flight at a time, a minimum interval between requests, and a
-/// backoff window after the upstream answers 429/503/504. A client takes the gate with
+/// backoff window after the upstream answers 429/503/504, as long as its Retry-After asks. A client takes the gate with
 /// <see cref="TryEnterAsync"/>, calls <see cref="ThrottleAsync"/> and <see cref="MarkRequestSent"/>
 /// around its request, and disposes the entry; the backoff can be read outside the gate so a
 /// foreground caller fails fast without waiting.
@@ -87,9 +89,40 @@ public async Task ThrottleAsync(TimeSpan minInterval, bool honourBackoff, Cancel
     /// <summary>Call while holding the gate, right before the HTTP request goes out.</summary>
     public void MarkRequestSent() => _lastRequestAt = DateTimeOffset.UtcNow;
 
+    // The bounds on a Retry-After an upstream sends: a second at the least, so a "0" cannot
+    // turn a refusal into an immediate retry, and an hour at the most, so a mistaken header
+    // cannot switch a feature off for the day.
+    internal static readonly TimeSpan MinRetryAfter = TimeSpan.FromSeconds(1);
+    internal static readonly TimeSpan MaxRetryAfter = TimeSpan.FromHours(1);
+
     public void SetBackoff(TimeSpan duration) =>
         Interlocked.Exchange(ref _backoffUntilTicks, (DateTimeOffset.UtcNow + duration).UtcTicks);
 
+    /// <summary>
+    /// Opens the backoff window an upstream's "slow down" answer asks for: as long as its
+    /// Retry-After header says, or <paramref name="fallback"/> when it sends none.
+    /// </summary>
+    /// <returns>How long the window is, for the log line.</returns>
+    public TimeSpan SetBackoff(HttpResponseMessage response, TimeSpan fallback)
+    {
+        var duration = BackoffFor(response.Headers.RetryAfter, fallback, DateTimeOffset.UtcNow);
+        SetBackoff(duration);
+        return duration;
+    }
+
+    /// <summary>
+    /// The wait a Retry-After header asks for, in seconds or as a date, kept between
+    /// <see cref="MinRetryAfter"/> and <see cref="MaxRetryAfter"/>. A missing header, or a date
+    /// already past, leaves the caller's own <paramref name="fallback"/>.
+    /// </summary>
+    internal static TimeSpan BackoffFor(RetryConditionHeaderValue? retryAfter, TimeSpan fallback, DateTimeOffset now)
+    {
+        var asked = retryAfter?.Delta ?? (retryAfter?.Date is { } date ? date - now : null);
+        if (asked is not { } wait || wait <= TimeSpan.Zero) return fallback;
+        if (wait < MinRetryAfter) return MinRetryAfter;
+        return wait > MaxRetryAfter ? MaxRetryAfter : wait;
+    }
+
     /// <summary>True for the upstream status codes that mean "slow down", not "your request is wrong".</summary>
     public static bool IsThrottlingStatus(int statusCode) => statusCode is 429 or 503 or 504;
 }
diff --git a/src/GarageStack.Data/Services/NominatimApiClient.cs b/src/GarageStack.Data/Services/NominatimApiClient.cs
index 41912f12..81fdfb55 100644
--- a/src/GarageStack.Data/Services/NominatimApiClient.cs
+++ b/src/GarageStack.Data/Services/NominatimApiClient.cs
@@ -69,9 +69,9 @@ public sealed class NominatimApiClient(
 
             if (UpstreamRateGate.IsThrottlingStatus((int)response.StatusCode))
             {
-                _gate.SetBackoff(RetryAfter429);
+                var backoff = _gate.SetBackoff(response, RetryAfter429);
                 logger.LogDebug("Nominatim {Status}, backing off {Seconds}s",
-                    (int)response.StatusCode, (int)RetryAfter429.TotalSeconds);
+                    (int)response.StatusCode, (int)backoff.TotalSeconds);
                 return null;
             }
 
diff --git a/src/GarageStack.Data/Services/OcmApiClient.cs b/src/GarageStack.Data/Services/OcmApiClient.cs
index 77890633..3f001edf 100644
--- a/src/GarageStack.Data/Services/OcmApiClient.cs
+++ b/src/GarageStack.Data/Services/OcmApiClient.cs
@@ -73,9 +73,9 @@ public sealed class OcmApiClient(
 
         if (UpstreamRateGate.IsThrottlingStatus((int)response.StatusCode))
         {
-            _gate.SetBackoff(RetryAfter429);
+            var backoff = _gate.SetBackoff(response, RetryAfter429);
             logger.LogWarning("OCM rate-limited ({Status}); pausing charging station requests for {Seconds}s",
-                (int)response.StatusCode, (int)RetryAfter429.TotalSeconds);
+                (int)response.StatusCode, (int)backoff.TotalSeconds);
             return null;
         }
 
diff --git a/src/GarageStack.Data/Services/OverpassApiClient.cs b/src/GarageStack.Data/Services/OverpassApiClient.cs
index 13959ef8..8d821d7a 100644
--- a/src/GarageStack.Data/Services/OverpassApiClient.cs
+++ b/src/GarageStack.Data/Services/OverpassApiClient.cs
@@ -103,15 +103,15 @@ await _gate.ThrottleAsync(
             {
                 // Short backoff so subsequent pans don't immediately retry the same
                 // rate-limited tile and keep getting 429 forever ("area stays blank").
-                _gate.SetBackoff(ForegroundRetryAfter429);
+                var backoff = _gate.SetBackoff(response, ForegroundRetryAfter429);
                 logger.LogDebug("Overpass {Status} for {PoiType} ({CellLat},{CellLng}) on foreground path, backing off {Seconds}s",
-                    (int)response.StatusCode, poiType, cellLat, cellLng, (int)ForegroundRetryAfter429.TotalSeconds);
+                    (int)response.StatusCode, poiType, cellLat, cellLng, (int)backoff.TotalSeconds);
                 return null;
             }
 
             // Background: record backoff window so the foreground path skips Overpass for
-            // the next BackgroundRetryAfter429 seconds.
-            _gate.SetBackoff(BackgroundRetryAfter429);
+            // as long as Overpass asked, or the next BackgroundRetryAfter429 seconds.
+            _gate.SetBackoff(response, BackgroundRetryAfter429);
             throw new HttpRequestException(
                 $"Overpass rate-limited ({(int)response.StatusCode}) for {poiType} ({cellLat},{cellLng})");
         }
diff --git a/src/GarageStack.Data/Services/RdwApiClient.cs b/src/GarageStack.Data/Services/RdwApiClient.cs
index 8c9b5312..b9f64e12 100644
--- a/src/GarageStack.Data/Services/RdwApiClient.cs
+++ b/src/GarageStack.Data/Services/RdwApiClient.cs
@@ -104,9 +104,9 @@ private async Task<IReadOnlyList<T>> GetAsync<T>(string dataset, string query, C
 
             if (UpstreamRateGate.IsThrottlingStatus((int)response.StatusCode))
             {
-                _gate.SetBackoff(RetryAfterThrottle);
-                logger.LogWarning("RDW rate-limited ({Status}); pausing lookups for {Minutes} minutes",
-                    (int)response.StatusCode, (int)RetryAfterThrottle.TotalMinutes);
+                var backoff = _gate.SetBackoff(response, RetryAfterThrottle);
+                logger.LogWarning("RDW rate-limited ({Status}); pausing lookups for {Seconds}s",
+                    (int)response.StatusCode, (int)backoff.TotalSeconds);
                 throw new RdwUnavailableException("The RDW asked to slow down; trying again later");
             }
 
diff --git a/src/GarageStack.Data/Services/ValhallaApiClient.cs b/src/GarageStack.Data/Services/ValhallaApiClient.cs
index 7f57222c..f656d13e 100644
--- a/src/GarageStack.Data/Services/ValhallaApiClient.cs
+++ b/src/GarageStack.Data/Services/ValhallaApiClient.cs
@@ -74,9 +74,9 @@ public async Task<TraceMatch> MatchAsync(IReadOnlyList<GeoCoordinate> points, Ca
 
             if (UpstreamRateGate.IsThrottlingStatus((int)response.StatusCode))
             {
-                _gate.SetBackoff(RetryAfter429);
+                var backoff = _gate.SetBackoff(response, RetryAfter429);
                 logger.LogDebug("Valhalla {Status}, backing off {Seconds}s",
-                    (int)response.StatusCode, (int)RetryAfter429.TotalSeconds);
+                    (int)response.StatusCode, (int)backoff.TotalSeconds);
                 return TraceMatch.Unavailable;
             }
 
diff --git a/src/GarageStack.Tests/UpstreamRateGateTests.cs b/src/GarageStack.Tests/UpstreamRateGateTests.cs
index 5d70ab80..71574a2f 100644
--- a/src/GarageStack.Tests/UpstreamRateGateTests.cs
+++ b/src/GarageStack.Tests/UpstreamRateGateTests.cs
@@ -1,3 +1,5 @@
+using System.Net;
+using System.Net.Http.Headers;
 using GarageStack.Core.Helpers;
 
 namespace GarageStack.Tests;
@@ -77,4 +79,53 @@ public async Task Dispose_Twice_ReleasesTheGateOnce()
         Assert.True(first.Entered);
         Assert.False(second.Entered);
     }
+
+    private static readonly TimeSpan Fallback = TimeSpan.FromSeconds(60);
+    private static readonly DateTimeOffset Now = new(2026, 10, 19, 12, 0, 0, TimeSpan.Zero);
+
+    [Fact]
+    public void BackoffFor_WaitsAsLongAsRetryAfterSaysInSeconds()
+    {
+        var wait = UpstreamRateGate.BackoffFor(new RetryConditionHeaderValue(TimeSpan.FromSeconds(300)), Fallback, Now);
+
+        Assert.Equal(TimeSpan.FromSeconds(300), wait);
+    }
+
+    [Fact]
+    public void BackoffFor_WaitsUntilTheDateRetryAfterNames()
+    {
+        var wait = UpstreamRateGate.BackoffFor(new RetryConditionHeaderValue(Now.AddMinutes(2)), Fallback, Now);
+
+        Assert.Equal(TimeSpan.FromMinutes(2), wait);
+    }
+
+    [Fact]
+    public void BackoffFor_KeepsTheFallback_WithoutAHeaderOrWithADateAlreadyPast()
+    {
+        Assert.Equal(Fallback, UpstreamRateGate.BackoffFor(null, Fallback, Now));
+        Assert.Equal(Fallback, UpstreamRateGate.BackoffFor(new RetryConditionHeaderValue(Now.AddMinutes(-1)), Fallback, Now));
+    }
+
+    [Fact]
+    public void BackoffFor_KeepsAnAskedWaitBetweenASecondAndAnHour()
+    {
+        Assert.Equal(UpstreamRateGate.MinRetryAfter,
+            UpstreamRateGate.BackoffFor(new RetryConditionHeaderValue(TimeSpan.FromMilliseconds(10)), Fallback, Now));
+        Assert.Equal(UpstreamRateGate.MaxRetryAfter,
+            UpstreamRateGate.BackoffFor(new RetryConditionHeaderValue(TimeSpan.FromDays(1)), Fallback, Now));
+    }
+
+    [Fact]
+    public void SetBackoff_FromAResponse_OpensTheWindowItsRetryAfterAsks()
+    {
+        var gate = new UpstreamRateGate();
+        using var response = new HttpResponseMessage(HttpStatusCode.TooManyRequests);
+        response.Headers.RetryAfter = new RetryConditionHeaderValue(TimeSpan.FromSeconds(300));
+
+        var before = DateTimeOffset.UtcNow;
+        var wait = gate.SetBackoff(response, Fallback);
+
+        Assert.Equal(TimeSpan.FromSeconds(300), wait);
+        Assert.InRange(gate.BackoffUntil, before.AddSeconds(300), DateTimeOffset.UtcNow.AddSeconds(300));
+    }
 }

From bc5a77c853b33c1756881c0070dc50a34e0c8b1e Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 19 Oct 2026 19:01:15 +0000
Subject: [PATCH 5/7] perf(telemetry): stop storing the raw MQTT topic on every
 row

Each telemetry row kept the full topic that started it,
saic/<account email>/vehicles/<VIN>/..., so every row carried the MG account's
email address. Only the undocumented diagnostic endpoint
GET /api/vehicles/{vin}/topics read it; it goes too. Unmapped topics are still
logged once each. The DropRawTopic migration drops the column, which
PostgreSQL does without rewriting the table.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L6DtW2eHhipteRopmy3cif
---
 .../Endpoints/VehicleEndpoints.cs             |   12 -
 .../Helpers/TelemetryFields.cs                |    1 -
 .../Interfaces/ITelemetryRepository.cs        |    5 -
 .../Models/TelemetryQueryResults.cs           |    3 -
 .../Models/TelemetrySnapshot.cs               |    8 -
 .../Demo/DemoTelemetryRepository.cs           |    2 -
 .../20261019185754_DropRawTopic.Designer.cs   | 1177 +++++++++++++++++
 .../Migrations/20261019185754_DropRawTopic.cs |   28 +
 .../Migrations/AppDbContextModelSnapshot.cs   |    3 -
 .../Repositories/TelemetryRepository.cs       |    9 -
 .../TelemetryHandlerTests.cs                  |    5 +-
 .../TelemetryRepositoryTests.cs               |   38 -
 .../Mqtt/TelemetryHandler.cs                  |    5 +-
 13 files changed, 1209 insertions(+), 87 deletions(-)
 create mode 100644 src/GarageStack.Data/Migrations/20261019185754_DropRawTopic.Designer.cs
 create mode 100644 src/GarageStack.Data/Migrations/20261019185754_DropRawTopic.cs

diff --git a/src/GarageStack.Api/Endpoints/VehicleEndpoints.cs b/src/GarageStack.Api/Endpoints/VehicleEndpoints.cs
index 88473e77..b5ffc1d7 100644
--- a/src/GarageStack.Api/Endpoints/VehicleEndpoints.cs
+++ b/src/GarageStack.Api/Endpoints/VehicleEndpoints.cs
@@ -11,8 +11,6 @@ public static class VehicleEndpoints
     // What the tyre history dialog charts.
     private const int TyreHistoryDays = 30;
 
-    private static readonly TimeSpan TopicsWindow = TimeSpan.FromDays(7);
-
     public static IEndpointRouteBuilder MapVehicleEndpoints(this IEndpointRouteBuilder app)
     {
         var group = app.MapGroup("/api/vehicles")
@@ -160,16 +158,6 @@ public static IEndpointRouteBuilder MapVehicleEndpoints(this IEndpointRouteBuild
         })
         .WithSummary("Get aggregate statistics for a vehicle over a date range");
 
-        // A diagnostic: what the gateway has been sending lately. Bounded to a week, so it reads
-        // a slice of the telemetry instead of every row the car ever sent.
-        vehicleGroup.MapGet("/topics", async (HttpContext httpContext, ITelemetryRepository telemetry, CancellationToken ct) =>
-        {
-            var vehicle = httpContext.ResolvedVehicle();
-            var topics = await telemetry.GetRawTopicStatsAsync(vehicle.Id, DateTime.UtcNow - TopicsWindow, ct);
-            return Results.Ok(topics);
-        })
-        .WithSummary("Distinct raw MQTT topics seen for a vehicle in the last 7 days (one entry per 15-second merge window; topics arriving mid-window are not recorded)");
-
         return app;
     }
 
diff --git a/src/GarageStack.Core/Helpers/TelemetryFields.cs b/src/GarageStack.Core/Helpers/TelemetryFields.cs
index e2e1173e..2f94e625 100644
--- a/src/GarageStack.Core/Helpers/TelemetryFields.cs
+++ b/src/GarageStack.Core/Helpers/TelemetryFields.cs
@@ -17,7 +17,6 @@ public static class TelemetryFields
     [
         nameof(TelemetrySnapshot.Id), nameof(TelemetrySnapshot.VehicleId),
         nameof(TelemetrySnapshot.Vehicle), nameof(TelemetrySnapshot.RecordedAt),
-        nameof(TelemetrySnapshot.RawTopic),
     ];
 
     /// <summary>Every property that carries telemetry, in declaration order.</summary>
diff --git a/src/GarageStack.Core/Interfaces/ITelemetryRepository.cs b/src/GarageStack.Core/Interfaces/ITelemetryRepository.cs
index 01e40f6f..3b39e6b7 100644
--- a/src/GarageStack.Core/Interfaces/ITelemetryRepository.cs
+++ b/src/GarageStack.Core/Interfaces/ITelemetryRepository.cs
@@ -72,11 +72,6 @@ Task<IReadOnlyList<DailyStat>> GetDailyStatsAsync(
     /// </summary>
     Task<string?> GetChargingStopReasonAsync(int vehicleId, CancellationToken ct = default);
 
-    /// <summary>
-    /// The raw MQTT topics that started telemetry rows for <paramref name="vehicleId"/> since
-    /// <paramref name="since"/>, most frequent first.
-    /// </summary>
-    Task<IReadOnlyList<RawTopicStat>> GetRawTopicStatsAsync(int vehicleId, DateTime since, CancellationToken ct = default);
 
     /// <summary>
     /// Every row recorded for <paramref name="vehicleId"/>, oldest first, one at a time: for the data
diff --git a/src/GarageStack.Core/Models/TelemetryQueryResults.cs b/src/GarageStack.Core/Models/TelemetryQueryResults.cs
index 7adbe2ea..6a2e563b 100644
--- a/src/GarageStack.Core/Models/TelemetryQueryResults.cs
+++ b/src/GarageStack.Core/Models/TelemetryQueryResults.cs
@@ -3,9 +3,6 @@ namespace GarageStack.Core.Models;
 /// <summary>Where the car was by one GPS fix, and which way it faced.</summary>
 public sealed record PositionFix(double Latitude, double Longitude, double? Heading);
 
-/// <summary>How often one raw MQTT topic started a telemetry row, and when it last did.</summary>
-public sealed record RawTopicStat(string Topic, int Count, DateTime Last);
-
 /// <summary>
 /// One poll of the car's status (lock, doors, windows) and when it first reached GarageStack.
 /// <see cref="State"/> is the telemetry row the poll landed in.
diff --git a/src/GarageStack.Core/Models/TelemetrySnapshot.cs b/src/GarageStack.Core/Models/TelemetrySnapshot.cs
index aa03de6c..3e053237 100644
--- a/src/GarageStack.Core/Models/TelemetrySnapshot.cs
+++ b/src/GarageStack.Core/Models/TelemetrySnapshot.cs
@@ -1,5 +1,3 @@
-using System.Text.Json.Serialization;
-
 namespace GarageStack.Core.Models;
 
 public class TelemetrySnapshot
@@ -123,11 +121,5 @@ public class TelemetrySnapshot
     // Location extras
     public double? Elevation { get; set; }
 
-    // Only set on the row that starts a merge window (TelemetryRepository.AddAsync), never on
-    // rows folded into it via MergeIntoAsync - kept for troubleshooting which MQTT topic
-    // created a given row. Not serialized to the API response.
-    [JsonIgnore]
-    public string? RawTopic { get; set; }
-
     public TelemetrySnapshot Clone() => (TelemetrySnapshot)MemberwiseClone();
 }
diff --git a/src/GarageStack.Data/Demo/DemoTelemetryRepository.cs b/src/GarageStack.Data/Demo/DemoTelemetryRepository.cs
index 01a4b410..8ceb0935 100644
--- a/src/GarageStack.Data/Demo/DemoTelemetryRepository.cs
+++ b/src/GarageStack.Data/Demo/DemoTelemetryRepository.cs
@@ -93,8 +93,6 @@ public async IAsyncEnumerable<TelemetrySnapshot> StreamAllAsync(
     }
 
     // Demo data is not ingested from MQTT, so there are no raw topics to report.
-    public Task<IReadOnlyList<RawTopicStat>> GetRawTopicStatsAsync(int vehicleId, DateTime since, CancellationToken ct = default) =>
-        Task.FromResult<IReadOnlyList<RawTopicStat>>([]);
 
     public Task<VehicleAggregateStats> GetAggregateStatsAsync(
         int vehicleId, DateTime from, DateTime to, CancellationToken ct = default)
diff --git a/src/GarageStack.Data/Migrations/20261019185754_DropRawTopic.Designer.cs b/src/GarageStack.Data/Migrations/20261019185754_DropRawTopic.Designer.cs
new file mode 100644
index 00000000..d2619fb2
--- /dev/null
+++ b/src/GarageStack.Data/Migrations/20261019185754_DropRawTopic.Designer.cs
@@ -0,0 +1,1177 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using GarageStack.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace GarageStack.Data.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20261019185754_DropRawTopic")]
+    partial class DropRawTopic
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.13")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("GarageStack.Core.Models.ApiToken", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccountKey")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("LastUsedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Prefix")
+                        .IsRequired()
+                        .HasMaxLength(9)
+                        .HasColumnType("character varying(9)");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountKey");
+
+                    b.HasIndex("TokenHash")
+                        .IsUnique();
+
+                    b.ToTable("ApiTokens");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.AppNotification", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Category")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsArchived")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("VehicleId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.HasIndex("IsDeleted", "CreatedAt");
+
+                    b.ToTable("AppNotifications");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.ClimateSchedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Days")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastRunAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastRunDetail")
+                        .HasMaxLength(300)
+                        .HasColumnType("character varying(300)");
+
+                    b.Property<string>("LastRunFailedCommand")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("LastRunOutcome")
+                        .HasMaxLength(24)
+                        .HasColumnType("character varying(24)");
+
+                    b.Property<string>("Mode")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime?>("NextRunUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double?>("OnlyAboveC")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("OnlyBelowC")
+                        .HasColumnType("double precision");
+
+                    b.Property<bool>("RearDefroster")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("SeatLeftLevel")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SeatRightLevel")
+                        .HasColumnType("integer");
+
+                    b.Property<TimeOnly>("StartTime")
+                        .HasColumnType("time without time zone");
+
+                    b.Property<int>("TemperatureC")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TimeZoneId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<int>("VehicleId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Version")
+                        .IsConcurrencyToken()
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("VehicleId");
+
+                    b.ToTable("ClimateSchedules");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.CommutePlace", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Kind")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Label")
+                        .HasMaxLength(60)
+                        .HasColumnType("character varying(60)");
+
+                    b.Property<double>("Latitude")
+                        .HasColumnType("double precision");
+
+                    b.Property<double>("Longitude")
+                        .HasColumnType("double precision");
+
+                    b.Property<int>("RadiusMeters")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("VehicleId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("VehicleId");
+
+                    b.ToTable("CommutePlaces");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.GeocodeCacheEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CachedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("CellLat")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("CellLng")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("City")
+                        .HasMaxLength(120)
+                        .HasColumnType("character varying(120)");
+
+                    b.Property<string>("CountryCode")
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(300)
+                        .HasColumnType("character varying(300)");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("HouseNumber")
+                        .HasMaxLength(120)
+                        .HasColumnType("character varying(120)");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Postcode")
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<string>("Precision")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<string>("Road")
+                        .HasMaxLength(120)
+                        .HasColumnType("character varying(120)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExpiresAt")
+                        .HasDatabaseName("IX_GeocodeCacheEntries_ExpiresAt");
+
+                    b.HasIndex("Precision", "Language", "CellLat", "CellLng")
+                        .IsUnique()
+                        .HasDatabaseName("IX_GeocodeCacheEntries_Precision_Language_CellLatLng");
+
+                    b.ToTable("GeocodeCacheEntries");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.MaintenanceItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double?>("IntervalKm")
+                        .HasColumnType("double precision");
+
+                    b.Property<int?>("IntervalMonths")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("LastServiceDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double?>("LastServiceOdometerKm")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<int>("VehicleId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("VehicleId");
+
+                    b.ToTable("MaintenanceItems");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.MaintenanceLogEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MaintenanceItemId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<double?>("OdometerKm")
+                        .HasColumnType("double precision");
+
+                    b.Property<DateTime>("PerformedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MaintenanceItemId", "PerformedAt");
+
+                    b.ToTable("MaintenanceLogEntries");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.MapMatchCacheEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CachedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double>("MatchedKm")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("PointIndexesJson")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Provider")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Shape")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SpeedLimitRunsJson")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TraceHash")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExpiresAt")
+                        .HasDatabaseName("IX_MapMatchCacheEntries_ExpiresAt");
+
+                    b.HasIndex("Provider", "TraceHash")
+                        .IsUnique()
+                        .HasDatabaseName("IX_MapMatchCacheEntries_Provider_TraceHash");
+
+                    b.ToTable("MapMatchCacheEntries");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.PoiCacheTile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CachedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("CellLat")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("CellLng")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("PoiType")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExpiresAt")
+                        .HasDatabaseName("IX_PoiCacheTiles_ExpiresAt");
+
+                    b.HasIndex("Source", "PoiType", "CellLat", "CellLng")
+                        .IsUnique()
+                        .HasDatabaseName("IX_PoiCacheTiles_Source_PoiType_CellLatLng");
+
+                    b.ToTable("PoiCacheTiles");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.PoiItem", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Brand")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<int>("CellLat")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("CellLng")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ExternalId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<double>("Latitude")
+                        .HasColumnType("double precision");
+
+                    b.Property<double>("Longitude")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("MetaJson")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PoiType")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Source", "ExternalId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_PoiItems_Source_ExternalId");
+
+                    b.HasIndex("Source", "PoiType", "Brand")
+                        .HasDatabaseName("IX_PoiItems_Source_PoiType_Brand");
+
+                    b.HasIndex("Source", "PoiType", "CellLat", "CellLng")
+                        .HasDatabaseName("IX_PoiItems_Source_PoiType_CellLatLng");
+
+                    b.HasIndex("Source", "PoiType", "Latitude", "Longitude")
+                        .HasDatabaseName("IX_PoiItems_Source_PoiType_LatLon");
+
+                    b.ToTable("PoiItems");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.PushSubscription", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AuthKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Endpoint")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.PrimitiveCollection<List<string>>("ExcludedCategories")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("text[]")
+                        .HasDefaultValueSql("'{}'::text[]");
+
+                    b.Property<string>("P256DhKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Endpoint")
+                        .IsUnique();
+
+                    b.ToTable("PushSubscriptions");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.RdwVehicleInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly?>("ApkExpiresOn")
+                        .HasColumnType("date");
+
+                    b.Property<DateTime?>("FetchedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("Found")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("LicensePlate")
+                        .IsRequired()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Make")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Model")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<bool?>("OpenRecallIndicator")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("RecallsJson")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("VehicleId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool?>("WamInsured")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("VehicleId")
+                        .IsUnique();
+
+                    b.ToTable("RdwVehicleInfos");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.RevokedToken", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("ExpiresAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Jti")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Jti")
+                        .IsUnique();
+
+                    b.ToTable("RevokedTokens");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.TelemetrySnapshot", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<bool?>("BatteryHeating")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("BatteryHeatingScheduleMode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BatteryHeatingScheduleStartTime")
+                        .HasColumnType("text");
+
+                    b.Property<double?>("BatteryVoltage")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("BmsChargeStatus")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("BonnetOpen")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ChargeCurrentLimit")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("ChargerConnected")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool?>("ChargingCableLock")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("ChargingLastEndAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("ChargingLastStartAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ChargingScheduleEndTime")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChargingScheduleMode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChargingScheduleStartTime")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChargingStopReason")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChargingType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClimateMode")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("ClimateOn")
+                        .HasColumnType("boolean");
+
+                    b.Property<double?>("CurrentJourneyDistance")
+                        .HasColumnType("double precision");
+
+                    b.Property<bool?>("DriverDoorOpen")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool?>("DriverWindowOpen")
+                        .HasColumnType("boolean");
+
+                    b.Property<double?>("ElectricRangeKm")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("Elevation")
+                        .HasColumnType("double precision");
+
+                    b.Property<bool?>("EngineRunning")
+                        .HasColumnType("boolean");
+
+                    b.Property<double?>("EvSocPercent")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("ExteriorTemperature")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("FuelLevelPercent")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("FuelRangeKm")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("Heading")
+                        .HasColumnType("double precision");
+
+                    b.Property<int?>("HeatedSeatFrontLeft")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("HeatedSeatFrontRight")
+                        .HasColumnType("integer");
+
+                    b.Property<bool?>("HvBatteryActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<double?>("HvCurrent")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("HvPower")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("HvSocKwh")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("HvTotalCapacityKwh")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("HvVoltage")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("InteriorTemperature")
+                        .HasColumnType("double precision");
+
+                    b.Property<bool?>("IsAvailable")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool?>("IsCharging")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool?>("IsLocked")
+                        .HasColumnType("boolean");
+
+                    b.Property<double?>("LastChargeEndingPower")
+                        .HasColumnType("double precision");
+
+                    b.Property<DateTime?>("LastChargeStateAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("LastVehicleStateAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double?>("Latitude")
+                        .HasColumnType("double precision");
+
+                    b.Property<bool?>("LightsDippedBeam")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool?>("LightsMainBeam")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool?>("LightsSide")
+                        .HasColumnType("boolean");
+
+                    b.Property<double?>("Longitude")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("MileageOfTheDay")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("MileageSinceLastCharge")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("ObcCurrent")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("ObcPowerSinglePhase")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("ObcPowerThreePhase")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("ObcVoltage")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("OdometerKm")
+                        .HasColumnType("double precision");
+
+                    b.Property<int?>("OffboardChargerPlugStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("OnboardChargerPlugStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<bool?>("PassengerDoorOpen")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool?>("PassengerWindowOpen")
+                        .HasColumnType("boolean");
+
+                    b.Property<double?>("PowerUsageOfDay")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("PowerUsageSinceLastCharge")
+                        .HasColumnType("double precision");
+
+                    b.Property<bool?>("RearLeftDoorOpen")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool?>("RearLeftWindowOpen")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool?>("RearRightDoorOpen")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool?>("RearRightWindowOpen")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool?>("RearWindowDefroster")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("RecordedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("RemainingChargingTime")
+                        .HasColumnType("integer");
+
+                    b.Property<double?>("RemoteTemperature")
+                        .HasColumnType("double precision");
+
+                    b.Property<int?>("SocTargetPercent")
+                        .HasColumnType("integer");
+
+                    b.Property<double?>("Speed")
+                        .HasColumnType("double precision");
+
+                    b.Property<bool?>("SunRoofOpen")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool?>("TrunkOpen")
+                        .HasColumnType("boolean");
+
+                    b.Property<double?>("TyrePressureFrontLeft")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("TyrePressureFrontRight")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("TyrePressureRearLeft")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("TyrePressureRearRight")
+                        .HasColumnType("double precision");
+
+                    b.Property<int>("VehicleId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("VehicleId", "RecordedAt");
+
+                    b.HasIndex(new[] { "VehicleId", "RecordedAt" }, "IX_TelemetrySnapshots_VehicleId_RecordedAt_Gps")
+                        .HasFilter("\"Latitude\" IS NOT NULL AND \"Longitude\" IS NOT NULL");
+
+                    NpgsqlIndexBuilderExtensions.IncludeProperties(b.HasIndex(new[] { "VehicleId", "RecordedAt" }, "IX_TelemetrySnapshots_VehicleId_RecordedAt_Gps"), new[] { "Latitude", "Longitude", "Speed", "Heading" });
+
+                    b.HasIndex(new[] { "VehicleId", "RecordedAt" }, "IX_TelemetrySnapshots_VehicleId_RecordedAt_Schedule")
+                        .HasFilter("\"ChargingScheduleMode\" IS NOT NULL OR \"ChargingScheduleStartTime\" IS NOT NULL OR \"ChargingScheduleEndTime\" IS NOT NULL OR \"BatteryHeatingScheduleMode\" IS NOT NULL OR \"BatteryHeatingScheduleStartTime\" IS NOT NULL");
+
+                    b.ToTable("TelemetrySnapshots");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.Trip", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<double?>("AvgMovingSpeedKmh")
+                        .HasColumnType("double precision");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double>("DistanceKm")
+                        .HasColumnType("double precision");
+
+                    b.Property<double>("EndLatitude")
+                        .HasColumnType("double precision");
+
+                    b.Property<double>("EndLongitude")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("EndPlaceJson")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("EndedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double?>("MaxSpeedKmh")
+                        .HasColumnType("double precision");
+
+                    b.Property<int?>("MovingSpeedSamples")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<double?>("OdometerEndKm")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("OdometerStartKm")
+                        .HasColumnType("double precision");
+
+                    b.Property<int>("PointCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PointsJson")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Purpose")
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<bool>("PurposeIsManual")
+                        .HasColumnType("boolean");
+
+                    b.Property<double>("StartLatitude")
+                        .HasColumnType("double precision");
+
+                    b.Property<double>("StartLongitude")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("StartPlaceJson")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("VehicleId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("VehicleId", "StartedAt")
+                        .IsUnique();
+
+                    b.ToTable("Trips");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.UserSettings", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("AccountKey")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Json")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Section")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Version")
+                        .IsConcurrencyToken()
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountKey", "Section")
+                        .IsUnique();
+
+                    b.ToTable("UserSettings");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.Vehicle", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ConfigJson")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LastMessageId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime?>("LastParkedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LicensePlate")
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)");
+
+                    b.Property<string>("Model")
+                        .HasColumnType("text");
+
+                    b.Property<double?>("ParkedLatitude")
+                        .HasColumnType("double precision");
+
+                    b.Property<double?>("ParkedLongitude")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("SaicUser")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Series")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("TelemetryCompactedUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("TripsRecordedUntil")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Vin")
+                        .IsRequired()
+                        .HasMaxLength(17)
+                        .HasColumnType("character varying(17)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Vin")
+                        .IsUnique();
+
+                    b.ToTable("Vehicles");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.ClimateSchedule", b =>
+                {
+                    b.HasOne("GarageStack.Core.Models.Vehicle", "Vehicle")
+                        .WithMany()
+                        .HasForeignKey("VehicleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Vehicle");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.CommutePlace", b =>
+                {
+                    b.HasOne("GarageStack.Core.Models.Vehicle", "Vehicle")
+                        .WithMany()
+                        .HasForeignKey("VehicleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Vehicle");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.MaintenanceItem", b =>
+                {
+                    b.HasOne("GarageStack.Core.Models.Vehicle", "Vehicle")
+                        .WithMany()
+                        .HasForeignKey("VehicleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Vehicle");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.MaintenanceLogEntry", b =>
+                {
+                    b.HasOne("GarageStack.Core.Models.MaintenanceItem", "MaintenanceItem")
+                        .WithMany("LogEntries")
+                        .HasForeignKey("MaintenanceItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MaintenanceItem");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.RdwVehicleInfo", b =>
+                {
+                    b.HasOne("GarageStack.Core.Models.Vehicle", "Vehicle")
+                        .WithMany()
+                        .HasForeignKey("VehicleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Vehicle");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.TelemetrySnapshot", b =>
+                {
+                    b.HasOne("GarageStack.Core.Models.Vehicle", "Vehicle")
+                        .WithMany("TelemetrySnapshots")
+                        .HasForeignKey("VehicleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Vehicle");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.Trip", b =>
+                {
+                    b.HasOne("GarageStack.Core.Models.Vehicle", "Vehicle")
+                        .WithMany()
+                        .HasForeignKey("VehicleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Vehicle");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.MaintenanceItem", b =>
+                {
+                    b.Navigation("LogEntries");
+                });
+
+            modelBuilder.Entity("GarageStack.Core.Models.Vehicle", b =>
+                {
+                    b.Navigation("TelemetrySnapshots");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/GarageStack.Data/Migrations/20261019185754_DropRawTopic.cs b/src/GarageStack.Data/Migrations/20261019185754_DropRawTopic.cs
new file mode 100644
index 00000000..d0f0cada
--- /dev/null
+++ b/src/GarageStack.Data/Migrations/20261019185754_DropRawTopic.cs
@@ -0,0 +1,28 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace GarageStack.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class DropRawTopic : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "RawTopic",
+                table: "TelemetrySnapshots");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "RawTopic",
+                table: "TelemetrySnapshots",
+                type: "text",
+                nullable: true);
+        }
+    }
+}
diff --git a/src/GarageStack.Data/Migrations/AppDbContextModelSnapshot.cs b/src/GarageStack.Data/Migrations/AppDbContextModelSnapshot.cs
index 0b37ca15..3995994e 100644
--- a/src/GarageStack.Data/Migrations/AppDbContextModelSnapshot.cs
+++ b/src/GarageStack.Data/Migrations/AppDbContextModelSnapshot.cs
@@ -838,9 +838,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<double?>("PowerUsageSinceLastCharge")
                         .HasColumnType("double precision");
 
-                    b.Property<string>("RawTopic")
-                        .HasColumnType("text");
-
                     b.Property<bool?>("RearLeftDoorOpen")
                         .HasColumnType("boolean");
 
diff --git a/src/GarageStack.Data/Repositories/TelemetryRepository.cs b/src/GarageStack.Data/Repositories/TelemetryRepository.cs
index 9c9abed3..8e9af15e 100644
--- a/src/GarageStack.Data/Repositories/TelemetryRepository.cs
+++ b/src/GarageStack.Data/Repositories/TelemetryRepository.cs
@@ -339,15 +339,6 @@ public async IAsyncEnumerable<TelemetrySnapshot> StreamAllAsync(
             yield return row;
     }
 
-    public async Task<IReadOnlyList<RawTopicStat>> GetRawTopicStatsAsync(int vehicleId, DateTime since, CancellationToken ct = default) =>
-        await db.TelemetrySnapshots
-            .AsNoTracking()
-            .Where(s => s.VehicleId == vehicleId && s.RecordedAt >= since && s.RawTopic != null)
-            .GroupBy(s => s.RawTopic!)
-            .OrderByDescending(g => g.Count())
-            .Select(g => new RawTopicStat(g.Key, g.Count(), g.Max(s => s.RecordedAt)))
-            .ToListAsync(ct);
-
     public async Task<VehicleAggregateStats> GetAggregateStatsAsync(int vehicleId, DateTime from, DateTime to, CancellationToken ct = default)
     {
         // Single grouped query instead of two round-trips: total count and the
diff --git a/src/GarageStack.Tests/TelemetryHandlerTests.cs b/src/GarageStack.Tests/TelemetryHandlerTests.cs
index d00e8692..0b0c3467 100644
--- a/src/GarageStack.Tests/TelemetryHandlerTests.cs
+++ b/src/GarageStack.Tests/TelemetryHandlerTests.cs
@@ -46,7 +46,6 @@ public Task MergeIntoAsync(long rowId, TelemetrySnapshot patch, CancellationToke
     public Task<DateTime?> GetFirstGpsFixAtAsync(int vehicleId, CancellationToken ct = default) => throw new NotImplementedException();
     public Task<double?> GetOdometerAtAsync(int vehicleId, DateTime at, CancellationToken ct = default) => throw new NotImplementedException();
     public Task<IReadOnlyList<StatusReading>> GetStatusReadingsAsync(int vehicleId, int count, CancellationToken ct = default) => throw new NotImplementedException();
-    public Task<IReadOnlyList<RawTopicStat>> GetRawTopicStatsAsync(int vehicleId, DateTime since, CancellationToken ct = default) => throw new NotImplementedException();
     public IAsyncEnumerable<TelemetrySnapshot> StreamAllAsync(int vehicleId, CancellationToken ct = default) => throw new NotImplementedException();
     public Task<PositionFix?> GetLatestPositionAsync(int vehicleId, CancellationToken ct = default) => throw new NotImplementedException();
     public Task<string?> GetChargingStopReasonAsync(int vehicleId, CancellationToken ct = default) => throw new NotImplementedException();
@@ -82,8 +81,8 @@ public async Task MergeOrAddTelemetryAsync_ConcurrentCallsSameVehicle_SecondCall
 
         // Fire both "concurrently", as two overlapping MQTT dispatches for the same vehicle would.
         await Task.WhenAll(
-            handler.MergeOrAddTelemetryAsync(1, patch1, "saic/vin/topic1", repo, ct),
-            handler.MergeOrAddTelemetryAsync(1, patch2, "saic/vin/topic2", repo, ct));
+            handler.MergeOrAddTelemetryAsync(1, patch1, repo, ct),
+            handler.MergeOrAddTelemetryAsync(1, patch2, repo, ct));
 
         Assert.Equal(1, repo.AddCount);
         Assert.Equal(1, repo.MergeCount);
diff --git a/src/GarageStack.Tests/TelemetryRepositoryTests.cs b/src/GarageStack.Tests/TelemetryRepositoryTests.cs
index 01d116b0..2e7e5323 100644
--- a/src/GarageStack.Tests/TelemetryRepositoryTests.cs
+++ b/src/GarageStack.Tests/TelemetryRepositoryTests.cs
@@ -595,44 +595,6 @@ public async Task MergeIntoAsync_MissingRow_InsertsNewRow()
         Assert.Equal(1, await db.TelemetrySnapshots.CountAsync(ct));
     }
 
-    // Regression: sorting after projecting into the RawTopicStat record could not be translated
-    // by EF and returned a 500 from /topics on PostgreSQL.
-    [Fact]
-    public async Task GetRawTopicStatsAsync_GroupsByTopic_MostFrequentFirst()
-    {
-        var ct = TestContext.Current.CancellationToken;
-        var (db, repo, vehicle) = await SetupAsync();
-        var t0 = new DateTime(2026, 1, 1, 10, 0, 0, DateTimeKind.Utc);
-        db.TelemetrySnapshots.AddRange(
-            new TelemetrySnapshot { VehicleId = vehicle.Id, RecordedAt = t0, RawTopic = "a", EvSocPercent = 1 },
-            new TelemetrySnapshot { VehicleId = vehicle.Id, RecordedAt = t0.AddMinutes(1), RawTopic = "b", EvSocPercent = 1 },
-            new TelemetrySnapshot { VehicleId = vehicle.Id, RecordedAt = t0.AddMinutes(2), RawTopic = "b", EvSocPercent = 1 },
-            new TelemetrySnapshot { VehicleId = vehicle.Id, RecordedAt = t0.AddMinutes(3), EvSocPercent = 1 });
-        await db.SaveChangesAsync(ct);
-
-        var stats = await repo.GetRawTopicStatsAsync(vehicle.Id, t0.AddDays(-7), ct);
-
-        Assert.Equal(2, stats.Count);
-        Assert.Equal(new RawTopicStat("b", 2, t0.AddMinutes(2)), stats[0]);
-        Assert.Equal(new RawTopicStat("a", 1, t0), stats[1]);
-    }
-
-    [Fact]
-    public async Task GetRawTopicStatsAsync_LeavesOutTopicsBeforeTheWindow()
-    {
-        var ct = TestContext.Current.CancellationToken;
-        var (db, repo, vehicle) = await SetupAsync();
-        var t0 = new DateTime(2026, 1, 1, 10, 0, 0, DateTimeKind.Utc);
-        db.TelemetrySnapshots.AddRange(
-            new TelemetrySnapshot { VehicleId = vehicle.Id, RecordedAt = t0.AddDays(-30), RawTopic = "old", EvSocPercent = 1 },
-            new TelemetrySnapshot { VehicleId = vehicle.Id, RecordedAt = t0, RawTopic = "recent", EvSocPercent = 1 });
-        await db.SaveChangesAsync(ct);
-
-        var stats = await repo.GetRawTopicStatsAsync(vehicle.Id, t0.AddDays(-7), ct);
-
-        Assert.Equal("recent", Assert.Single(stats).Topic);
-    }
-
     // Parked, the car keeps sending rows without a position; the newest fix is still the answer.
     [Fact]
     public async Task GetLatestPositionAsync_IsTheNewestFix_PastRowsWithoutOne()
diff --git a/src/GarageStack.Worker/Mqtt/TelemetryHandler.cs b/src/GarageStack.Worker/Mqtt/TelemetryHandler.cs
index befaa2d6..a5a7bd70 100644
--- a/src/GarageStack.Worker/Mqtt/TelemetryHandler.cs
+++ b/src/GarageStack.Worker/Mqtt/TelemetryHandler.cs
@@ -112,7 +112,7 @@ public async Task<bool> TryHandleAsync(MqttMessage message, CancellationToken ct
             patch.VehicleId = vehicleId;
             patch.RecordedAt = DateTime.UtcNow;
 
-            await MergeOrAddTelemetryAsync(vehicleId, patch, message.Topic, telemetryRepo, ct);
+            await MergeOrAddTelemetryAsync(vehicleId, patch, telemetryRepo, ct);
             await ParkAtThisPollsFixAsync(vehicleId, patch, telemetryRepo, resolved.Vehicles, ct);
 
             if (await ObserveEngineAsync(vin, patch, notifications, ct) == StateTransition.TurnedOff && vehicleId > 0)
@@ -159,7 +159,7 @@ internal async Task ParkAtThisPollsFixAsync(
     // Serializes read-await-write access to _mergeState per vehicle so two concurrently
     // dispatched messages for the same vehicle can't race on which row they merge into.
     internal async Task MergeOrAddTelemetryAsync(
-        int vehicleId, TelemetrySnapshot patch, string topic, ITelemetryRepository telemetryRepo, CancellationToken ct)
+        int vehicleId, TelemetrySnapshot patch, ITelemetryRepository telemetryRepo, CancellationToken ct)
     {
         var gate = _mergeGates.GetOrAdd(vehicleId, static _ => new SemaphoreSlim(1, 1));
         await gate.WaitAsync(ct);
@@ -173,7 +173,6 @@ internal async Task MergeOrAddTelemetryAsync(
             }
             else
             {
-                patch.RawTopic = topic;
                 var newId = await telemetryRepo.AddAsync(patch, ct);
                 _mergeState[vehicleId] = (newId, patch.RecordedAt);
             }

From b11cf9c444e05866c246661f4645405ea7df53ae Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 19 Oct 2026 19:01:15 +0000
Subject: [PATCH 6/7] build(frontend): move workbox-window to the dev
 dependencies

Nothing in the app imports it; it is there as a peer of vite-plugin-pwa, which
only the build uses.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L6DtW2eHhipteRopmy3cif
---
 frontend/package.json   | 6 +++---
 frontend/pnpm-lock.yaml | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/frontend/package.json b/frontend/package.json
index 266e8a23..87435a54 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -41,8 +41,7 @@
     "vue-router": "^5.4.0",
     "workbox-precaching": "^7.4.1",
     "workbox-routing": "^7.4.1",
-    "workbox-strategies": "^7.4.1",
-    "workbox-window": "^7.4.1"
+    "workbox-strategies": "^7.4.1"
   },
   "devDependencies": {
     "@playwright/test": "^1.64.1",
@@ -73,7 +72,8 @@
     "vite": "^8.3.4",
     "vite-plugin-pwa": "^2.0.0",
     "vitest": "^5.0.5",
-    "vue-tsc": "^3.3.13"
+    "vue-tsc": "^3.3.13",
+    "workbox-window": "^7.4.1"
   },
   "engines": {
     "node": "^22.13.0 || ^24.0.0 || >=26.0.0"
diff --git a/frontend/pnpm-lock.yaml b/frontend/pnpm-lock.yaml
index 3d01639e..06a54624 100644
--- a/frontend/pnpm-lock.yaml
+++ b/frontend/pnpm-lock.yaml
@@ -77,9 +77,6 @@ importers:
       workbox-strategies:
         specifier: ^7.4.1
         version: 7.4.1
-      workbox-window:
-        specifier: ^7.4.1
-        version: 7.4.1
     devDependencies:
       '@playwright/test':
         specifier: ^1.64.1
@@ -168,6 +165,9 @@ importers:
       vue-tsc:
         specifier: ^3.3.13
         version: 3.3.13(typescript@6.0.3)
+      workbox-window:
+        specifier: ^7.4.1
+        version: 7.4.1
 
 packages:
 

From e62c653eaeefb3a1f3874eab1b5f3b8a1c87c8d5 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 19 Oct 2026 19:02:36 +0000
Subject: [PATCH 7/7] docs(readme): add contents, what leaves your network, and
 a documentation index

The prerequisites named only some of the services GarageStack asks; a table
under Security defaults now lists each one, what it receives and how to switch
it off. Overpass backing off follows its Retry-After, and the README links
every other document, CONTRIBUTING and SECURITY among them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L6DtW2eHhipteRopmy3cif
---
 README.md | 61 ++++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 58 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index e06803bb..181ab468 100644
--- a/README.md
+++ b/README.md
@@ -41,6 +41,20 @@ The statistics, trip log, maintenance list and light theme are in the [screensho
 
 **Want to try it?** Read [MG iSmart account and session limits](#mg-ismart-account-and-session-limits) first, because GarageStack and the MG app cannot be signed in to the same account at once, then pick an [installation option](#installation). A single `docker run` is enough to get going.
 
+## Contents
+
+- [Features](#features)
+- [MG iSmart account and session limits](#mg-ismart-account-and-session-limits)
+- [Prerequisites](#prerequisites) and [Installation](#installation)
+- [Updating](#updating), [Monitoring](#monitoring) and [Backup and restore](#backup-and-restore)
+- [Push notifications](#push-notifications)
+- [Trip log](#trip-log)
+- [Dutch registration (RDW)](#dutch-registration-rdw)
+- [Homepage dashboard widget](#homepage-dashboard-widget) and [Read-only API tokens](#read-only-api-tokens)
+- [Map overlays](#map-overlays)
+- [Security defaults](#security-defaults), [HTTPS](#https) and [What leaves your network](#what-leaves-your-network)
+- [Documentation](#documentation)
+
 ## Features
 
 - **Live dashboard** -- Real-time vehicle telemetry displayed as configurable cards. Cards are automatically shown or hidden based on your vehicle type (HEV, PHEV, BEV) and can be reordered or toggled individually in the dashboard's edit mode. The car drawn on the dashboard takes your car's colour (Settings > Car colour), and the vehicle type can be set by hand under Settings > Vehicle type when detection gets it wrong.
@@ -148,7 +162,7 @@ Before installing, make sure the following are available on your host:
 - **Docker** 23.0 or later (or Podman with Docker Compose compatibility); the quick start's relative `./garagestack-data` mount needs 23.0
 - **Docker Compose** 2.20 or later (bundled with Docker Desktop; on Linux install the `docker-compose-plugin` package) -- required for Option B only
 - An **MG iSmart account** with your vehicle already linked in the official app
-- Outbound internet access on the host so the container can reach the SAIC API and (optionally) Overpass / Open Charge Map / the RDW
+- Outbound internet access on the host, for the MG servers and the map and lookup services listed under [What leaves your network](#what-leaves-your-network)
 
 ---
 
@@ -197,7 +211,7 @@ git clone https://github.com/joszz/garagestack.git
 cd garagestack
 ```
 
-**2. Create your `.env` file**
+#### 2. Create your `.env` file
 
 ```bash
 cp .env.example .env
@@ -475,7 +489,7 @@ Sourced from OpenStreetMap via the free [Overpass API](https://overpass-api.de)
 - Shows petrol and diesel stations from OSM data. Accuracy and completeness depend on OSM coverage in your area.
 - **Brand filter** -- select one or more brands (e.g. BP, Shell, Total) from the Filters panel. Only stations with a matching `brand` or `operator` OSM tag are shown; untagged stations are hidden when any filter is active. The filter is applied client-side with no additional API call.
 - The Worker pre-populates a 100 km radius around your car's last known position every 6 hours, so the layer loads instantly on first view without hitting Overpass.
-- If Overpass returns a 429 rate-limit response, the client backs off and retries automatically; existing cached data is shown in the meantime.
+- If Overpass answers that it is busy (429, 503 or 504), GarageStack waits as long as Overpass asks (its `Retry-After`) before asking again, and shows the cached data in the meantime. The same goes for every other service GarageStack asks.
 - Tile data is cached for 7 days. Zooming or panning to a new area triggers on-demand fetching for uncached tiles.
 - Hidden for BEV vehicles (petrol stations are not relevant).
 
@@ -546,6 +560,24 @@ A reading counts as over the limit only past 5 km/h above it: speedometers read
 - The optional Home Assistant broker login can only use the car's `saic/#` topics and read Home Assistant discovery, so it cannot publish fake discovery configs or reach anything else on the broker.
 - The frontend sends a strict Content-Security-Policy with every response, which allows scripts only from GarageStack itself. See [Behind a reverse proxy or CDN](#behind-a-reverse-proxy-or-cdn) for keeping it intact.
 
+### What leaves your network
+
+GarageStack runs on your own hardware, but a few features ask public services for what they know. Each one is listed here with what it sends, and each one except the MG servers can be switched off.
+
+| Service | Asked by | What it receives | Switch it off |
+| ------- | -------- | ---------------- | ------------- |
+| MG / SAIC iSmart API | the gateway | Your MG login, and the commands you send the car | Cannot be: it is where the car's data comes from |
+| [Nominatim](https://nominatim.openstreetmap.org) (place names) | the API | The coordinates of a trip's ends, or of where the car is parked, and the interface language | Settings > Map > Show place names, or `GEOCODING__ENABLED=false` |
+| [Valhalla](https://valhalla1.openstreetmap.de) (snapped trips, speed limits) | the API | The GPS fixes of the trip you select on the map | The map's filter panel > Snap to roads, or `MAPMATCHING__ENABLED=false` |
+| [Overpass](https://overpass-api.de) (fuel stations, service areas, speed cameras) | the API and the Worker | The map tiles being looked at, and the ones around the car (0.5° squares, not the car's position) | Turn the layers off; `SPEEDCAMERAS__ENABLED=false` removes the camera layer |
+| [Open Charge Map](https://openchargemap.org) (charging stations) | the API and the Worker | The map tiles being looked at, and your OCM key | Leave `OPENCHARGEMAP_API_KEY` empty |
+| [RDW open data](https://opendata.rdw.nl) (APK, recalls, insurance) | the API and the Worker | The licence plate, and the RDW's own codes for the recalls it lists | Off until `RDW_ENABLED=true` |
+| [GitHub](https://github.com/joszz/GarageStack/releases) (update notice) | the API | One request a day for the latest release | `UPDATE_CHECK_ENABLED=false` |
+| [OpenFreeMap](https://openfreemap.org) and [OpenStreetMap](https://www.openstreetmap.org) tiles (the basemap) | your browser | The map tiles your browser shows | Serve your own tiles, see [Basemap](#basemap) |
+| Your browser's push service (Google, Mozilla, Apple) | the Worker | Each notification, encrypted so only your browser can read it, and `VAPID_SUBJECT` | Leave the VAPID keys empty, or switch push off per device |
+
+Requests to the map, lookup and update services identify themselves as `GarageStack/1.0 (+https://github.com/joszz/GarageStack)`, as Nominatim's usage policy asks. Apart from what the table lists, the car's telemetry, its trips, your notifications and your settings stay on your server, unless you connect something to it yourself, such as Home Assistant.
+
 ### HTTPS
 
 GarageStack serves plain HTTP, which is all it needs on your own network, except for three things browsers keep for secure pages: push notifications, installing it as an app, and the service worker behind both. Browsers count `http://localhost` as secure, but not `http://192.168.1.100:8080`. To use those on your phone, give GarageStack an `https://` address: put it behind a reverse proxy that terminates TLS (examples below), or reach it through a VPN that provides HTTPS certificates. Over plain HTTP, Settings > Notifications says why push is not available.
@@ -591,4 +623,27 @@ Every proxy in front of the API (yours, and with Compose the frontend container)
 
 ---
 
+## Documentation
+
+For running GarageStack:
+
+- [`CONFIGURATION.md`](documentation/CONFIGURATION.md): every setting, with its default
+- [`AUTHENTICATION.md`](documentation/AUTHENTICATION.md): single sign-on, the built-in login, and provider examples
+- [`HOME_ASSISTANT.md`](documentation/HOME_ASSISTANT.md): the car in Home Assistant, through MQTT or an API token
+- [`WIDGET.md`](documentation/WIDGET.md): the gethomepage.dev widget
+- [`docker/all-in-one/README.md`](docker/all-in-one/README.md): the all-in-one image and Unraid
+- [Screenshots](documentation/screenshots/README.md) of the main pages
+
+For working on it:
+
+- [`CONTRIBUTING.md`](.github/CONTRIBUTING.md): setting up, tests, and adding a language
+- [`ARCHITECTURE.md`](documentation/ARCHITECTURE.md): how the services fit together
+- [`DEMO.md`](documentation/DEMO.md): the app on sample data, without a car, and the API reference
+- [`RELEASING.md`](documentation/RELEASING.md): versions, tags and release notes
+- [`ACCESSIBILITY.md`](.github/ACCESSIBILITY.md) and [`SECURITY.md`](.github/SECURITY.md), which also says how to report a vulnerability
+
+What changed in each version is on the [releases page](https://github.com/joszz/GarageStack/releases).
+
+---
+
 > **Development note:** This project was built with AI-assisted development (Claude Code). All code was reviewed, directed, and validated by a human developer throughout - AI acted as a coding assistant, not an autonomous agent.